repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

overkill: bug fixing

7f29c30531b3213bc30fd275429a8fd064adbeec

Oliver Jan Krylow <oliver@bugabinga.net> ·

SSH signature · not checked

Browse filesCompare with HEAD

Changed files (37)

CHANGELOG.md

Modified
2 2 # Changelog
4 4 ## Unreleased
6 +- Remove the unneeded `builtin-tools` extension and `/builtin-tools` command
6 7 - Update npm dependency lockfile to latest resolved package versions
7 -- Modernize extensions for Pi 0.84 API changes around agent sessions, provider headers, auth, and RPC message updates
8 +- Pin all Pi packages to 0.84.2 and modernize extensions for API changes around agent sessions, provider headers, auth, and RPC messages
8 9 - Fix The System README artifact path docs to show plural directories
9 10 - Make `/system init` deterministic with confirmation; it creates schema v3 config, plural artifact directories, and core files directly
10 11 - Add an optional project title to The System config; `/system init` writes it from the project directory name and rendered books use it
45 46 - Fix Pulse TAB completion
46 47 - Fix Notes so `/tree` restores notes from the selected branch and `/new` asks whether to carry pending notes into the new session
47 48 - Fix the uv extension on Windows by skipping incompatible shell shims while retaining command blocking
49 +- Fix Overkill's Aftermath skill picker so large skill lists scroll within the terminal
50 +- Fix Overkill Aftermath completion when mining finds insufficient tasks so it offers report-only actions and shows consistent artifact paths
51 +- Show persistent below-editor progress during long Overkill phases, including mining and aggregation calls
52 +- Keep transient TUI progress out of session history, remove duplicate status output, clear progress after discarding a run, and explain perfect-baseline completion
53 +- Bound target model calls to 900 seconds and checkpoint infrastructure failures for safe resume
54 +- Fix discard through a symlinked Pi agent directory
55 +- Label the bounded skill picker and show useful path tails
56 +- Open the Overkill Aftermath skill picker before scanning session history
57 +- Fix Overkill Aftermath mining so miners call structured output reliably, retry one malformed response, enforce the task schema, and reject wholly invalid nonempty results
58 +- Warn when unfinished Overkill runs may overlap work across Pi processes without duplicating warning prefixes or flagging unrelated suite authoring
59 +- Fix Overkill Aftermath session mining to use Pi's configured session directory
60 +- Add `/overkill suite <skill-path> <suite-dir>` to have Pi author and validate a standard Overkill evaluator suite
61 +- Make `/overkill suite` stop and ask before overwriting existing or concurrently modified evaluator files
62 +- Keep `/overkill suite` focused on the skill contract instead of unrelated Overkill implementation research
63 +- Show a compact colorized diff preview as soon as Overkill stages an optimized skill, with the bounded full diff available through Ctrl+O
64 +- Retry one malformed optimizer structured output before preserving an interrupted checkpoint
65 +- Keep generated starter suites to 3/2/2 cases with a small shared checker contract
66 +- Fix exact `/overkill aftermath` so autocomplete does not replace it with `aftermath status`
67 +- Report insufficient Aftermath task progress against the three-task minimum instead of 30
68 +- Label post-baseline failures as run failures instead of baseline failures
69 +- Canonicalize prospective suite-authoring destinations so project symlinks cannot escape the trusted project
70 +- Reject source or suite changes made after confirmation and before private run creation
71 +- Bound checker source to 256 KiB and disclose that trusted checkers inherit the process environment
72 +- Let users discard interrupted inactive suite runs that cannot safely resume
73 +- Reject malformed quoting and trailing command arguments with explicit usage errors
74 +- Report missing or corrupt review artifacts as a command error instead of throwing through Pi
75 +- Align rubric-judge generation constraints with validation and retry one malformed judgment in a fresh session
76 +- Bind every Aftermath mining and aggregation prompt to the confirmed skill capability instead of replaying unrelated recurring work
77 +- Replace repetitive Aftermath completion messages with one outcome-first summary, rounded scores, explicit no-diff reasons, and silent keep actions
49 79 ## 0.0.3

README.md

Modified
69 69 | Extension slug | Short explanation | README |
70 70 | ---------------- | ----------------------------------------------------------------------- | --------------------------------------------- |
71 71 | `angel` | Structured advisor and command guardrail for configured Pi model pairs. | [README](extensions/angel/README.md) |
72 -| `builtin-tools` | Toggle Pi builtin file-search tools. | [README](extensions/builtin-tools/README.md) |
73 72 | `cmprss` | Compress oversized tool results with exact retrieval. | [README](extensions/cmprss/README.md) |
74 73 | `context-size` | Context-window usage telemetry for Pi. | [README](extensions/context-size/README.md) |
75 74 | `cost` | Token and spend telemetry for Pi. | [README](extensions/cost/README.md) |

docs/super/specs/2026-07-03-cmprss-pi-extension-design.md

Modified
38 38 - `extensions/terse/index.ts`, `README.md`, and `package.json` for deterministic prompt injection.
39 39 - `extensions/tldr/index.ts` and tests for bounded UI/widget rendering.
40 40 - `extensions/goldfish/index.ts`, `README.md`, and `package.json` for session entries, commands, state replay, and UI state.
41 -- `extensions/builtin-tools/index.ts` for small command/hook style.
42 41 - `scripts/extensions.mjs` for extension package checks and README generation expectations.
44 43 ## Problem

docs/super/specs/2026-07-13-overkill-aftermath-design.md

Modified
36 36 1. Harvests every readable Pi session's persisted active branch plus the invoking branch snapshot.
37 37 2. Suggests one skill from deterministic local evidence.
38 38 3. Requires one confirmed target skill.
39 -4. Mines recurring checkable tasks in bounded model-call chunks.
39 +4. Mines recurring checkable tasks that require the confirmed skill's named capability in bounded model-call chunks.
40 40 5. Freezes task records and deterministic train, validation, and test splits.
41 41 6. Replays those tasks through the core Overkill engine.
42 42 7. Stages only a strictly validation-improving candidate.
300 300 `rubric` is a nonempty string of at most 8192 UTF-8 bytes.
302 -Unknown fields, unknown source IDs, malformed checks, mixed checks and rubric, and oversized records discard that proposal.
302 +The structured-output tool enforces this proposal schema before accepting miner or aggregator output.
304 +Every mining and aggregation prompt includes the frozen target skill name and description and rejects generic workflows or tasks belonging to other skills.
306 +Unknown source IDs and oversized records discard that proposal.
308 +If a nonempty model output yields no valid proposals, mining fails instead of reporting insufficient evidence.
304 310 A discarded proposal never reaches a split.
383 389 `rationale` is a string capped at 4096 UTF-8 bytes.
385 -Unknown fields or malformed output abort the affected evaluation as infrastructure failure.
391 +The generation schema enforces score range and rationale length before accepting output.
393 +Malformed output retries once in a fresh judge session within the existing judge-call limit, then aborts the affected evaluation as infrastructure failure.
387 395 Judge results are cached by task ID and lowercase SHA-256 response hash within the run.
467 475 4. Review session counts, digest handling, upper-bound calls, and source no-write guarantee.
468 476 5. Start or cancel.
469 477 6. Follow one compact status line during mining, replay, validation, final test, and staging.
470 -7. Review the final score delta and paths.
471 -8. Choose review diff, keep staged, or discard.
478 +7. Read one final summary: candidate outcome, rounded validation comparison or insufficient-task count, and report path.
479 +8. Choose review diff, done, or discard without a redundant retention acknowledgment.
473 481 The extension uses `ctx.ui.setStatus` and built-in `select` and `confirm` dialogs.
481 489 Print writes concise text progress directly.
491 +Collapsed completion status names the outcome rather than repeating `complete`, and displays scores with at most three decimals.
493 +The final summary omits the already-shown source path, states explicitly why no diff exists, and shows the report path once.
483 495 Review and path reporting follow the core mode contract.
485 497 The accepted mockup predates the final command rename; every visible `sleep` label maps to `aftermath`.
491 503 A harvest with some unreadable sessions continues and reports the count.
493 -Missing auth, model-resolution failure, malformed miner output, malformed judge output, failed child-session disposal, or persistence failure preserves the latest durable checkpoint.
505 +A malformed miner structured output retries once in a fresh isolated session.
507 +A second malformed miner output, missing auth, model-resolution failure, malformed judge output, failed child-session disposal, or persistence failure preserves the latest durable checkpoint.
495 509 Cancellation follows the shared core controller and checkpoint contract.

docs/super/specs/2026-07-13-overkill-skill-training-design.md

Modified
83 83 ## User Surface
85 85 ```text
86 +/overkill suite [skill-path] [suite-dir]
86 87 /overkill <skill-path> <suite-dir>
87 88 /overkill status
88 89 /overkill resume
91 92 /overkill cancel
95 +`/overkill suite [skill-path] [suite-dir]` asks Pi to author a project-contained starter suite with three train, two validation, and two test cases plus a generic checker under 120 lines.
94 97 `/overkill <skill-path> <suite-dir>` starts an explicit-suite run.
96 99 `status`, `resume`, `review`, and `discard` resolve the newest explicit-suite Overkill run linked from the active Pi session branch.
110 113 `review` shows a bounded unified diff in TUI and print modes and reports the full source, report, and staged paths in every mode.
112 -`discard` deletes only the selected Overkill run directory and appends a terminal custom entry.
115 +`discard` deletes only the selected inactive Overkill run directory and appends a terminal custom entry, including interrupted runs that can no longer resume safely.
114 117 Overkill registers no model-callable tool in the invoking Pi session.
175 178 The target session receives `/skill:<name> <task-prompt>` with normal prompt expansion enabled.
180 +Each target call has a 900-second deadline; timeout aborts the child session and preserves a resumable checkpoint.
177 182 References to sibling `scripts/`, `references/`, and `assets/` therefore resolve against the original skill package.
179 184 ## Model Contract
209 214 The current project must be trusted before Overkill reads the suite or executes `check.mjs`.
216 +`check.mjs` must be no larger than 256 KiB.
211 218 Each `items.json` file is a UTF-8 JSON array no larger than 1 MiB.
213 220 Each split contains between 1 and 64 items.
338 345 Its only active tool is a terminating TypeBox-backed `structured_output` tool.
340 -A step performs at most four optimizer calls:
347 +A step requests four valid optimizer outputs:
342 349 1. Reflect over failed trajectories when at least one failed trajectory exists.
343 350 2. Reflect over successful trajectories when at least one successful trajectory exists.
511 518 The user must confirm before baseline model calls or checker execution.
520 +Overkill revalidates source and suite fingerprints after confirmation and before private run creation.
513 522 JSON and print invocations require both explicit paths and treat the command itself as confirmation.
515 524 ### Progress
531 540 A custom entry renderer computes a bounded diff from the run ID and artifacts only in TUI mode.
542 +A staged completion shows up to four colorized changed lines immediately and expands through `app.tools.expand` to the full diff.
544 +Coloring uses Pi's native diff renderer, so it needs no platform-specific executable.
533 546 Print mode writes the same bounded unified diff.
535 548 The diff is capped at 200 lines and 32 KiB and ends with a truncation marker when capped.
565 578 Invalid paths, untrusted suites, malformed source or suite files, missing auth, and model-resolution failure stop before model calls.
567 -A model, checker, structured-output, persistence, or disposal infrastructure failure stops new work and preserves the latest durable checkpoint.
580 +Malformed optimizer structured output retries once for that phase within the existing 12-call run maximum.
582 +A model, checker, repeated structured-output, persistence, or disposal infrastructure failure stops new work and preserves the latest durable checkpoint.
569 584 An affected evaluation never changes scores or candidate selection.

extensions/builtin-tools/CHANGELOG.md

Deleted
deleted file mode 100644
1 -# Changelog
3 -## 0.0.3
5 -- Move workspace tooling from Bun scripts to mise and Vitest
6 -- Fix harness tests for import.meta.dirname, deps, and Chai matchers
7 -- Format markdown docs and update extension guides and demos
8 -- Tighten Biome lint rules and fix builtin-tools violations
10 -## 0.0.2
12 -- Ship release only; `extensions/builtin-tools` has no diff from `v0.0.1`
13 -- Keep `/builtin-tools` toggle for built-in `find`, `ls`, `grep`
14 -- Keep `session_start` auto-enable for available `find`, `ls`, `grep`
16 -## 0.1.0 - 2026-05-21
18 -- a40a427 prepare extensions for npm release
19 -- 133cb7d chore(pi):
20 - migrate extensions to earendil packages
21 -- 0cdb8ce feat(builtin-tools):
22 - enable search tools

extensions/builtin-tools/README.md

Deleted
deleted file mode 100644
1 -# builtin-tools
3 -Toggle Pi builtin file-search tools.
5 -## Install / load
7 -Loaded through the root pi-ext package.
8 -See [root README](../../README.md).
10 -## Commands / tools / settings
12 -Commands:
14 -- `/builtin-tools` — toggle built-in `find`, `ls`, and `grep` tools.
16 -Tools:
18 -- none
20 -Hooks:
22 -- `session_start` — enables available built-in `find`, `ls`, and `grep` tools.
24 -Settings:
26 -- none
28 -## Behavior
30 -On session start, available built-in `find`, `ls`, and `grep` tools are enabled.
32 -`/builtin-tools` checks registered tools, then toggles available built-ins:
34 -- if all are active:
35 - disables them
36 -- otherwise:
37 - enables them
39 -UI notifications report changed tools.
40 -If no target tools are registered, the command reports that.

extensions/builtin-tools/__tests__/harness.test.ts

Deleted
deleted file mode 100644
1 -import { afterEach, describe, expect, it } from "vitest";
2 -import { createTestSession, type TestSession } from "../../../test/harness";
3 -import builtinToolsExtension from "../index";
5 -describe("builtin-tools pi-test-harness", () => {
6 - let t: TestSession | undefined;
8 - afterEach(() => {
9 - t?.dispose();
10 - t = undefined;
11 - });
13 - it("loads in real Pi extension runtime", async () => {
14 - t = await createTestSession({
15 - extensionFactories: [builtinToolsExtension],
16 - });
18 - expect(t.session.extensionRunner.extensions).toHaveLength(1);
19 - });
20 -});

extensions/builtin-tools/index.ts

Deleted
deleted file mode 100644
1 -import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
3 -const TOOL_NAMES = ["find", "ls", "grep"] as const;
5 -function availableBuiltinToolNames(pi: ExtensionAPI): string[] {
6 - const available = new Set(pi.getAllTools().map((tool) => tool.name));
7 - return TOOL_NAMES.filter((name) => available.has(name));
8 -}
10 -function enableBuiltinTools(pi: ExtensionAPI): string[] {
11 - const active = new Set(pi.getActiveTools());
12 - const enabled: string[] = [];
14 - for (const name of availableBuiltinToolNames(pi)) {
15 - if (!active.has(name)) enabled.push(name);
16 - active.add(name);
17 - }
19 - pi.setActiveTools([...active]);
20 - return enabled;
21 -}
23 -function toggleBuiltinTools(pi: ExtensionAPI): {
24 - action: "enabled" | "disabled";
25 - tools: string[];
26 -} {
27 - const tools = availableBuiltinToolNames(pi);
28 - const active = new Set(pi.getActiveTools());
29 - const allEnabled =
30 - tools.length > 0 && tools.every((name) => active.has(name));
32 - if (allEnabled) {
33 - for (const name of tools) active.delete(name);
34 - pi.setActiveTools([...active]);
35 - return { action: "disabled", tools };
36 - }
38 - for (const name of tools) active.add(name);
39 - pi.setActiveTools([...active]);
40 - return { action: "enabled", tools };
41 -}
43 -export default function builtinToolsExtension(pi: ExtensionAPI) {
44 - pi.on("session_start", (_event, ctx) => {
45 - const enabled = enableBuiltinTools(pi);
46 - if (ctx.hasUI && enabled.length > 0) {
47 - ctx.ui.notify(`builtin-tools: enabled ${enabled.join(", ")}`, "info");
48 - }
49 - });
51 - pi.registerCommand("builtin-tools", {
52 - description: "Toggle built-in find, ls, and grep tools.",
53 - handler: async (_args, ctx) => {
54 - const { action, tools } = toggleBuiltinTools(pi);
55 - const suffix =
56 - tools.length > 0
57 - ? `${action} ${tools.join(", ")}`
58 - : "no built-in tools available";
59 - ctx.ui.notify(`builtin-tools: ${suffix}`, "info");
60 - },
61 - });
62 -}

extensions/builtin-tools/package.json

Deleted
deleted file mode 100644
1 -{
2 - "name": "@bugabinga/pi-ext-builtin-tools",
3 - "type": "module",
4 - "main": "index.ts",
5 - "peerDependencies": {
6 - "@earendil-works/pi-coding-agent": "*"
7 - },
8 - "license": "MIT",
9 - "description": "Toggle Pi builtin file-search tools.",
10 - "keywords": [
11 - "pi",
12 - "pi-extension"
13 - ],
14 - "devDependencies": {
15 - "@marcfargas/pi-test-harness": "^0.6.1",
16 - "vitest": "^4.1.9"
17 - },
18 - "scripts": {},
19 - "private": true
20 -}

extensions/overkill/README.md

Modified
1 1 # Overkill
3 -Overkill validates trusted explicit evaluator suites for loaded Pi skills without modifying source skills or suites.
3 +Overkill validates trusted explicit evaluator suites and mines target-relevant Aftermath tasks for loaded Pi skills without modifying source skills or suites.
5 -Load `extensions/overkill/index.ts`, then use `/overkill <skill-path> <suite-dir>`, `/overkill status`, or `/overkill discard`.
5 +Load `extensions/overkill/index.ts`, then use `/overkill suite [skill-path] [suite-dir]` to have Pi pick missing inputs and author a small 3/2/2 explicit suite, `/overkill <skill-path> <suite-dir>` to train, `/overkill aftermath [skill-path]` to mine session evidence, or the status, review, resume, cancel, and discard subcommands.
7 +Target model calls time out after 900 seconds and leave a resumable checkpoint.
8 +Malformed optimizer and rubric-judge output retry once within their existing call limits.
9 +Trusted checkers are capped at 256 KiB and execute with Pi's process environment after confirmation.
10 +Interrupted inactive runs may be discarded when changed inputs make resume unsafe.
12 +A staged candidate immediately shows a compact Pi-native diff preview; press `ctrl+o` for the bounded full diff.
13 +Aftermath completion states the outcome, rounded score comparison, diff availability, and report path once.
7 15 See [`index.ts`](./index.ts) and the [Phase 1 plan](../../docs/super/plans/2026-07-15-overkill-phase-1-contracts-run-state.md).

extensions/overkill/__tests__/acceptance.test.ts

Modified
384 384 await load(data, runtime);
385 385 await start(data);
387 + const progressWidgets = session?.events
388 + .uiCallsFor("setWidget")
389 + .filter((call) => call.args[0] === "overkill-progress");
390 + expect(
391 + progressWidgets?.some(
392 + (call) =>
393 + Array.isArray(call.args[1]) &&
394 + String(call.args[1][0]).startsWith("Overkill baseline"),
395 + ),
396 + ).toBe(true);
397 + expect(progressWidgets?.at(-1)?.args).toEqual([
398 + "overkill-progress",
399 + undefined,
400 + ]);
387 401 const entries = branchEntries();
388 402 expect(entries.at(-1)?.data).toMatchObject({
389 403 kind: "suite",
393 407 bestScore: 1,
395 409 const stages = entries.map((entry) => entry.data.stage);
396 - expect(stages).toEqual(
397 - expect.arrayContaining([
398 - "preflight",
399 - "baseline",
400 - "baseline_complete",
401 - "training",
402 - "final_test",
403 - "complete",
404 - ]),
405 - );
410 + expect(stages).toEqual(["preflight", "complete"]);
406 411 const runId = entries.at(-1)?.data.runId;
407 412 const runDirectory = join(data.agentDir, "overkill-runs", runId);
408 413 expect(relative(data.root, runDirectory).startsWith("..")).toBe(true);
488 493 expect(confirms[0]?.args[1]).toContain(`Source: ${data.skill}`);
489 494 expect(confirms[0]?.args[1]).toContain(`Suite: ${data.suite}`);
490 495 expect(confirms[0]?.args[1]).toContain(
491 - "trusted checker executes project code",
496 + "trusted checker executes project code with your process environment",
493 498 expect(confirms[0]?.args[1]).toContain(
494 499 "will not write the source skill or suite",
615 620 expect(terminalInput).toBeUndefined();
617 622 if (mode === "tui")
618 - expect(session?.events.uiCallsFor("setStatus").at(-1)?.args).toEqual([
619 - "overkill",
623 + expect(session?.events.uiCallsFor("setWidget").at(-1)?.args).toEqual([
624 + "overkill-progress",
620 625 undefined,
622 627 expect(process.listenerCount("SIGINT")).toBe(baselineSignals);
661 666 stage: "discarded",
662 667 terminal: "discarded",
669 + expect(session?.events.uiCallsFor("setWidget").at(-1)?.args).toEqual([
670 + "overkill-progress",
671 + undefined,
672 + ]);
673 + });
675 + it("discards an interrupted inactive suite run", async () => {
676 + const data = await fixture();
677 + let cancelled = false;
678 + const runtime = deterministicRuntime({
679 + onTarget: async (call) => {
680 + if (cancelled || !call.prompt.includes("validation 2")) return false;
681 + cancelled = true;
682 + await command("cancel");
683 + return true;
684 + },
685 + });
686 + await load(data, runtime);
687 + await start(data);
688 + const interrupted = branchEntries().at(-1)?.data;
689 + expect(interrupted).toMatchObject({ stage: "interrupted", terminal: null });
690 + const directory = join(data.agentDir, "overkill-runs", interrupted.runId);
691 + await command("discard");
692 + await expect(access(directory)).rejects.toThrow();
693 + expect(branchEntries().at(-1)?.data).toMatchObject({
694 + stage: "discarded",
695 + terminal: "discarded",
696 + });
666 699 it.each(["baseline", "optimizer", "validation", "final_test"] as const)(
667 - "cancels at %s, resumes exactly without repeating completed calls, and permits discard only when terminal",
700 + "cancels at %s and resumes exactly without repeating completed calls",
668 701 async (cancelStage) => {
669 702 const data = await fixture();
670 703 let cancelled = false;
715 748 expect(interruptedManifest.calls.optimizer).toBe(
716 749 runtime.optimizerCalls.length,
718 - await command("discard");
719 - await access(runDirectory);
720 - expect(session?.events.uiCallsFor("notify").at(-1)?.args[0]).toContain(
721 - "only terminal runs can be discarded",
722 - );
724 751 if (cancelStage === "optimizer") {
725 752 const interruptedEntry = branchEntries().at(-1);
726 753 if (!interruptedEntry)

extensions/overkill/__tests__/aftermath-acceptance.test.ts

Modified
643 643 const beforeRunLeaf = session?.session.sessionManager.getLeafId();
644 644 await command("aftermath");
646 + const progressWidgets = session?.events
647 + .uiCallsFor("setWidget")
648 + .filter((call) => call.args[0] === "overkill-progress");
649 + expect(
650 + progressWidgets?.some(
651 + (call) =>
652 + Array.isArray(call.args[1]) &&
653 + call.args[1][0] === "Overkill mining 0/1 · mining call 1 running",
654 + ),
655 + ).toBe(true);
656 + expect(progressWidgets?.at(-1)?.args).toEqual([
657 + "overkill-progress",
658 + undefined,
659 + ]);
646 660 const terminalEntry = runEntries().at(-1);
647 661 const terminal = terminalEntry?.data;
648 662 expect(terminal).toMatchObject({
668 682 expect(confirms[0]?.args[1]).toContain("without redaction");
669 683 expect(confirms[0]?.args[1]).toContain("16 KiB");
670 684 const selects = session?.events.uiCallsFor("select") ?? [];
671 - expect(selects[0]?.args[1]).toEqual([
672 - "use demo",
673 - "choose another",
674 - "cancel",
675 - ]);
685 + expect(selects[0]?.args[0]).toBe("Choose exactly one Aftermath skill.");
686 + expect(selects[0]?.args[1][0]).toContain("demo —");
676 687 const structured = runtime.calls.filter(
677 688 (call) => call.kind === "mining" || call.kind === "judge",
778 789 "without redaction",
780 791 const completion = session?.events.uiCallsFor("notify").at(-1)?.args[0];
781 - expect(completion).toContain(`Source: ${fixture.skill}`);
792 + expect(completion).not.toContain(`Source: ${fixture.skill}`);
782 793 expect(completion).toContain("Report:");
783 794 expect(completion).toContain("Staged:");
784 795 expect(completion).not.toContain(`--- ${fixture.skill}`);
800 811 if (title.startsWith("Aftermath suggests")) return "choose another";
801 812 if (title.startsWith("Choose exactly one"))
802 813 return items.find((item) => item.startsWith("other —"));
803 - if (title.startsWith("Aftermath complete")) return "keep staged";
814 + if (title.startsWith("Aftermath complete")) return "done";
804 815 return items[0];
810 821 await readFile(join(directory, "manifest.json"), "utf8"),
812 823 expect(manifest.target).toEqual({ name: "other", path: other });
813 - expect(session?.events.uiCallsFor("notify").at(-1)?.args[0]).toContain(
814 - "artifacts retained",
815 - );
824 + expect(
825 + session?.events
826 + .uiCallsFor("notify")
827 + .some((call) => String(call.args[0]).includes("retained")),
828 + ).toBe(false);
816 829 await access(join(directory, "staged-skill.md"));
860 873 const runtime = deterministicRuntime(fixture, { outcome: "insufficient" });
861 874 await load(fixture, runtime, {
862 875 select: (title, items) =>
863 - title.startsWith("Aftermath complete") ? "discard" : items[0],
876 + title.startsWith("Aftermath complete") ? "discard report" : items[0],
865 878 await command("aftermath");
866 879 const terminal = runEntries().at(-1)?.data;
898 911 select: (title, items) => {
899 912 if (title.startsWith("Aftermath suggests")) return "use demo";
900 913 if (title.startsWith("Resume incomplete")) return choice;
901 - if (title.startsWith("Aftermath complete")) return "keep staged";
914 + if (title.startsWith("Aftermath complete")) return "done";
902 915 return items[0];
999 1012 expect(terminalInput).toBeUndefined();
1001 1014 if (mode === "tui")
1002 - expect(session?.events.uiCallsFor("setStatus").at(-1)?.args).toEqual([
1003 - "overkill",
1015 + expect(session?.events.uiCallsFor("setWidget").at(-1)?.args).toEqual([
1016 + "overkill-progress",
1004 1017 undefined,
1006 1019 expect(process.listenerCount("SIGINT")).toBe(baselineSignals);
1015 1028 const directory = await runDirectory(fixture);
1016 1029 expect(runEntries().at(-1)?.data).toMatchObject({
1017 1030 terminal: "no_improvement",
1031 + completed: 2,
1032 + total: 3,
1019 1034 expect(runtime.calls.filter((call) => call.kind !== "mining")).toEqual([]);
1020 1035 await expect(access(join(directory, "staged-skill.md"))).rejects.toThrow();
1022 1037 await readFile(join(directory, "report.json"), "utf8"),
1024 1039 expect(report).toMatchObject({ terminal: "insufficient_tasks" });
1040 + const completion = session?.events
1041 + .uiCallsFor("select")
1042 + .find((call) =>
1043 + String(call.args[0]).startsWith("Aftermath complete — no candidate"),
1044 + );
1045 + expect(completion?.args[0]).toContain(
1046 + "Only 2/3 recurring tasks; replay was skipped.",
1047 + );
1048 + expect(completion?.args[0]).toContain(
1049 + `Report: ${join(directory, "report.json")}`,
1050 + );
1051 + expect(completion?.args[1]).toEqual(["done", "discard report"]);
1025 1052 await expectInputsUnchanged(fixture);
1050 1077 await readFile(join(directory, "report.json"), "utf8"),
1052 1079 expect(report).toMatchObject({ accepted: 0, terminal: "two_rejections" });
1080 + const completion = session?.events
1081 + .uiCallsFor("select")
1082 + .find((call) => String(call.args[0]).startsWith("Aftermath complete"));
1083 + expect(completion?.args[0]).toContain(
1084 + "Best validation 0 did not beat baseline 0; no diff was staged.",
1085 + );
1086 + expect(completion?.args[0]).toContain(
1087 + `Report: ${join(directory, "report.json")}`,
1088 + );
1053 1089 await expectInputsUnchanged(fixture);

extensions/overkill/__tests__/aftermath-commands.test.ts

Modified
8 8 getArgumentCompletions?: (prefix: string) => unknown;
11 -it("fails closed when persisted session listing fails", async () => {
11 +it("uses the active configured session directory and fails closed when listing fails", async () => {
12 + const listAll = vi.fn(async () => {
13 + throw new Error("unavailable");
14 + });
12 15 await expect(
13 16 harvestAftermath({
14 17 ctx: {
15 18 cwd: "/work",
16 19 sessionManager: {
20 + getSessionDir: () => "/configured/sessions",
17 21 getSessionId: () => "current",
18 22 getBranch: () => [],
20 24 } as never,
21 25 knownSkillPaths: new Map(),
22 26 sessionApi: {
23 - listAll: async () => {
24 - throw new Error("unavailable");
25 - },
27 + listAll,
26 28 open: () => {
27 29 throw new Error("unreachable");
31 33 ).rejects.toThrow("unavailable");
34 + expect(listAll).toHaveBeenCalledWith("/configured/sessions");
34 37 it("rejects an invalid explicit Aftermath path before harvesting session data", async () => {
80 83 registerEntryRenderer() {},
81 84 } as never);
85 + expect(command?.getArgumentCompletions?.("aftermath")).toBeNull();
82 86 expect(command?.getArgumentCompletions?.("aftermath re")).toEqual([
83 87 { value: "aftermath resume", label: "aftermath resume" },
84 88 { value: "aftermath review", label: "aftermath review" },

extensions/overkill/__tests__/aftermath-mining.test.ts

Modified
7 7 validateAndFreezeTasks,
8 8 } from "../lib/aftermath-mining.ts";
10 +const target = { name: "chrome-cdp", description: "Use live Chrome CDP." };
10 12 describe("Aftermath mining contracts", () => {
11 13 it("chunks consecutively and estimates recursive aggregation", () => {
12 14 expect(
26 28 const prompts: string[] = [];
27 29 const proposals = await mineTaskProposals({
28 30 digests: [{ sessionId: "a" }, { sessionId: "b" }],
29 - onCall: async () => {
30 - prompts.push("attempt persisted");
31 + target,
32 + onCall: async (phase) => {
33 + prompts.push(`attempt persisted:${phase}`);
32 35 async createSession() {
33 36 let listener: ((event: any) => void) | undefined;
53 56 expect(proposals).toEqual([{ intent: "x" }]);
54 57 expect(prompts).toEqual([
55 - "attempt persisted",
56 - 'phase:mine\nExtract no more than 10 recurring, checkable task proposals. Return only {"tasks": [...]}.\ndigests:[{"sessionId":"a"},{"sessionId":"b"}]',
58 + "attempt persisted:mining",
59 + expect.stringContaining(
60 + 'phase:mine\ntargetSkill:{"description":"Use live Chrome CDP.","name":"chrome-cdp"}\nPropose only recurring tasks whose correct completion requires this target skill',
61 + ),
65 + it("retries one malformed structured output in a fresh session", async () => {
66 + let sessions = 0;
67 + const attempts: number[] = [];
68 + const proposals = await mineTaskProposals({
69 + digests: [{ sessionId: "a" }],
70 + target,
71 + onCall: async (_phase, attempt) => {
72 + attempts.push(attempt);
73 + },
74 + async createSession() {
75 + sessions += 1;
76 + const current = sessions;
77 + let listener: ((event: any) => void) | undefined;
78 + return {
79 + subscribe(next: (event: any) => void) {
80 + listener = next;
81 + return () => {};
82 + },
83 + async prompt() {
84 + if (current === 1) return;
85 + listener?.({
86 + type: "tool_execution_end",
87 + toolName: "structured_output",
88 + isError: false,
89 + result: { details: { tasks: [{ intent: "recovered" }] } },
90 + });
91 + },
92 + async abort() {},
93 + dispose() {},
94 + };
95 + },
96 + });
98 + expect(proposals).toEqual([{ intent: "recovered" }]);
99 + expect(sessions).toBe(2);
100 + expect(attempts).toEqual([1, 2]);
101 + });
103 + it.each([
105 + "duplicate",
106 + (listener: (event: any) => void) => {
107 + const event = {
108 + type: "tool_execution_end",
109 + toolName: "structured_output",
110 + isError: false,
111 + result: { details: { tasks: [] } },
112 + };
113 + listener(event);
114 + listener(event);
115 + },
116 + "emitted 2",
117 + ],
119 + "error-only",
120 + (listener: (event: any) => void) =>
121 + listener({
122 + type: "tool_execution_end",
123 + toolName: "structured_output",
124 + isError: true,
125 + result: { details: { tasks: [] } },
126 + }),
127 + "emitted 0",
128 + ],
130 + "task-cap",
131 + (listener: (event: any) => void) =>
132 + listener({
133 + type: "tool_execution_end",
134 + toolName: "structured_output",
135 + isError: false,
136 + result: {
137 + details: { tasks: Array.from({ length: 11 }, () => ({})) },
138 + },
139 + }),
140 + "task cap",
141 + ],
142 + ] as const)(
143 + "rejects %s structured mining output after one retry",
144 + async (_name, emit, message) => {
145 + let disposed = 0;
146 + await expect(
147 + mineTaskProposals({
148 + digests: [{ sessionId: "a" }],
149 + target,
150 + async createSession() {
151 + let listener: ((event: any) => void) | undefined;
152 + return {
153 + subscribe(next: (event: any) => void) {
154 + listener = next;
155 + return () => {};
156 + },
157 + async prompt() {
158 + if (listener) emit(listener);
159 + },
160 + async abort() {},
161 + dispose() {
162 + disposed += 1;
163 + },
164 + };
165 + },
166 + }),
167 + ).rejects.toThrow(message);
168 + expect(disposed).toBe(2);
169 + },
170 + );
172 + it("does not retry pre-aborted mining", async () => {
173 + const controller = new AbortController();
174 + controller.abort();
175 + let sessions = 0;
176 + await expect(
177 + mineTaskProposals({
178 + digests: [{ sessionId: "a" }],
179 + target,
180 + signal: controller.signal,
181 + async createSession() {
182 + sessions += 1;
183 + return {
184 + subscribe() {
185 + return () => {};
186 + },
187 + async prompt() {},
188 + async abort() {},
189 + dispose() {},
190 + };
191 + },
192 + }),
193 + ).rejects.toThrow("cancelled");
194 + expect(sessions).toBe(1);
195 + });
60 197 it("freezes only recurring exact proposals with extension-derived IDs", () => {
61 198 const tasks = validateAndFreezeTasks({
62 199 proposals: [
81 218 expect(tasks[0]?.sourceSessionIds).toEqual(["a", "b"]);
221 + it("rejects a wholly incompatible nonempty miner schema", () => {
222 + expect(() =>
223 + validateAndFreezeTasks({
224 + proposals: [
226 + title: "Wrong schema",
227 + task: "Missing provenance and scorer",
228 + checks: ["not structured checks"],
229 + },
230 + ],
231 + harvestedSessionIds: new Set(["a", "b"]),
232 + }),
233 + ).toThrow("all 1 miner proposals violated the required task schema");
234 + });
84 236 it("normalizes every hashed string boundary before deduplication", () => {
85 237 const tasks = validateAndFreezeTasks({
86 238 proposals: [

extensions/overkill/__tests__/aftermath-scoring.test.ts

Modified
138 138 expect(judged.cacheKey).toBe(`task-abc:${responseHash("final response")}`);
139 139 expect(session.prompts).toHaveLength(1);
140 140 expect(session.prompts[0]).toContain('"judgePromptVersion":1');
141 + expect(session.prompts[0]).toContain("number from 0 through 1");
142 + expect(session.prompts[0]).toContain("at most 4096 UTF-8 bytes");
141 143 expect(session.prompts[0]).toContain("frozen context");
142 144 expect(session.disposed).toBe(1);
147 + it("retries one malformed judgment in a fresh session", async () => {
148 + let created = 0;
149 + let calls = 0;
150 + const sessions: Array<{ disposed: number }> = [];
151 + const result = await runRubricJudge(
153 + id: "task-retry",
154 + intent: "x",
155 + context: "y",
156 + sourceSessionIds: ["a", "b"],
157 + rubric: "z",
158 + },
159 + "response",
161 + async createSession() {
162 + const index = created++;
163 + const session = {
164 + disposed: 0,
165 + subscribe(listener: (event: any) => void) {
166 + this.listener = listener;
167 + return () => {};
168 + },
169 + async prompt() {
170 + this.listener({
171 + type: "tool_execution_end",
172 + toolName: "structured_output",
173 + isError: false,
174 + result: {
175 + details:
176 + index === 0
177 + ? { score: 2, passed: true, rationale: "bad" }
178 + : { score: 1, passed: true, rationale: "good" },
179 + },
180 + });
181 + },
182 + async abort() {},
183 + dispose() {
184 + this.disposed += 1;
185 + },
186 + };
187 + sessions.push(session);
188 + return session;
189 + },
190 + },
191 + undefined,
192 + async () => {
193 + calls += 1;
194 + },
195 + );
196 + expect(result).toMatchObject({ score: 1, passed: true, rationale: "good" });
197 + expect(created).toBe(2);
198 + expect(calls).toBe(2);
199 + expect(sessions.map((session) => session.disposed)).toEqual([1, 1]);
200 + });
145 202 it("rejects malformed judge output and disposes on abort", async () => {
146 203 const controller = new AbortController();
147 204 const session = {
178 235 expect(session.disposed).toBe(1);
238 + it.each([
240 + "duplicate",
241 + { score: 1, passed: true, rationale: "ok" },
242 + 2,
243 + "exactly one",
244 + ],
246 + "negative score",
247 + { score: -1, passed: false, rationale: "bad" },
248 + 1,
249 + "invalid",
250 + ],
251 + ["high score", { score: 2, passed: true, rationale: "bad" }, 1, "invalid"],
253 + "non-Boolean",
254 + { score: 1, passed: "yes", rationale: "bad" },
255 + 1,
256 + "invalid",
257 + ],
259 + "long rationale",
260 + { score: 1, passed: true, rationale: "x".repeat(8193) },
261 + 1,
262 + "invalid",
263 + ],
264 + ] as const)(
265 + "rejects %s rubric output",
266 + async (_name, details, emissions, message) => {
267 + const session = {
268 + subscribe(listener: (event: any) => void) {
269 + this.listener = listener;
270 + return () => {};
271 + },
272 + async prompt() {
273 + for (let index = 0; index < emissions; index += 1)
274 + this.listener({
275 + type: "tool_execution_end",
276 + toolName: "structured_output",
277 + isError: false,
278 + result: { details },
279 + });
280 + },
281 + async abort() {},
282 + dispose() {},
283 + };
284 + await expect(
285 + runRubricJudge(
287 + id: "task-invalid",
288 + intent: "x",
289 + context: "y",
290 + sourceSessionIds: ["a", "b"],
291 + rubric: "z",
292 + },
293 + "response",
295 + async createSession() {
296 + return session;
297 + },
298 + },
299 + ),
300 + ).rejects.toThrow(message);
301 + },
302 + );
181 304 it("preserves observed outcomes in immutable rubric prompts", async () => {
182 305 const session = {
183 306 recordedPrompt: "",

extensions/overkill/__tests__/checker.test.ts

Modified
146 146 ).rejects.toThrow("unknown");
149 + it.each([
150 + ["'not json'", "exactly one JSON object"],
151 + ["'[]'", "must be a JSON object"],
152 + ["JSON.stringify({ score: -1, passed: true })", "finite and in [0, 1]"],
153 + ["JSON.stringify({ score: 2, passed: true })", "finite and in [0, 1]"],
154 + ['\'{"score":1e999,"passed":true}\'', "finite and in [0, 1]"],
155 + ['JSON.stringify({ score: 1, passed: "yes" })', "passed must be Boolean"],
156 + ["JSON.stringify({ score: 1, passed: true, feedback: 2 })", "8 KiB"],
158 + 'JSON.stringify({ score: 1, passed: true, feedback: "x".repeat(8193) })',
159 + "8 KiB",
160 + ],
161 + ])("rejects checker result boundary %s", async (output, message) => {
162 + const invalid = await fixture(`process.stdout.write(${output});`);
163 + await expect(
164 + executeChecker({
165 + checkerPath: invalid.checkerPath,
166 + suitePath: invalid.suitePath,
167 + input: checkerInput,
168 + }),
169 + ).rejects.toThrow(message);
170 + });
149 172 it("rejects a checker result when any validated suite byte changes during use", async () => {
150 173 const mutable = await fixture(
151 174 "import { writeFileSync } from 'node:fs'; writeFileSync(new URL('./val/items.json', import.meta.url), '[{\"id\":\"changed\"}]'); process.stdout.write(JSON.stringify({ score: 1, passed: true }));",

extensions/overkill/__tests__/commands.test.ts

Modified
1 -import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
1 +import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
2 2 import { tmpdir } from "node:os";
3 3 import { join } from "node:path";
4 +import { visibleWidth } from "@earendil-works/pi-tui";
4 5 import { describe, expect, it } from "vitest";
5 -import overkill, { parseArguments } from "../index.ts";
6 +import overkill, {
7 + chooseLoadedSkill,
8 + parseArguments,
9 + unfinishedRunWarning,
10 +} from "../index.ts";
11 +import { createRunDirectory, persistManifest } from "../lib/run-state.ts";
7 13 type Command = {
8 14 handler: (args: string, ctx: any) => Promise<void>;
12 18 function setup(branch: unknown[] = [], loadedCommands: unknown[] = []) {
13 19 const commands = new Map<string, Command>();
14 20 const notices: Array<[string, string]> = [];
21 + const userMessages: string[] = [];
15 22 let next = 0;
16 23 const pi = {
17 24 on() {},
28 35 getThinkingLevel() {
29 36 return "off";
38 + sendUserMessage(message: string) {
39 + userMessages.push(message);
40 + },
32 42 overkill(pi as never);
33 43 const ctx = {
34 44 cwd: "/project",
45 + mode: "tui",
46 + hasUI: true,
35 47 model: undefined,
36 48 modelRegistry: {
37 49 async getAvailable() {
41 53 isProjectTrusted() {
42 54 return true;
56 + isIdle() {
57 + return true;
58 + },
44 59 sessionManager: {
45 60 getBranch() {
46 61 return branch;
53 68 notify(message: string, level: string) {
54 69 notices.push([message, level]);
71 + async select(_title: string, items: string[]) {
72 + return items[0];
73 + },
58 - return { branch, commands, ctx, notices };
76 + return { branch, commands, ctx, notices, userMessages };
61 79 function overkillCommand(state: ReturnType<typeof setup>): Command {
67 85 describe("/overkill Phase 3 command fixtures", () => {
68 - it("preserves Windows UNC paths", () => {
69 - for (const input of [
70 - "\\\\server\\share\\SKILL.md suite",
71 - '"\\\\server\\share\\SKILL.md" suite',
72 - ]) {
73 - expect(parseArguments(input)).toEqual([
74 - "\\\\server\\share\\SKILL.md",
75 - "suite",
76 - ]);
86 + it("parses quoted, empty, concatenated, and Windows path arguments", () => {
87 + expect(
88 + parseArguments(
89 + '"path with spaces/SKILL.md" "" pre"joined value" \\\\server\\share',
90 + ),
91 + ).toEqual([
92 + "path with spaces/SKILL.md",
93 + "",
94 + "prejoined value",
95 + "\\\\server\\share",
96 + ]);
97 + expect(() => parseArguments("'unterminated")).toThrow(
98 + "unterminated quoted argument",
99 + );
100 + });
102 + it("keeps a large Aftermath skill picker inside the terminal", async () => {
103 + const skills = Array.from({ length: 20 }, (_, index) => ({
104 + name: `skill-${String(index).padStart(2, "0")}`,
105 + path: `/very/long/skill/path/${index}/SKILL.md`,
106 + }));
107 + let rendered: string[] = [];
108 + const selected = await chooseLoadedSkill(
110 + mode: "tui",
111 + ui: {
112 + async custom(factory: any) {
113 + let result: string | null | undefined;
114 + const component = factory(
115 + { terminal: { rows: 12 }, requestRender() {} },
117 + bold: (text: string) => text,
118 + fg: (_color: string, text: string) => text,
119 + },
120 + {},
121 + (value: string | null) => {
122 + result = value;
123 + },
124 + );
125 + rendered = component.render(48);
126 + component.handleInput("\r");
127 + return result;
128 + },
129 + },
130 + } as any,
131 + skills,
132 + new Map(skills.map((skill) => [skill.path, skill.path])),
133 + "Aftermath",
134 + );
136 + expect(selected).toEqual(skills[0]);
137 + expect(rendered.length).toBeLessThanOrEqual(12);
138 + expect(rendered.some((line) => line.includes("(1/20)"))).toBe(true);
139 + expect(rendered.every((line) => visibleWidth(line) <= 48)).toBe(true);
140 + });
142 + it("returns no skill when the small picker is cancelled", async () => {
143 + const skills = [
144 + { name: "one", path: "/skills/one/SKILL.md" },
145 + { name: "two", path: "/skills/two/SKILL.md" },
146 + ];
147 + const selected = await chooseLoadedSkill(
149 + mode: "tui",
150 + ui: {
151 + async select() {
152 + return undefined;
153 + },
154 + },
155 + } as any,
156 + skills,
157 + new Map(skills.map((skill) => [skill.path, skill.path])),
158 + "Aftermath",
159 + );
160 + expect(selected).toBeUndefined();
161 + });
163 + it("warns about unfinished matching runs from other processes", async () => {
164 + const agentDir = await mkdtemp(
165 + join(tmpdir(), "overkill-parallel-warning-"),
166 + );
167 + try {
168 + const runId = "123e4567-e89b-12d3-a456-426614174000";
169 + const directory = await createRunDirectory(agentDir, runId);
170 + await persistManifest(directory, {
171 + version: 1,
172 + runId,
173 + kind: "suite",
174 + source: { path: "/source/SKILL.md", fingerprint: "a".repeat(64) },
175 + suite: { path: "/project/suite", fingerprint: "b".repeat(64) },
176 + model: { provider: "test", id: "model", thinking: "off" },
177 + sessionId: "session",
178 + linkEntryId: null,
179 + stage: "training",
180 + terminal: null,
181 + scores: {
182 + baseline: null,
183 + current: null,
184 + best: null,
185 + test: null,
186 + },
187 + calls: { target: 0, checker: 0, optimizer: 0, judge: 0 },
188 + artifacts: {
189 + baselineSnapshot: "baseline-snapshot.md",
190 + report: null,
191 + staged: null,
192 + },
193 + });
195 + const warning = await unfinishedRunWarning(
196 + "/source/SKILL.md",
197 + undefined,
198 + agentDir,
199 + );
200 + expect(warning).toContain("1 unfinished Overkill run");
201 + expect(warning).toContain(runId);
202 + expect(warning).toContain("other Pi processes");
203 + } finally {
204 + await rm(agentDir, { force: true, recursive: true });
239 + it("explains a perfect baseline without raw terminal jargon", async () => {
240 + const state = setup([
242 + id: "run",
243 + type: "custom",
244 + customType: "overkill-run",
245 + data: {
246 + version: 1,
247 + runId: "123e4567-e89b-12d3-a456-426614174000",
248 + kind: "suite",
249 + stage: "complete",
250 + terminal: "no_improvement",
251 + completed: 8,
252 + total: 8,
253 + bestScore: 1,
254 + reportPath: "/private/report.json",
255 + stagedPath: null,
256 + },
257 + },
258 + ]);
260 + await overkillCommand(state).handler("status", state.ctx);
262 + expect(state.notices).toEqual([
264 + "Overkill: complete | completed: 8/8 | outcome: baseline perfect; optimization skipped",
265 + "info",
266 + ],
267 + ]);
268 + });
111 270 it("reports checkpointed training and final-test progress for staged review without private evidence", async () => {
112 271 const state = setup([
198 357 expect(confirmation).toContain(
199 358 "Upper bound: 8 target calls, 12 optimizer calls.",
201 - expect(confirmation).toContain("trusted checker executes project code");
360 + expect(confirmation).toContain(
361 + "trusted checker executes project code with your process environment",
362 + );
202 363 expect(confirmation).toContain(
203 364 "will not write the source skill or suite",
372 + it("reports missing terminal review artifacts without throwing", async () => {
373 + const state = setup([
375 + id: "run",
376 + type: "custom",
377 + customType: "overkill-run",
378 + data: {
379 + version: 1,
380 + runId: "00000000-0000-4000-8000-000000000001",
381 + kind: "suite",
382 + stage: "complete",
383 + terminal: "staged",
384 + reportPath: null,
385 + stagedPath: null,
386 + },
387 + },
388 + ]);
389 + await overkillCommand(state).handler("review", state.ctx);
390 + expect(state.notices.at(-1)?.[0]).toContain("Overkill review failed:");
391 + });
211 393 it("emits headless status as a normal run entry instead of a no-op notification", async () => {
212 394 const state = setup([
238 - it("offers subcommand completion and rejects new runs without both explicit paths", async () => {
420 + it("rejects suite-authoring destinations that escape through a symlink", async () => {
421 + const root = await mkdtemp(join(tmpdir(), "overkill-suite-symlink-"));
422 + const outside = await mkdtemp(join(tmpdir(), "overkill-suite-outside-"));
423 + try {
424 + const skill = join(root, "SKILL.md");
425 + await writeFile(skill, "---\nname: demo\ndescription: Demo\n---\nBody\n");
426 + await symlink(
427 + outside,
428 + join(root, "escaped"),
429 + process.platform === "win32" ? "junction" : "dir",
430 + );
431 + const state = setup(
432 + [],
435 + name: "skill:demo",
436 + source: "skill",
437 + sourceInfo: { path: skill, scope: "user" },
438 + },
439 + ],
440 + );
441 + state.ctx.cwd = root;
442 + await overkillCommand(state).handler("suite SKILL.md escaped", state.ctx);
443 + expect(state.userMessages).toEqual([]);
444 + expect(state.notices.at(-1)?.[0]).toContain(
445 + "suite directory must be inside the project",
446 + );
447 + } finally {
448 + await rm(root, { force: true, recursive: true });
449 + await rm(outside, { force: true, recursive: true });
451 + });
453 + it("teaches Pi to author a standard suite for one loaded skill", async () => {
454 + const root = await mkdtemp(join(tmpdir(), "overkill-suite-authoring-"));
455 + try {
456 + const skill = join(root, "SKILL.md");
457 + await writeFile(skill, "---\nname: demo\ndescription: Demo\n---\nBody\n");
458 + const state = setup(
459 + [],
462 + name: "skill:demo",
463 + source: "skill",
464 + sourceInfo: { path: skill, scope: "user" },
465 + },
466 + ],
467 + );
468 + state.ctx.cwd = root;
469 + await overkillCommand(state).handler("suite SKILL.md eval", state.ctx);
471 + expect(state.userMessages).toHaveLength(1);
472 + expect(state.userMessages[0]).toContain(
473 + `skill at ${JSON.stringify(skill)}`,
474 + );
475 + expect(state.userMessages[0]).toContain(
476 + `Use ${JSON.stringify(join(root, "eval"))}`,
477 + );
478 + expect(state.userMessages[0]).toContain("train/items.json");
479 + expect(state.userMessages[0]).toContain("held-out test cases");
480 + expect(state.userMessages[0]).toContain(
481 + "exactly 3 train items, 2 validation items, and 2 test items",
482 + );
483 + expect(state.userMessages[0]).toContain(
484 + "suite contract below is authoritative",
485 + );
486 + expect(state.userMessages[0]).toContain("keep check.mjs under 120 lines");
487 + expect(state.userMessages[0]).toContain(
488 + "Do not design locks, atomic reservations, or repeated concurrency probes",
489 + );
490 + expect(state.userMessages[0]).toContain(
491 + "Do not start Overkill automatically",
492 + );
493 + } finally {
494 + await rm(root, { force: true, recursive: true });
496 + });
498 + it("picks a skill and lets Pi choose a project-local suite directory", async () => {
499 + const root = await mkdtemp(join(tmpdir(), "overkill-suite-picker-"));
500 + try {
501 + const skill = join(root, "skills", "demo", "SKILL.md");
502 + await mkdir(join(root, "skills", "demo"), { recursive: true });
503 + await writeFile(skill, "---\nname: demo\ndescription: Demo\n---\nBody\n");
504 + const state = setup(
505 + [],
508 + name: "skill:demo",
509 + source: "skill",
510 + sourceInfo: { path: skill, scope: "user" },
511 + },
512 + ],
513 + );
514 + state.ctx.cwd = root;
515 + await overkillCommand(state).handler("suite", state.ctx);
517 + expect(state.userMessages).toHaveLength(1);
518 + expect(state.userMessages[0]).toContain(
519 + `Choose a suite directory inside ${JSON.stringify(root)}`,
520 + );
521 + expect(state.userMessages[0]).toContain(
522 + JSON.stringify(join(root, ".overkill", "suites", "demo")),
523 + );
524 + } finally {
525 + await rm(root, { force: true, recursive: true });
527 + });
529 + it("keeps completion boundaries and rejects malformed or extra arguments", async () => {
239 530 const state = setup();
240 - expect(overkillCommand(state).getArgumentCompletions?.("st")).toEqual([
241 - { value: "status", label: "status" },
531 + const command = overkillCommand(state);
532 + expect(command.getArgumentCompletions?.("su")).toEqual([
533 + { value: "suite", label: "suite" },
243 - await overkillCommand(state).handler("only-one-path", state.ctx);
535 + expect(command.getArgumentCompletions?.("aftermathx")).toBeNull();
536 + await command.handler("only-one-path", state.ctx);
244 537 expect(state.notices.at(-1)).toEqual([
245 538 "Usage: /overkill <skill-path> <suite-dir>",
246 539 "error",
541 + await command.handler("status extra", state.ctx);
542 + expect(state.notices.at(-1)).toEqual(["Usage: /overkill status", "error"]);
543 + await command.handler("aftermath status extra", state.ctx);
544 + expect(state.notices.at(-1)).toEqual([
545 + "Usage: /overkill aftermath status",
546 + "error",
547 + ]);
548 + await command.handler("'unterminated", state.ctx);
549 + expect(state.notices.at(-1)).toEqual([
550 + "Overkill command failed: unterminated quoted argument",
551 + "error",
552 + ]);

extensions/overkill/__tests__/contracts.test.ts

Modified
131 131 expect(() => parseSourceSkill(Buffer.from("no frontmatter"))).toThrow(
132 132 "frontmatter",
134 + expect(() =>
135 + parseSourceSkill(
136 + Buffer.from("---\nname: INVALID\ndescription: Demo\n---\nBody\n"),
137 + ),
138 + ).toThrow("name");
139 + expect(() =>
140 + parseSourceSkill(
141 + Buffer.from("---\nname: valid\ndescription: Demo\n---\n \n"),
142 + ),
143 + ).toThrow("nonempty Markdown body");
144 + expect(() => parseSourceSkill(Buffer.from([0xff]))).toThrow("UTF-8");
134 145 expect(() => parseSourceSkill(Buffer.alloc(256 * 1024 + 1))).toThrow(
135 146 "256 KiB",
182 - it("rejects missing files, malformed items, duplicate IDs, and oversized prompts", async () => {
193 + it("rejects malformed item boundaries and oversized checker code", async () => {
194 + const cases: Array<[Buffer | string, string]> = [
195 + ["not json", "must be JSON"],
196 + [JSON.stringify({ id: "x", prompt: "x" }), "1 to 64"],
197 + [JSON.stringify([]), "1 to 64"],
199 + JSON.stringify(
200 + Array.from({ length: 65 }, (_, index) => ({
201 + id: `item-${index}`,
202 + prompt: "x",
203 + })),
204 + ),
205 + "1 to 64",
206 + ],
207 + [JSON.stringify([{ prompt: "x" }]), "nonempty id"],
208 + [JSON.stringify([{ id: "x", prompt: "" }]), "nonempty prompt"],
209 + [Buffer.from([0xff]), "UTF-8"],
210 + [Buffer.alloc(1024 * 1024 + 1, 0x20), "1 MiB"],
211 + ];
212 + for (const [contents, message] of cases) {
213 + const root = await temporaryDirectory();
214 + const suite = await writeSuite(root);
215 + await writeFile(join(suite, "val", "items.json"), contents);
216 + await expect(validateTrustedSuite(suite, root, true)).rejects.toThrow(
217 + message,
218 + );
220 + const root = await temporaryDirectory();
221 + const suite = await writeSuite(root);
222 + await writeFile(join(suite, "check.mjs"), Buffer.alloc(256 * 1024 + 1));
223 + await expect(validateTrustedSuite(suite, root, true)).rejects.toThrow(
224 + "check.mjs exceeds 256 KiB",
225 + );
226 + });
228 + it("rejects duplicate IDs and oversized prompts", async () => {
183 229 const root = await temporaryDirectory();
184 230 const suite = await writeSuite(root);
185 231 await writeFile(

extensions/overkill/__tests__/modes.test.ts

Modified
2 2 import { describe, expect, it } from "vitest";
3 3 import {
4 4 buildConfirmation,
5 5 buildReviewDiff,
6 + buildReviewDiffPreview,
6 7 formatProgress,
7 8 formatResultPaths,
8 9 upperBoundCalls,
20 21 splitCounts: { train: 2, val: 3, test: 4 },
22 23 ).toBe(
23 - "Source: /source/SKILL.md\nSuite: /project/suite\nSplits: train 2, validation 3, test 4\nUpper bound: 22 target calls, 12 optimizer calls.\nThe trusted checker executes project code.\nOverkill will not write the source skill or suite. Continue?",
24 + "Source: /source/SKILL.md\nSuite: /project/suite\nSplits: train 2, validation 3, test 4\nUpper bound: 22 target calls, 12 optimizer calls.\nThe trusted checker executes project code with your process environment.\nOverkill will not write the source skill or suite. Continue?",
33 34 bestScore: 0.5,
35 36 ).toBe("Overkill validation 1/3 best 0.5");
37 + expect(
38 + formatProgress({
39 + stage: "complete",
40 + terminal: "no_improvement",
41 + bestScore: 0.35000000000000003,
42 + }),
43 + ).toBe("Overkill no improvement best 0.35");
44 + expect(
45 + formatProgress({ stage: "complete", terminal: "staged", bestScore: 1 }),
46 + ).toBe("Overkill candidate staged best 1");
36 47 expect(
37 48 formatResultPaths({
38 49 sourcePath: "/source/SKILL.md",
63 74 expect(diff).toMatch(/…\[diff truncated\]\n$/);
77 + it("builds a compact changed-line preview for immediate completion feedback", () => {
78 + const preview = buildReviewDiffPreview(
79 + buildReviewDiff(
80 + "/source/SKILL.md",
81 + "/run/staged-skill.md",
82 + "same\nold one\nold two\nold three",
83 + "same\nnew one\nnew two\nnew three",
84 + ),
85 + );
86 + expect(preview).toBe(
87 + "-old one\n-old two\n-old three\n+new one\n… 2 more changed lines",
88 + );
89 + expect(preview).not.toContain("/source/SKILL.md");
90 + });
66 92 it("neutralizes ANSI and OSC terminal controls without changing ordinary Unicode", () => {
67 93 const diff = buildReviewDiff(
68 94 "/source/\u001b]0;owned\u0007SKILL.md",

extensions/overkill/__tests__/optimizer.test.ts

Modified
163 163 expect(order).toEqual(["persist", "prompt"]);
166 + it("retries one malformed proposal before continuing", async () => {
167 + const session = fakeSession([
168 + { proposal: "failure proposal", edits: [] },
169 + { proposal: "failure proposal" },
170 + { proposal: "merged" },
171 + { edits: [{ op: "append", content: "improve" }] },
172 + ]);
173 + const result = await runOptimizerStep(
175 + body: "body",
176 + failures: [{ id: "f", score: 0 }],
177 + successes: [],
178 + rejections: [],
179 + },
181 + async createSession() {
182 + return session;
183 + },
184 + },
185 + );
186 + expect(result.calls).toBe(4);
187 + expect(session.prompts[1]).toContain(
188 + "previous structured output was malformed",
189 + );
190 + });
166 192 it("uses fixed empty proposals without calls and rejects malformed terminating output", async () => {
167 193 const session = fakeSession([
168 194 { proposal: "failure proposal" },
169 195 { proposal: "merged" },
170 196 { edits: [] },
197 + { edits: [] },
172 199 await expect(
173 200 runOptimizerStep(
186 213 ).rejects.toThrow("one to four");
187 214 expect(
188 215 session.prompts.map((prompt) => prompt.match(/^phase:(\w+)/)?.[1]),
189 - ).toEqual(["failure", "merge", "ranking"]);
216 + ).toEqual(["failure", "merge", "ranking", "ranking"]);
190 217 expect(session.disposed).toBe(1);

extensions/overkill/__tests__/preflight.test.ts

Modified
2 2 import { access, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
3 3 import { tmpdir } from "node:os";
4 4 import { join } from "node:path";
5 5 import { afterEach, describe, expect, it } from "vitest";
6 -import { prepareSuiteRun } from "../lib/preflight.ts";
6 +import { fingerprintSource } from "../lib/checker.ts";
7 +import { inspectSuiteRun, prepareSuiteRun } from "../lib/preflight.ts";
8 9 const temporaryPaths: string[] = [];
69 70 ).rejects.toThrow();
73 + it("rejects source or suite changes after confirmation before artifact creation", async () => {
74 + const data = await fixture();
75 + const options = {
76 + ...data,
77 + cwd: data.root,
78 + commands: loadedCommands(data.skill),
79 + projectTrusted: true,
80 + sourcePath: data.skill,
81 + suitePath: data.suite,
82 + sessionId: "session",
83 + model: { provider: "test", id: "model", thinking: "off" },
84 + authAvailable: true,
85 + };
86 + const inspected = await inspectSuiteRun(options);
87 + await writeFile(
88 + join(data.suite, "val", "items.json"),
89 + JSON.stringify([{ id: "changed", prompt: "changed" }]),
90 + );
91 + await expect(
92 + prepareSuiteRun(options, {
93 + sourceFingerprint: fingerprintSource(inspected.sourceBytes),
94 + suiteFingerprint: inspected.suite.fingerprint ?? "",
95 + }),
96 + ).rejects.toThrow("changed after confirmation");
97 + await expect(
98 + access(join(data.agentDir, "overkill-runs")),
99 + ).rejects.toThrow();
100 + });
102 + it("rejects source changes after confirmation before artifact creation", async () => {
103 + const data = await fixture();
104 + const options = {
105 + ...data,
106 + cwd: data.root,
107 + commands: loadedCommands(data.skill),
108 + projectTrusted: true,
109 + sourcePath: data.skill,
110 + suitePath: data.suite,
111 + sessionId: "session",
112 + model: { provider: "test", id: "model", thinking: "off" },
113 + authAvailable: true,
114 + };
115 + const inspected = await inspectSuiteRun(options);
116 + await writeFile(
117 + data.skill,
118 + "---\nname: demo\ndescription: Demo\n---\nChanged\n",
119 + );
120 + await expect(
121 + prepareSuiteRun(options, {
122 + sourceFingerprint: fingerprintSource(inspected.sourceBytes),
123 + suiteFingerprint: inspected.suite.fingerprint ?? "",
124 + }),
125 + ).rejects.toThrow("changed after confirmation");
126 + await expect(
127 + access(join(data.agentDir, "overkill-runs")),
128 + ).rejects.toThrow();
129 + });
72 131 it("creates only private metadata after canonical source and trusted suite validation", async () => {
73 132 const data = await fixture();
74 133 const run = await prepareSuiteRun({

extensions/overkill/__tests__/rollouts.test.ts

Modified
2 2 import { createHash } from "node:crypto";
3 3 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
4 4 import { tmpdir } from "node:os";
5 5 import { join } from "node:path";
6 -import { afterEach, describe, expect, it } from "vitest";
6 +import { afterEach, describe, expect, it, vi } from "vitest";
7 7 import { fingerprintSource } from "../lib/checker.ts";
8 8 import {
9 9 createIsolatedTargetSession,
10 + promptTarget,
10 11 runSplitRollout,
11 12 runValidationBaseline,
13 + TARGET_CALL_TIMEOUT_MS,
12 14 writeCandidateSnapshot,
13 15 } from "../lib/rollouts.ts";
14 16 import { persistScoreCache, readBaselineCheckpoint } from "../lib/run-state.ts";
82 84 describe("isolated target session", () => {
85 + it("aborts a target call that exceeds the fixed deadline", async () => {
86 + expect(TARGET_CALL_TIMEOUT_MS).toBe(900_000);
87 + vi.useFakeTimers();
88 + try {
89 + const target = targetSession();
90 + target.prompt = async function (prompt: string, options?: unknown) {
91 + this.prompts.push([prompt, options]);
92 + await new Promise<void>(() => {});
93 + };
94 + const result = promptTarget(target, "slow");
95 + const rejection = expect(result).rejects.toThrow(
96 + `target rollout timed out after ${TARGET_CALL_TIMEOUT_MS / 1000}s`,
97 + );
98 + await vi.advanceTimersByTimeAsync(TARGET_CALL_TIMEOUT_MS);
99 + await rejection;
100 + expect(target.aborted).toBe(1);
101 + } finally {
102 + vi.useRealTimers();
104 + });
83 106 it("uses a candidate-only normal skill loader with frozen model, thinking, and exactly read-only tools", async () => {
84 107 const directory = await temporaryDirectory();
85 108 const snapshot = await writeCandidateSnapshot({ directory, source });

extensions/overkill/__tests__/run-state.test.ts

Modified
1 -import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
1 +import {
2 + access,
3 + mkdir,
4 + mkdtemp,
5 + readFile,
6 + rm,
7 + symlink,
8 + writeFile,
9 +} from "node:fs/promises";
2 10 import { tmpdir } from "node:os";
3 11 import { join } from "node:path";
4 12 import { afterEach, describe, expect, it } from "vitest";
185 193 await expect(readFile(join(directory, "manifest.json"))).rejects.toThrow();
196 + it("discards through a symlinked agent directory without weakening containment", async () => {
197 + const root = await temporaryDirectory();
198 + const agentDir = join(root, "agent");
199 + const alias = join(root, "agent-link");
200 + await mkdir(agentDir);
201 + await symlink(agentDir, alias, "junction");
202 + const directory = await createRunDirectory(agentDir, manifest.runId);
204 + await discardRun(
205 + join(alias, "overkill-runs"),
206 + join(alias, "overkill-runs", manifest.runId),
207 + );
209 + await expect(access(directory)).rejects.toThrow();
210 + });
188 212 it("discards only a run linked by its manifest to the active session branch", async () => {
189 213 const agentDir = await temporaryDirectory();
190 214 const directory = await createRunDirectory(agentDir, manifest.runId);

extensions/overkill/__tests__/training.test.ts

Modified
16 16 describe("strict optimizer schedule", () => {
17 + it.each([
18 + [[]],
19 + [[score("x", -0.1)]],
20 + [[score("x", 1.1)]],
21 + [[score("x", NaN)]],
22 + [[score("x", Infinity)]],
23 + ])("rejects empty or invalid baseline scores %#", (baseline) => {
24 + expect(() => createTrainingState({ body: "body", baseline })).toThrow(
25 + /scores|invalid score/u,
26 + );
27 + });
17 29 it("uses full train and validation arithmetic scoring, accepts only strict improvements, then reports one test", async () => {
18 30 const calls: Array<[string, string]> = [];
19 31 const result = await runTrainingSchedule(

extensions/overkill/index.ts

Modified
1 1 import { createHash } from "node:crypto";
2 2 import { writeSync } from "node:fs";
3 -import { readFile, realpath } from "node:fs/promises";
4 -import { join, resolve } from "node:path";
3 +import { readdir, readFile, realpath } from "node:fs/promises";
4 +import {
5 + basename,
6 + dirname,
7 + extname,
8 + isAbsolute,
9 + join,
10 + relative,
11 + resolve,
12 +} from "node:path";
5 13 import {
6 14 type ExtensionAPI,
7 15 type ExtensionCommandContext,
8 16 getAgentDir,
9 17 keyHint,
18 + renderDiff,
10 19 SessionManager,
11 20 } from "@earendil-works/pi-coding-agent";
12 -import { Key, matchesKey, Text } from "@earendil-works/pi-tui";
21 +import { Key, matchesKey, SelectList, Text } from "@earendil-works/pi-tui";
13 22 import {
14 23 buildDigest,
15 24 type Digest,
63 72 import {
64 73 buildConfirmation,
65 74 buildReviewDiff,
75 + buildReviewDiffPreview,
66 76 formatProgress,
67 77 formatResultPaths,
78 + formatScore,
68 79 sanitizeTerminalText,
69 80 upperBoundCalls,
70 81 } from "./lib/modes.ts";
113 124 const SUBCOMMANDS = [
114 125 "aftermath",
126 + "suite",
115 127 "status",
116 128 "resume",
117 129 "review",
144 156 export type AftermathSessionApi = {
145 - listAll: () => Promise<Array<{ path: string; id: string }>>;
146 - open: (path: string) => {
157 + listAll: (
158 + sessionDir?: string,
159 + ) => Promise<Array<{ path: string; id: string }>>;
160 + open: (
161 + path: string,
162 + sessionDir?: string,
163 + ) => {
147 164 getBranch: () => unknown[];
148 165 getSessionId: () => string;
149 166 getCwd: () => string;
255 +export function buildSuiteAuthoringPrompt(
256 + sourcePath: string,
257 + suitePath: string | undefined,
258 + projectRoot: string,
259 +): string {
260 + const sourceName = basename(sourcePath);
261 + const skillName =
262 + sourceName === "SKILL.md"
263 + ? basename(dirname(sourcePath))
264 + : basename(sourceName, extname(sourceName));
265 + const destination = suitePath
266 + ? `Use ${JSON.stringify(suitePath)} as the suite directory.`
267 + : `Choose a suite directory inside ${JSON.stringify(projectRoot)}. Prefer an established project evaluator location; otherwise use the project-local scratch directory ${JSON.stringify(join(projectRoot, ".overkill", "suites", skillName))}.`;
268 + return `Create a trusted explicit evaluator suite for the loaded Pi skill at ${JSON.stringify(sourcePath)}.
269 +${destination}
271 +Read the complete skill and only its directly referenced files needed to understand behavior.
272 +The suite contract below is authoritative; do not inspect Overkill implementation or unrelated project documentation.
273 +Inspect the destination once immediately before writing; if evaluator files already exist or appear concurrently modified, stop and ask rather than overwriting them.
274 +Do not design locks, atomic reservations, or repeated concurrency probes.
275 +After that single inspection, write the four files immediately without narrating a plan.
276 +Create exactly this layout and nothing else inside the suite directory:
277 +- train/items.json
278 +- val/items.json
279 +- test/items.json
280 +- check.mjs
282 +Create a small first suite: exactly 3 train items, 2 validation items, and 2 test items, with globally unique nonempty string ids and nonempty prompts no larger than 16 KiB.
283 +Add checker-owned expected fields when useful.
284 +Use train cases for optimization, validation cases for candidate selection, and held-out test cases for final evaluation; keep scenarios distinct across splits.
285 +Prioritize the skill's highest-risk and most representative successful and failure workflows; report omitted coverage instead of adding more cases.
286 +Keep each item concise and use a small shared expectation vocabulary such as exact, required substrings, forbidden substrings, or simple patterns.
287 +Do not design a domain-specific testing framework.
288 +The checker must read one JSON object from stdin, inspect item, response, trajectory, and calledTools, then write exactly one JSON object with score in [0,1], Boolean passed, and optional feedback.
289 +Write all four files before refining them, and keep check.mjs under 120 lines.
290 +Use only Node.js standard library in check.mjs.
291 +Keep checks bounded, cross-platform, and independent of network, credentials, mutable external state, and the source skill's exact wording.
292 +Do not weaken trust-boundary, security, data-loss, or required human-confirmation behavior.
293 +Validate the JSON and checker locally with one passing and one failing input.
294 +Do not start Overkill automatically.
295 +Summarize coverage, limitations, and the exact /overkill <skill-path> <suite-dir> command the user should run after reviewing check.mjs.`;
238 298 export function parseArguments(input: string): string[] {
239 299 const parts: string[] = [];
240 - const expression =
241 - /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
242 - let match = expression.exec(input);
243 - while (match !== null) {
244 - const token = match[1] ?? match[2] ?? match[3];
245 - if (token !== undefined) {
246 - const quoted = match[1] !== undefined || match[2] !== undefined;
247 - parts.push(quoted ? token.replace(/\\(["'])/g, "$1") : token);
300 + let index = 0;
301 + while (index < input.length) {
302 + while (/\s/u.test(input[index] ?? "")) index += 1;
303 + if (index >= input.length) break;
304 + let token = "";
305 + while (index < input.length && !/\s/u.test(input[index] ?? "")) {
306 + const quote = input[index];
307 + if (quote !== '"' && quote !== "'") {
308 + token += quote;
309 + index += 1;
310 + continue;
312 + index += 1;
313 + let closed = false;
314 + while (index < input.length) {
315 + const character = input[index];
316 + if (character === quote) {
317 + closed = true;
318 + index += 1;
319 + break;
321 + if (character === "\\" && input[index + 1] === quote) {
322 + token += quote;
323 + index += 2;
324 + } else {
325 + token += character;
326 + index += 1;
329 + if (!closed) throw new Error("unterminated quoted argument");
249 - match = expression.exec(input);
331 + parts.push(token);
251 333 return parts;
336 +async function canonicalProspectivePath(path: string): Promise<string> {
337 + let existing = resolve(path);
338 + const missing: string[] = [];
339 + while (true) {
340 + try {
341 + return resolve(await realpath(existing), ...missing);
342 + } catch (error) {
343 + if (
344 + !(error instanceof Error) ||
345 + !("code" in error) ||
346 + error.code !== "ENOENT"
348 + throw error;
350 + const parent = dirname(existing);
351 + if (parent === existing) throw new Error("path has no existing ancestor");
352 + missing.unshift(basename(existing));
353 + existing = parent;
254 357 function runEntry(
255 358 run: {
256 359 manifest: {
302 405 return selectNewestAftermathRun(ctx.sessionManager.getBranch());
408 +export async function unfinishedRunWarning(
409 + sourcePath: string | undefined,
410 + suitePath?: string,
411 + agentDir = getAgentDir(),
412 +): Promise<string | undefined> {
413 + const root = join(agentDir, "overkill-runs");
414 + const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
415 + const runIds: string[] = [];
416 + for (const entry of entries) {
417 + if (!entry.isDirectory()) continue;
418 + const manifest = await readManifest(join(root, entry.name)).catch(
419 + () => undefined,
420 + );
421 + if (
422 + manifest?.terminal === null &&
423 + ((sourcePath !== undefined && manifest.source.path === sourcePath) ||
424 + (suitePath !== undefined && manifest.suite?.path === suitePath))
426 + runIds.push(manifest.runId);
428 + if (runIds.length === 0) return undefined;
429 + return `${runIds.length} unfinished Overkill run${runIds.length === 1 ? "" : "s"} already target this skill or suite (${runIds.slice(0, 3).join(", ")}${runIds.length > 3 ? ", …" : ""}). They may be active in other Pi processes; parallel runs duplicate model cost, and suite edits can invalidate running evaluations.`;
305 432 function statusMessage(run: RunEntry): string {
433 + if (
434 + run.kind === "suite" &&
435 + run.stage === "complete" &&
436 + run.terminal === "no_improvement" &&
437 + run.bestScore === 1
439 + return `Overkill: complete | completed: ${run.completed ?? 0}${run.total === undefined ? "" : `/${run.total}`} | outcome: baseline perfect; optimization skipped`;
306 440 const fields = [`Overkill: ${run.stage}`];
307 441 if (run.completed !== undefined)
308 442 fields.push(
333 467 pi.appendEntry("overkill-run", entry);
470 +function showProgress(ctx: ExtensionCommandContext, text: string): void {
471 + const mode = commandMode(ctx);
472 + if (mode === "rpc") ctx.ui.setStatus("overkill", text);
473 + if (mode === "tui")
474 + ctx.ui.setWidget("overkill-progress", [text], {
475 + placement: "belowEditor",
476 + });
336 479 function appendProgress(
337 480 pi: ExtensionAPI,
338 481 ctx: ExtensionCommandContext,
339 482 entry: RunEntry,
340 483 ): void {
341 - appendProgressEntry(pi, entry);
342 484 const mode = commandMode(ctx);
343 - if (mode === "tui" || mode === "rpc")
344 - ctx.ui.setStatus("overkill", formatProgress(entry));
345 - else if (mode === "print") writePrint(formatProgress(entry));
485 + const durable =
486 + entry.terminal !== null ||
487 + entry.stage === "preflight" ||
488 + entry.stage === "interrupted" ||
489 + (entry.kind === "aftermath" &&
490 + entry.stage === "mining" &&
491 + entry.completed === undefined);
492 + if (mode !== "tui" || durable) appendProgressEntry(pi, entry);
493 + const progress = formatProgress(entry);
494 + showProgress(ctx, progress);
495 + if (mode === "print") writePrint(progress);
348 498 function clearProgress(ctx: ExtensionCommandContext): void {
349 - if (commandMode(ctx) === "tui" || commandMode(ctx) === "rpc")
350 - ctx.ui.setStatus("overkill", undefined);
499 + if (commandMode(ctx) === "rpc") ctx.ui.setStatus("overkill", undefined);
500 + if (commandMode(ctx) === "tui")
501 + ctx.ui.setWidget("overkill-progress", undefined);
353 504 function requestCancellation(active: ActiveRun): void {
403 554 await active.interrupt?.();
404 555 throw new RolloutCancelledError();
406 - if (active.kind === "aftermath") {
407 - try {
408 - await active.interrupt?.();
409 - } catch {
410 - // Preserve the original infrastructure failure.
557 + try {
558 + await active.interrupt?.();
559 + } catch {
560 + // Preserve the original infrastructure failure.
413 562 throw error;
414 563 } finally {
462 611 targetModel: unknown;
463 612 taskAdapter?: CoreTaskAdapter;
464 613 reportExtras?: () => Record<string, unknown>;
614 + deferCompletionNotice?: boolean;
465 615 }): Promise<void> {
466 616 const { ctx, manifest } = options;
467 617 const itemsFor = (split: "train" | "validation" | "test") =>
579 729 if (controller.signal.aborted) throw new RolloutCancelledError();
580 730 if (!active.suppressOutput)
581 731 appendProgress(options.pi, ctx, runEntry({ manifest }, progress));
582 - if (commandMode(ctx) !== "json" && commandMode(ctx) !== "print")
583 - ctx.ui.notify(`Overkill validation baseline: ${result.mean}`, "info");
584 732 if (result.mean === 1) {
585 733 const reportPath = await persistFinalReport(options.directory, {
586 734 version: 1,
609 757 reportPath,
610 758 stagedPath: null,
612 - if (commandMode(ctx) === "print") writePrint(paths);
613 - else if (commandMode(ctx) !== "json") ctx.ui.notify(paths, "info");
760 + if (commandMode(ctx) === "print")
761 + writePrint(
762 + `Baseline already scores 1; no strictly better candidate exists, so optimization was skipped.\n${paths}`,
763 + );
764 + else if (
765 + commandMode(ctx) !== "json" &&
766 + !options.deferCompletionNotice
768 + ctx.ui.notify(
769 + "Baseline already scores 1; no strictly better candidate exists, so optimization was skipped.",
770 + "info",
771 + );
615 773 return;
930 1088 stagedPath,
932 1090 if (commandMode(ctx) === "print") writePrint(paths);
933 - else if (commandMode(ctx) !== "json") ctx.ui.notify(paths, "info");
1091 + else if (commandMode(ctx) !== "json" && !options.deferCompletionNotice)
1092 + ctx.ui.notify(paths, "info");
936 1095 async function splitScores(
1013 1172 const api =
1014 1173 options.sessionApi ??
1015 1174 (SessionManager as unknown as NonNullable<typeof options.sessionApi>);
1016 - const listed = await api.listAll();
1175 + const sessionDir = options.ctx.sessionManager.getSessionDir();
1176 + const listed = await api.listAll(sessionDir);
1017 1177 const snapshots = new Map<string, Digest>();
1018 1178 const unreadableIds = new Set<string>();
1019 1179 for (const listedSession of listed) {
1021 - const session = api.open(listedSession.path);
1181 + const session = api.open(listedSession.path, sessionDir);
1022 1182 const id = session.getSessionId();
1023 1183 snapshots.set(
1058 -function loadedSkills(pi: ExtensionAPI): Array<{ name: string; path: string }> {
1218 +type LoadedSkillTarget = { name: string; path: string };
1220 +function loadedSkills(pi: ExtensionAPI): LoadedSkillTarget[] {
1059 1221 return pi
1060 1222 .getCommands()
1061 1223 .flatMap((command) => {
1243 +export async function chooseLoadedSkill(
1244 + ctx: ExtensionCommandContext,
1245 + skills: readonly LoadedSkillTarget[],
1246 + canonicalPaths: ReadonlyMap<string, string>,
1247 + purpose: string,
1248 +): Promise<LoadedSkillTarget | undefined> {
1249 + if (commandMode(ctx) !== "tui" || skills.length <= 8) {
1250 + const labels = skills.map(
1251 + (skill) =>
1252 + `${skill.name} — ${canonicalPaths.get(skill.path) ?? skill.path}`,
1253 + );
1254 + const choice = await ctx.ui.select(
1255 + `Choose exactly one ${purpose} skill.`,
1256 + labels,
1257 + );
1258 + return skills[labels.indexOf(choice ?? "")];
1261 + const path = await ctx.ui.custom<string | null>(
1262 + (tui, theme, _keybindings, done) => {
1263 + const list = new SelectList(
1264 + skills.map((skill) => {
1265 + const canonical = canonicalPaths.get(skill.path) ?? skill.path;
1266 + const parent = dirname(canonical);
1267 + return {
1268 + value: skill.path,
1269 + label: skill.name,
1270 + description: join(
1271 + "…",
1272 + basename(dirname(parent)),
1273 + basename(parent),
1274 + basename(canonical),
1275 + ),
1276 + };
1277 + }),
1278 + Math.max(1, Math.min(8, tui.terminal.rows - 3)),
1280 + selectedPrefix: (text) => theme.fg("accent", text),
1281 + selectedText: (text) => theme.fg("accent", text),
1282 + description: (text) => theme.fg("muted", text),
1283 + scrollInfo: (text) => theme.fg("dim", text),
1284 + noMatch: (text) => theme.fg("warning", text),
1285 + },
1286 + );
1287 + list.onSelect = (item) => done(item.value);
1288 + list.onCancel = () => done(null);
1289 + return {
1290 + render: (width: number) => [
1291 + theme.fg("accent", `Choose one ${purpose} skill`),
1292 + ...list.render(width),
1293 + theme.fg("dim", "type filter · arrows move · enter · esc"),
1294 + ],
1295 + invalidate: () => list.invalidate(),
1296 + handleInput: (data: string) => {
1297 + list.handleInput(data);
1298 + tui.requestRender();
1299 + },
1300 + };
1301 + },
1302 + );
1303 + return skills.find((skill) => skill.path === path);
1081 1306 async function runAftermath(
1082 1307 pi: ExtensionAPI,
1083 1308 ctx: ExtensionCommandContext,
1084 1309 parts: string[],
1085 1310 ): Promise<void> {
1086 1311 const active = activeRun;
1087 - if (!active || active.kind !== "aftermath")
1312 + if (active?.kind !== "aftermath")
1088 1313 throw new Error("Aftermath run ownership is unavailable");
1089 1314 throwIfCancelled(active);
1090 1315 const explicitPath = parts[0];
1168 1393 : undefined;
1169 1394 if (explicitPath && !selected)
1170 1395 throw new Error("explicit Aftermath skill path is not a loaded skill");
1396 + if (!selected && ctx.hasUI)
1397 + selected = await chooseLoadedSkill(
1398 + ctx,
1399 + skills,
1400 + canonicalSkillPaths,
1401 + "Aftermath",
1402 + );
1403 + if (!selected) throw new Error("one confirmed Aftermath skill is required");
1171 1404 throwIfCancelled(active);
1405 + const sourcePath =
1406 + canonicalSkillPaths.get(selected.path) ?? (await realpath(selected.path));
1407 + const parallelWarning = await unfinishedRunWarning(sourcePath);
1172 1408 const harvested = await harvestAftermath({
1174 1410 knownSkillPaths: knownPaths,
1179 1415 harvested.digests,
1180 1416 new Set(skills.map((skill) => skill.name)),
1182 - if (!selected && ctx.hasUI) {
1183 - if (evidence.suggestion) {
1184 - const action = await ctx.ui.select(
1185 - `Aftermath suggests ${evidence.suggestion}.`,
1186 - [`use ${evidence.suggestion}`, "choose another", "cancel"],
1187 - );
1188 - if (!action || action === "cancel") return;
1189 - if (action === `use ${evidence.suggestion}`)
1190 - selected = skills.find((skill) => skill.name === evidence.suggestion);
1192 - if (!selected) {
1193 - const choices = skills.map(
1194 - (skill) =>
1195 - `${skill.name} — ${canonicalSkillPaths.get(skill.path) ?? skill.path}`,
1196 - );
1197 - const choice = await ctx.ui.select(
1198 - "Choose exactly one Aftermath skill.",
1199 - choices,
1200 - );
1201 - if (!choice) return;
1202 - selected = skills.find(
1203 - (skill) =>
1204 - `${skill.name} — ${canonicalSkillPaths.get(skill.path) ?? skill.path}` ===
1205 - choice,
1206 - );
1209 - if (!selected) throw new Error("one confirmed Aftermath skill is required");
1210 - throwIfCancelled(active);
1211 1418 const calls = estimateMiningCalls(harvested.digests.length);
1212 1419 const confirmation = [
1213 1420 `Readable sessions: ${harvested.digests.length}; unreadable: ${harvested.unreadable}.`,
1214 1421 "Each digest is capped at 16 KiB, persisted, and sent to the model without redaction.",
1215 - `Estimated mining/aggregation calls: ${calls.mining}/${calls.aggregation}.`,
1422 + `Expected mining/aggregation calls: ${calls.mining}/${calls.aggregation}; malformed structured output retries once per call.`,
1423 + `Maximum mining/aggregation calls with retries: ${calls.mining * 2}/${calls.aggregation * 2}.`,
1216 1424 "Maximum replay calls after mining: 116 target, 116 rubric-judge, 12 optimizer.",
1425 + ...(parallelWarning ? [`Warning: ${parallelWarning}`] : []),
1217 1426 "Overkill will not write the source skill.",
1218 1427 ].join("\n");
1227 1436 frozenModel && ctx.modelRegistry.find(frozenModel.provider, frozenModel.id);
1228 1437 if (!frozenModel || !targetModel || !(await modelHasAuth(ctx)))
1229 1438 throw new Error("selected model authentication is unavailable");
1230 - const sourcePath = await realpath(selected.path);
1231 1439 const sourceBytes = await readFile(sourcePath);
1232 1440 throwIfCancelled(active);
1233 1441 parseSourceSkill(sourceBytes);
1257 1465 sessionId: ctx.sessionManager.getSessionId(),
1258 1466 linkEntryId: null,
1259 1467 stage: "harvest",
1468 + miningPromptVersion: 2,
1260 1469 terminal: null,
1261 1470 scores: { baseline: null, current: null, best: null, test: null },
1262 1471 calls: { target: 0, checker: 0, optimizer: 0, judge: 0 },
1316 1525 ): Promise<void> {
1317 1526 if (!ctx.hasUI || (commandMode(ctx) !== "tui" && commandMode(ctx) !== "rpc"))
1318 1527 return;
1528 + const artifacts = await readFrozenReviewArtifacts(directory);
1529 + const manifest = await readAftermathManifest(directory);
1530 + const staged = artifacts.stagedPath !== null && artifacts.staged !== null;
1531 + const report = artifacts.reportPath
1532 + ? `Report: ${sanitizeTerminalText(artifacts.reportPath)}`
1533 + : "";
1534 + let summary: string;
1535 + if (staged) {
1536 + const scores = [
1537 + manifest.scores.baseline === null
1538 + ? null
1539 + : `baseline ${formatScore(manifest.scores.baseline)}`,
1540 + manifest.scores.best === null
1541 + ? null
1542 + : `validation ${formatScore(manifest.scores.best)}`,
1543 + manifest.scores.test === null
1544 + ? null
1545 + : `held-out ${formatScore(manifest.scores.test)}`,
1546 + ].filter((value): value is string => value !== null);
1547 + summary = `Aftermath complete — candidate staged.\n${scores.join(" → ")}\n${report}`;
1548 + } else if (manifest.scores.baseline === null) {
1549 + const frozen = await readFrozenTasks(directory);
1550 + summary = `Aftermath complete — no candidate.\nOnly ${frozen.tasks.length}/3 recurring tasks; replay was skipped.\n${report}`;
1551 + } else if (manifest.scores.baseline === 1) {
1552 + summary = `Aftermath complete — no candidate needed.\nBaseline already scores 1; no improvement is possible.\n${report}`;
1553 + } else {
1554 + summary = `Aftermath complete — no candidate.\nBest validation ${formatScore(manifest.scores.best ?? manifest.scores.baseline)} did not beat baseline ${formatScore(manifest.scores.baseline)}; no diff was staged.\n${report}`;
1319 1556 const choice = await ctx.ui.select(
1320 - "Aftermath complete. Choose next action.",
1321 - ["review diff", "keep staged", "discard"],
1557 + summary,
1558 + staged ? ["review diff", "done", "discard"] : ["done", "discard report"],
1323 1560 if (choice === "review diff") {
1324 - const artifacts = await readFrozenReviewArtifacts(directory);
1325 - const paths = formatResultPaths(artifacts);
1326 - const canRenderDiff = commandMode(ctx) === "tui";
1561 + const paths = [
1562 + artifacts.reportPath
1563 + ? `Report: ${sanitizeTerminalText(artifacts.reportPath)}`
1564 + : null,
1565 + artifacts.stagedPath
1566 + ? `Staged: ${sanitizeTerminalText(artifacts.stagedPath)}`
1567 + : null,
1569 + .filter((value): value is string => value !== null)
1570 + .join("\n");
1327 1571 ctx.ui.notify(
1328 - artifacts.stagedPath && artifacts.staged
1329 - ? canRenderDiff
1330 - ? `${paths}\n${buildReviewDiff(
1331 - artifacts.sourcePath,
1332 - artifacts.stagedPath,
1333 - artifacts.source,
1334 - artifacts.staged,
1335 - )}`
1336 - : paths
1337 - : `${paths}\nNo candidate staged.`,
1572 + commandMode(ctx) === "tui" && artifacts.stagedPath && artifacts.staged
1573 + ? `${paths}\n${buildReviewDiff(
1574 + artifacts.sourcePath,
1575 + artifacts.stagedPath,
1576 + artifacts.source,
1577 + artifacts.staged,
1578 + )}`
1579 + : paths,
1338 1580 "info",
1340 1582 return;
1342 - if (choice === "keep staged") {
1343 - ctx.ui.notify("Aftermath artifacts retained.", "info");
1344 - return;
1346 - if (choice === "discard") {
1584 + if (choice === "done" || choice === undefined) return;
1585 + if (choice === "discard" || choice === "discard report") {
1347 1586 const selected = selectedAftermathRun(ctx);
1348 1587 if (!selected)
1349 1588 throw new Error("Aftermath run is no longer linked to this branch");
1376 1615 frozen?: Awaited<ReturnType<typeof readFrozenTasks>>;
1377 1616 }): Promise<void> {
1378 1617 const active = activeRun;
1379 - if (!active || active.kind !== "aftermath")
1618 + if (active?.kind !== "aftermath")
1380 1619 throw new Error("Aftermath run ownership is unavailable");
1381 1620 const { ctx, manifest } = options;
1621 + if (manifest.miningPromptVersion !== 2)
1622 + throw new Error(
1623 + "Aftermath run predates target-relevant mining; discard it and start a new run",
1624 + );
1625 + const frozenSource = await readFile(
1626 + join(options.directory, "baseline-snapshot.md"),
1627 + );
1628 + if (fingerprintSource(frozenSource) !== manifest.source.fingerprint)
1629 + throw new Error("frozen source fingerprint changed; replay is unsafe");
1630 + const source = parseSourceSkill(frozenSource);
1631 + if (source.name !== manifest.target.name)
1632 + throw new Error("frozen source name changed; replay is unsafe");
1382 1633 manifest.stage = "mining";
1383 1634 active.interrupt = async () => {
1384 1635 const interrupted = {
1396 1647 let attemptedMiningCalls = options.attemptedMiningCalls ?? 0;
1397 1648 for (const [level, outputs] of options.completedLevels ?? [])
1398 1649 for (const index of outputs.keys()) levels.add(`${level}:${index}`);
1650 + const miningTotal = estimateMiningCalls(options.digests.length).total;
1651 + const updateMiningProgress = (
1652 + phase?: "mining" | "aggregation",
1653 + attempt?: number,
1654 + maximumAttempts?: number,
1655 + ) => {
1656 + const completed = chunks.size + levels.size;
1657 + const progress = formatProgress({
1658 + stage: "mining",
1659 + completed,
1660 + total: miningTotal,
1661 + });
1662 + showProgress(
1663 + ctx,
1664 + phase
1665 + ? `${progress} · ${phase} call ${Math.min(completed + 1, miningTotal)} running${attempt && attempt > 1 ? ` · retry ${attempt}/${maximumAttempts}` : ""}`
1666 + : progress,
1667 + );
1668 + };
1399 1669 const persistCheckpoint = async () =>
1400 1670 await persistMiningCheckpoint(options.directory, {
1401 1671 attemptedCalls: attemptedMiningCalls,
1408 1678 const frozen =
1409 1679 options.frozen ??
1410 1680 (await (async () => {
1681 + updateMiningProgress();
1411 1682 const proposals = await mineTaskProposals({
1412 1683 digests: options.digests,
1684 + target: { name: source.name, description: source.description },
1413 1685 createSession: () =>
1414 1686 createMiningSession(
1423 1695 signal: active.controller.signal,
1424 1696 completedChunks: options.completedChunks,
1425 1697 completedLevels: options.completedLevels,
1426 - onCall: async () => {
1698 + onCall: async (phase, attempt, maximumAttempts) => {
1427 1699 attemptedMiningCalls += 1;
1428 1700 await persistCheckpoint();
1701 + updateMiningProgress(phase, attempt, maximumAttempts);
1430 1703 onChunk: async (index, output) => {
1431 1704 await persistMiningOutput(
1436 1709 chunks.add(index);
1437 1710 await persistCheckpoint();
1711 + updateMiningProgress();
1439 1713 onLevel: async (level, index, output) => {
1440 1714 await persistMiningOutput(
1445 1719 levels.add(`${level}:${index}`);
1446 1720 await persistCheckpoint();
1721 + updateMiningProgress();
1449 1724 throwIfCancelled(active);
1500 1775 manifest.calls.target = costs.targetConsumed;
1501 1776 manifest.calls.judge = costs.judgeConsumed;
1502 1777 await persistAftermathCost(options.directory, costs);
1503 - const callNotice = `Aftermath replay maximum: ${costs.targetMaximum} target calls, ${costs.judgeMaximum} rubric-judge calls.`;
1778 + const callNotice = `Replay budget: ≤${costs.targetMaximum} target + ${costs.judgeMaximum} judge calls; malformed judge retries consume this budget.`;
1504 1779 if (commandMode(ctx) === "print") writePrint(callNotice);
1505 1780 else if (commandMode(ctx) !== "json") ctx.ui.notify(callNotice, "info");
1506 1781 const allowCall = (kind: "target" | "judge") => {
1550 1825 await persistAftermathManifest(options.directory, manifest);
1551 1826 const entry = runEntry(
1552 1827 { manifest },
1553 - { completed: tasks.length, total: 30 },
1828 + { completed: tasks.length, total: 3 },
1554 1829 { reportPath, stagedPath: null },
1556 1831 appendProgress(options.pi, ctx, entry);
1557 - const paths = formatResultPaths({
1558 - sourcePath: manifest.source.path,
1559 - reportPath,
1560 - stagedPath: null,
1561 - });
1562 - if (commandMode(ctx) === "print") writePrint(paths);
1563 - else if (commandMode(ctx) !== "json")
1564 - ctx.ui.notify(`${paths}\nAftermath found insufficient tasks.`, "info");
1832 + if (commandMode(ctx) === "print")
1833 + writePrint(
1834 + `Aftermath complete — no candidate.\nOnly ${tasks.length}/3 recurring tasks; replay was skipped.\nReport: ${sanitizeTerminalText(reportPath)}`,
1835 + );
1565 1836 await offerAftermathCompletion(options.pi, ctx, options.directory);
1566 1837 return;
1569 1840 const currentSource = await readFile(manifest.source.path);
1570 1841 if (fingerprintSource(currentSource) !== manifest.source.fingerprint)
1571 1842 throw new Error("source fingerprint changed; replay is unsafe");
1572 - const frozenSource = await readFile(
1573 - join(options.directory, "baseline-snapshot.md"),
1574 - );
1575 - if (fingerprintSource(frozenSource) !== manifest.source.fingerprint)
1576 - throw new Error("frozen source fingerprint changed; replay is unsafe");
1577 - const source = parseSourceSkill(frozenSource);
1578 1843 const loadedSkill = await resolveLoadedSkill(
1579 1844 manifest.source.path,
1580 1845 options.pi.getCommands(),
1642 1907 targetCalls: costs.targetConsumed,
1643 1908 judgeCalls: costs.judgeConsumed,
1910 + deferCompletionNotice: true,
1646 1912 await offerAftermathCompletion(options.pi, ctx, options.directory);
1652 1918 selected: NonNullable<ReturnType<typeof selectedAftermathRun>>,
1653 1919 ): Promise<void> {
1654 1920 const active = activeRun;
1655 - if (!active || active.kind !== "aftermath")
1921 + if (active?.kind !== "aftermath")
1656 1922 throw new Error("Aftermath run ownership is unavailable");
1657 1923 const directory = join(getAgentDir(), "overkill-runs", selected.data.runId);
1658 1924 let manifest = await readAftermathManifest(directory);
1842 2108 return undefined;
1844 2110 const summary = theme.fg("accent", formatProgress(data));
1845 - if (!options.expanded)
1846 - return new Text(
2111 + if (!options.expanded) {
2112 + const details = [
1847 2113 `${summary} ${theme.fg("dim", keyHint("app.tools.expand", "to expand"))}`,
1848 - 0,
1849 - 0,
1850 - );
2114 + ];
2115 + if (data.terminal === "staged")
2116 + try {
2117 + const artifacts = readFrozenReviewArtifactsSync(
2118 + join(getAgentDir(), "overkill-runs", data.runId),
2119 + );
2120 + if (artifacts.stagedPath && artifacts.staged)
2121 + details.push(
2122 + renderDiff(
2123 + buildReviewDiffPreview(
2124 + buildReviewDiff(
2125 + artifacts.sourcePath,
2126 + artifacts.stagedPath,
2127 + artifacts.source,
2128 + artifacts.staged,
2129 + ),
2130 + ),
2131 + ),
2132 + );
2133 + } catch {
2134 + // The durable run summary remains useful without review artifacts.
2136 + return new Text(details.join("\n"), 0, 0);
1851 2138 const details = [summary];
2139 + if (data.stage === "preflight") return new Text(summary, 0, 0);
1853 2141 const artifacts = readFrozenReviewArtifactsSync(
1854 2142 join(getAgentDir(), "overkill-runs", data.runId),
1876 2164 details.push(
1877 - buildReviewDiff(
1878 - artifacts.sourcePath,
1879 - artifacts.stagedPath,
1880 - artifacts.source,
1881 - artifacts.staged,
2165 + renderDiff(
2166 + buildReviewDiff(
2167 + artifacts.sourcePath,
2168 + artifacts.stagedPath,
2169 + artifacts.source,
2170 + artifacts.staged,
2171 + ),
1891 2181 pi.registerCommand("overkill", {
1892 2182 description:
1893 - "Evaluate a trusted explicit suite baseline for a loaded Pi skill.",
2183 + "Author or optimize a loaded Pi skill with trusted evaluators.",
1894 2184 getArgumentCompletions: (prefix) => {
1895 2185 const trimmed = prefix.trim();
1896 - if (trimmed.startsWith("aftermath")) {
2186 + if (trimmed === "aftermath" && !prefix.endsWith(" ")) return null;
2187 + if (trimmed === "aftermath" || trimmed.startsWith("aftermath ")) {
1897 2188 const nested = trimmed.slice("aftermath".length).trim();
1898 2189 const choices = ["status", "resume", "review", "discard", "cancel"]
1899 2190 .filter((command) => command.startsWith(nested))
1909 2200 return choices.length > 0 ? choices : null;
1911 2202 handler: async (args, ctx) => {
1912 - const parts = parseArguments(args);
2203 + let parts: string[];
2204 + try {
2205 + parts = parseArguments(args);
2206 + } catch (error) {
2207 + ctx.ui.notify(
2208 + `Overkill command failed: ${error instanceof Error ? error.message : String(error)}`,
2209 + "error",
2210 + );
2211 + return;
1913 2213 const command = parts[0];
2214 + if (command === "suite") {
2215 + let [sourcePath, suitePath, ...extra] = parts.slice(1);
2216 + if (extra.length > 0) {
2217 + ctx.ui.notify(
2218 + "Usage: /overkill suite [skill-path] [suite-dir]",
2219 + "error",
2220 + );
2221 + return;
2223 + if (!ctx.isIdle()) {
2224 + ctx.ui.notify("Agent is busy.", "error");
2225 + return;
2227 + try {
2228 + if (!ctx.isProjectTrusted())
2229 + throw new Error("suite authoring requires a trusted project");
2230 + if (!sourcePath) {
2231 + if (!ctx.hasUI)
2232 + throw new Error(
2233 + "headless suite authoring requires an explicit skill path",
2234 + );
2235 + const skills = loadedSkills(pi);
2236 + if (skills.length === 0)
2237 + throw new Error("no loaded Pi skills are available");
2238 + const canonicalPaths = new Map<string, string>();
2239 + for (const skill of skills)
2240 + canonicalPaths.set(skill.path, await realpath(skill.path));
2241 + const selected = await chooseLoadedSkill(
2242 + ctx,
2243 + skills,
2244 + canonicalPaths,
2245 + "suite",
2246 + );
2247 + if (!selected) return;
2248 + sourcePath = selected.path;
2250 + const loaded = await resolveLoadedSkill(
2251 + sourcePath,
2252 + pi.getCommands(),
2253 + true,
2254 + ctx.cwd,
2255 + );
2256 + const projectRoot = await realpath(resolve(ctx.cwd));
2257 + if (suitePath) {
2258 + suitePath = await canonicalProspectivePath(
2259 + resolve(projectRoot, suitePath),
2260 + );
2261 + const projectRelative = relative(projectRoot, suitePath);
2262 + if (projectRelative.startsWith("..") || isAbsolute(projectRelative))
2263 + throw new Error("suite directory must be inside the project");
2265 + const parallelWarning = await unfinishedRunWarning(
2266 + undefined,
2267 + suitePath,
2268 + );
2269 + if (parallelWarning) ctx.ui.notify(parallelWarning, "warning");
2270 + pi.sendUserMessage(
2271 + buildSuiteAuthoringPrompt(loaded.path, suitePath, projectRoot),
2272 + );
2273 + } catch (error) {
2274 + ctx.ui.notify(
2275 + `Overkill suite authoring failed: ${error instanceof Error ? error.message : String(error)}`,
2276 + "error",
2277 + );
2279 + return;
1914 2281 if (command === "aftermath") {
1915 2282 const subcommand = parts[1];
2283 + if (
2284 + ["status", "resume", "review", "discard", "cancel"].includes(
2285 + subcommand ?? "",
2286 + ) &&
2287 + parts.length !== 2
2288 + ) {
2289 + ctx.ui.notify(`Usage: /overkill aftermath ${subcommand}`, "error");
2290 + return;
1916 2292 if (subcommand === "status") {
1917 2293 const run = selectedAftermathRun(ctx);
1918 2294 if (!run)
2018 2394 stage: "discarded",
2019 2395 terminal: "discarded",
2397 + clearProgress(ctx);
2021 2398 } else if (manifest.terminal) {
2022 2399 ctx.ui.notify(
2023 2400 "Aftermath mining is already complete; stored tasks are frozen.",
2040 2417 return;
2042 2419 if (activeRun || startPending) {
2043 - ctx.ui.notify("An Overkill rollout is already active.", "error");
2420 + ctx.ui.notify(
2421 + "This Pi process already has an Overkill rollout active; wait or cancel it before starting another.",
2422 + "error",
2423 + );
2044 2424 return;
2046 2426 startPending = true;
2066 2446 return;
2448 + if (
2449 + ["status", "discard", "cancel", "review", "resume"].includes(
2450 + command ?? "",
2451 + ) &&
2452 + parts.length !== 1
2453 + ) {
2454 + ctx.ui.notify(`Usage: /overkill ${command}`, "error");
2455 + return;
2068 2457 if (command === "status") {
2069 2458 const run = selectedRun(ctx);
2070 2459 if (!run) {
2096 2485 selected: run,
2097 2486 branch: ctx.sessionManager.getBranch(),
2098 2487 sessionId: ctx.sessionManager.getSessionId(),
2488 + allowNonterminal: true,
2489 + isRunActive: (runId) => activeRun?.runId === runId,
2100 2491 appendProgress(pi, ctx, {
2101 2492 ...run.data,
2102 2493 stage: "discarded",
2103 2494 terminal: "discarded",
2496 + clearProgress(ctx);
2105 2497 ctx.ui.notify("Overkill run discarded.", "info");
2106 2498 } catch (error) {
2107 2499 ctx.ui.notify(
2145 2537 return;
2147 - const artifacts = await readFrozenReviewArtifacts(
2148 - join(getAgentDir(), "overkill-runs", run.data.runId),
2149 - );
2539 + let artifacts: Awaited<ReturnType<typeof readFrozenReviewArtifacts>>;
2540 + try {
2541 + artifacts = await readFrozenReviewArtifacts(
2542 + join(getAgentDir(), "overkill-runs", run.data.runId),
2543 + );
2544 + } catch (error) {
2545 + ctx.ui.notify(
2546 + `Overkill review failed: ${error instanceof Error ? error.message : String(error)}`,
2547 + "error",
2548 + );
2549 + return;
2150 2551 const entry = {
2151 2552 ...run.data,
2152 2553 sourcePath: artifacts.sourcePath,
2189 2590 if (command === "resume") {
2190 2591 if (activeRun || startPending) {
2191 - ctx.ui.notify("An Overkill rollout is already active.", "error");
2592 + ctx.ui.notify(
2593 + "This Pi process already has an Overkill rollout active; wait or cancel it before resuming another.",
2594 + "error",
2595 + );
2192 2596 return;
2194 2598 const run = selectedRun(ctx);
2230 2634 return;
2232 2636 if (activeRun || startPending) {
2233 - ctx.ui.notify("An Overkill rollout is already active.", "error");
2637 + ctx.ui.notify(
2638 + "This Pi process already has an Overkill rollout active; wait or cancel it before starting another.",
2639 + "error",
2640 + );
2234 2641 return;
2236 2643 const invokingModel = ctx.model;
2269 2676 const inspected = await inspectSuiteRun(preflightOptions);
2677 + const inspectedSuiteFingerprint = inspected.suite.fingerprint;
2678 + if (!inspectedSuiteFingerprint)
2679 + throw new Error("validated suite fingerprint is unavailable");
2680 + const confirmedFingerprints = {
2681 + sourceFingerprint: fingerprintSource(inspected.sourceBytes),
2682 + suiteFingerprint: inspectedSuiteFingerprint,
2683 + };
2684 + const parallelWarning = await unfinishedRunWarning(
2685 + inspected.sourcePath,
2686 + inspected.suite.suitePath,
2687 + );
2270 2688 if (commandMode(ctx) === "tui" || commandMode(ctx) === "rpc") {
2271 2689 const confirmed = await ctx.ui.confirm(
2272 2690 "Start Overkill run?",
2274 2692 sourcePath: inspected.sourcePath,
2275 2693 suitePath: inspected.suite.suitePath,
2276 2694 splitCounts: inspected.suite.splitCounts,
2695 + warning: parallelWarning,
2279 2698 if (!confirmed) {
2284 2703 if (pendingCancelled) throw new RolloutCancelledError();
2285 2704 await withActiveRun(ctx, async (active) => {
2286 2705 throwIfCancelled(active);
2287 - const run = await prepareSuiteRun(preflightOptions);
2706 + const run = await prepareSuiteRun(
2707 + preflightOptions,
2708 + confirmedFingerprints,
2709 + );
2288 2710 active.runId = run.manifest.runId;
2289 2711 active.interrupt = async () =>
2290 2712 await checkpointInterrupted(run.directory, run.manifest);
2315 2737 return;
2316 2738 ctx.ui.notify(
2317 - `Overkill baseline failed: ${error instanceof Error ? error.message : String(error)}`,
2739 + `Overkill run failed: ${error instanceof Error ? error.message : String(error)}`,
2318 2740 "error",
2320 2742 } finally {

extensions/overkill/lib/aftermath-mining.ts

Modified
203 203 // is rejected before this function is called.
206 + if (options.proposals.length > 0 && frozen.size === 0)
207 + throw new Error(
208 + `all ${options.proposals.length} miner proposals violated the required task schema`,
209 + );
206 210 return [...frozen.values()]
207 211 .sort((left, right) =>
208 212 left.id < right.id ? -1 : left.id > right.id ? 1 : 0,
275 279 createAgentSession as unknown as StructuredOutputSdkSeam["createAgentSession"],
282 +const deterministicCheck = Type.Union([
283 + Type.Object(
285 + type: Type.Literal("contains"),
286 + value: Type.String(),
287 + caseSensitive: Type.Boolean(),
288 + },
289 + { additionalProperties: false },
290 + ),
291 + Type.Object(
292 + { type: Type.Literal("section_present"), heading: Type.String() },
293 + { additionalProperties: false },
294 + ),
295 + Type.Object(
296 + { type: Type.Literal("min_chars"), count: Type.Integer() },
297 + { additionalProperties: false },
298 + ),
299 + Type.Object(
300 + { type: Type.Literal("max_chars"), count: Type.Integer() },
301 + { additionalProperties: false },
302 + ),
303 +]);
305 +const taskFields = {
306 + intent: Type.String(),
307 + context: Type.String(),
308 + sourceSessionIds: Type.Array(Type.String(), { minItems: 2, maxItems: 32 }),
309 + observedOutcome: Type.Optional(Type.String()),
312 +const taskProposal = Type.Union([
313 + Type.Object(
315 + ...taskFields,
316 + checks: Type.Array(deterministicCheck, { minItems: 1, maxItems: 8 }),
317 + },
318 + { additionalProperties: false },
319 + ),
320 + Type.Object(
321 + { ...taskFields, rubric: Type.String() },
322 + { additionalProperties: false },
323 + ),
324 +]);
278 326 const miningOutput = defineTool({
279 327 name: "structured_output",
280 328 label: "Structured output",
281 - description: "Return task proposals as the final action.",
329 + description: "Return exact recurring task proposals as the final action.",
282 330 parameters: Type.Object(
283 - { tasks: Type.Array(Type.Any()) },
331 + { tasks: Type.Array(taskProposal) },
284 332 { additionalProperties: false },
286 334 async execute(_id, params) {
332 380 return result.session as unknown as MiningSession;
383 +const MINING_ATTEMPTS = 2;
385 +export class MiningOutputError extends Error {}
335 387 async function structuredTasks(
336 388 session: MiningSession,
337 389 prompt: string,
359 411 if (signal?.aborted) throw new Error("mining cancelled");
360 412 await session.prompt(prompt, { expandPromptTemplates: false });
361 413 if (signal?.aborted) throw new Error("mining cancelled");
362 - if (
363 - outputs !== 1 ||
364 - typeof output !== "object" ||
365 - output === null ||
366 - Array.isArray(output)
367 - )
368 - throw new Error("miner must emit exactly one structured output");
369 - const record = exactObject(output, ["tasks"], "miner output");
370 - if (!Array.isArray(record.tasks) || record.tasks.length > maximum)
371 - throw new Error("miner output task cap exceeded");
372 - const json = canonicalJson(output);
373 - if (bytes(json) > (maximum === 10 ? 64 * 1024 : 128 * 1024))
374 - throw new Error("miner output byte cap exceeded");
375 - return record.tasks;
414 + try {
415 + if (
416 + outputs !== 1 ||
417 + typeof output !== "object" ||
418 + output === null ||
419 + Array.isArray(output)
421 + throw new Error(
422 + `miner emitted ${outputs} successful structured outputs; expected exactly one`,
423 + );
424 + const record = exactObject(output, ["tasks"], "miner output");
425 + if (!Array.isArray(record.tasks) || record.tasks.length > maximum)
426 + throw new Error("miner output task cap exceeded");
427 + const json = canonicalJson(output);
428 + if (bytes(json) > (maximum === 10 ? 64 * 1024 : 128 * 1024))
429 + throw new Error("miner output byte cap exceeded");
430 + return record.tasks;
431 + } catch (error) {
432 + throw new MiningOutputError(
433 + error instanceof Error ? error.message : String(error),
434 + );
376 436 } finally {
377 437 signal?.removeEventListener("abort", onAbort);
378 438 unsubscribe();
443 +async function structuredTasksWithRetry(options: {
444 + createSession: () => Promise<MiningSession>;
445 + prompt: string;
446 + maximum: number;
447 + phase: "mining" | "aggregation";
448 + signal?: AbortSignal;
449 + onCall?: (
450 + phase: "mining" | "aggregation",
451 + attempt: number,
452 + maximumAttempts: number,
453 + ) => Promise<void>;
454 +}): Promise<unknown[]> {
455 + for (let attempt = 1; attempt <= MINING_ATTEMPTS; attempt += 1) {
456 + try {
457 + return await structuredTasks(
458 + await options.createSession(),
459 + `${options.prompt}\nEvery task must contain intent, context, 2–32 exact sourceSessionIds copied from the input, optional observedOutcome, and exactly one of: rubric string; checks array using contains {value, caseSensitive}, section_present {heading}, min_chars {count}, or max_chars {count}. Preserve this exact schema during aggregation. You must call structured_output exactly once as your final action; never print JSON as text. If no valid recurring proposal exists, call it with an empty tasks array.${attempt > 1 ? " This is a retry because the previous session ended without one valid structured_output call." : ""}`,
460 + options.maximum,
461 + options.signal,
462 + options.onCall
463 + ? async () =>
464 + await options.onCall?.(options.phase, attempt, MINING_ATTEMPTS)
465 + : undefined,
466 + );
467 + } catch (error) {
468 + if (!(error instanceof MiningOutputError) || attempt === MINING_ATTEMPTS)
469 + throw error;
472 + throw new Error("mining retry state is unreachable");
383 475 export async function mineTaskProposals(options: {
384 476 digests: readonly unknown[];
477 + target: { name: string; description: string };
385 478 createSession: () => Promise<MiningSession>;
386 479 signal?: AbortSignal;
387 480 onChunk?: (index: number, output: unknown[]) => Promise<void>;
388 481 onLevel?: (level: number, index: number, output: unknown[]) => Promise<void>;
389 - onCall?: () => Promise<void>;
482 + onCall?: (
483 + phase: "mining" | "aggregation",
484 + attempt: number,
485 + maximumAttempts: number,
486 + ) => Promise<void>;
390 487 completedChunks?: ReadonlyMap<number, unknown[]>;
391 488 completedLevels?: ReadonlyMap<number, unknown[][]>;
392 489 }): Promise<unknown[]> {
490 + const target = `targetSkill:${canonicalJson(options.target)}\nPropose only recurring tasks whose correct completion requires this target skill's described capability. Omit generic workflows and tasks belonging to other skills.`;
393 491 let outputs: unknown[][] = [];
394 492 for (const [index, group] of chunkConsecutively(
395 493 options.digests,
398 496 const saved = options.completedChunks?.get(index);
399 497 const output =
400 498 saved ??
401 - (await structuredTasks(
402 - await options.createSession(),
403 - `phase:mine\nExtract no more than 10 recurring, checkable task proposals. Return only {"tasks": [...]}.\ndigests:${canonicalJson(group)}`,
404 - 10,
405 - options.signal,
406 - options.onCall,
407 - ));
499 + (await structuredTasksWithRetry({
500 + createSession: options.createSession,
501 + prompt: `phase:mine\n${target}\nExtract no more than 10 recurring, checkable task proposals.\ndigests:${canonicalJson(group)}`,
502 + maximum: 10,
503 + phase: "mining",
504 + signal: options.signal,
505 + onCall: options.onCall,
506 + }));
408 507 if (!saved) await options.onChunk?.(index, output);
409 508 outputs.push(output);
414 513 const saved = options.completedLevels?.get(level)?.[index];
415 514 const output =
416 515 saved ??
417 - (await structuredTasks(
418 - await options.createSession(),
419 - `phase:aggregate\nConsolidate recurring task proposals. Return only {"tasks": [...]}, at most 30.\noutputs:${canonicalJson(group)}`,
420 - 30,
421 - options.signal,
422 - options.onCall,
423 - ));
516 + (await structuredTasksWithRetry({
517 + createSession: options.createSession,
518 + prompt: `phase:aggregate\n${target}\nConsolidate at most 30 recurring task proposals. Remove anything irrelevant to the target skill.\noutputs:${canonicalJson(group)}`,
519 + maximum: 30,
520 + phase: "aggregation",
521 + signal: options.signal,
522 + onCall: options.onCall,
523 + }));
424 524 if (!saved) await options.onLevel?.(level, index, output);
425 525 next.push(output);

extensions/overkill/lib/aftermath-scoring.ts

Modified
84 84 description: "Return one rubric judgment as the final action.",
85 85 parameters: Type.Object(
87 - score: Type.Number(),
87 + score: Type.Number({ minimum: 0, maximum: 1 }),
88 88 passed: Type.Boolean(),
89 - rationale: Type.String(),
89 + rationale: Type.String({
90 + maxLength: 4096,
91 + description: "At most 4096 UTF-8 bytes.",
92 + }),
91 94 { additionalProperties: false },
167 170 cacheKey: string;
173 +class RubricJudgeOutputError extends Error {}
170 175 function boundedResponse(response: string): string {
171 176 const maximum = 64 * 1024;
172 177 const marker = "…[truncated]";
193 198 function judgeResult(value: unknown): Omit<RubricJudgeResult, "cacheKey"> {
194 199 if (typeof value !== "object" || value === null || Array.isArray(value))
195 - throw new Error("rubric judge output must be an object");
200 + throw new RubricJudgeOutputError("rubric judge output must be an object");
196 201 const record = value as Record<string, unknown>;
198 203 Object.keys(record).length !== 3 ||
200 205 (key) => key !== "score" && key !== "passed" && key !== "rationale",
203 - throw new Error("rubric judge output has unknown fields");
208 + throw new RubricJudgeOutputError("rubric judge output has unknown fields");
205 210 typeof record.score !== "number" ||
206 211 !Number.isFinite(record.score) ||
210 215 typeof record.rationale !== "string" ||
211 216 Buffer.byteLength(record.rationale, "utf8") > 4096
213 - throw new Error("rubric judge output is invalid");
218 + throw new RubricJudgeOutputError("rubric judge output is invalid");
214 219 return {
215 220 score: record.score,
216 221 passed: record.passed,
265 -/** Runs one fresh, terminating structured-output rubric judgment. */
270 +type RubricTask = Pick<
271 + FrozenTask,
272 + | "id"
273 + | "intent"
274 + | "context"
275 + | "sourceSessionIds"
276 + | "observedOutcome"
277 + | "rubric"
280 +/** Retries one malformed structured output in a fresh judge session. */
266 281 export async function runRubricJudge(
267 - task: Pick<
268 - FrozenTask,
269 - | "id"
270 - | "intent"
271 - | "context"
272 - | "sourceSessionIds"
273 - | "observedOutcome"
274 - | "rubric"
275 - >,
282 + task: RubricTask,
283 + response: string,
284 + seam: { createSession: () => Promise<RubricJudgeSession> },
285 + signal?: AbortSignal,
286 + onCall?: () => Promise<void>,
287 +): Promise<RubricJudgeResult> {
288 + for (let attempt = 0; ; attempt += 1) {
289 + try {
290 + return await runRubricJudgeAttempt(task, response, seam, signal, onCall);
291 + } catch (error) {
292 + if (!(error instanceof RubricJudgeOutputError) || attempt === 1)
293 + throw error;
298 +async function runRubricJudgeAttempt(
299 + task: RubricTask,
276 300 response: string,
277 301 seam: { createSession: () => Promise<RubricJudgeSession> },
278 302 signal?: AbortSignal,
309 333 throw new RubricJudgeCancelledError();
311 335 await session.prompt(
312 - `Judge the frozen task response and terminate by calling structured_output exactly once with {"score":number,"passed":boolean,"rationale":string}.\ninput:${canonicalJson({ judgePromptVersion: 1, task, response: bounded })}`,
336 + `Judge the frozen task response and terminate by calling structured_output exactly once with {"score":number from 0 through 1,"passed":boolean,"rationale":string of at most 4096 UTF-8 bytes}.\ninput:${canonicalJson({ judgePromptVersion: 1, task, response: bounded })}`,
313 337 { expandPromptTemplates: false },
315 339 // A valid terminating output is durable work: return it so callers can
319 343 await abort();
320 344 throw new RubricJudgeCancelledError();
322 - throw new Error("rubric judge must emit exactly one structured output");
346 + throw new RubricJudgeOutputError(
347 + "rubric judge must emit exactly one structured output",
348 + );
323 349 } finally {
324 350 signal?.removeEventListener("abort", onAbort);
325 351 unsubscribe();

extensions/overkill/lib/aftermath-state.ts

Modified
21 21 stage: string;
22 22 terminal: null | "staged" | "no_improvement" | "failed" | "discarded";
23 23 harvestFingerprint?: string;
24 + miningPromptVersion?: 2;
24 25 taskFingerprint?: string;
25 26 scores: {
26 27 baseline: number | null;
107 108 "stage",
108 109 "terminal",
109 110 "harvestFingerprint",
111 + "miningPromptVersion",
110 112 "taskFingerprint",
111 113 "scores",
112 114 "calls",
119 121 (value as Record<string, unknown> | null)?.[key] !== undefined ||
121 123 "harvestFingerprint",
124 + "miningPromptVersion",
122 125 "taskFingerprint",
123 126 "scorers",
124 127 "splits",
159 162 throw new Error("invalid manifest terminal");
160 163 if (record.harvestFingerprint !== undefined)
161 164 fingerprint(record.harvestFingerprint, "harvest fingerprint");
165 + if (
166 + record.miningPromptVersion !== undefined &&
167 + record.miningPromptVersion !== 2
169 + throw new Error("invalid mining prompt version");
162 170 if (record.taskFingerprint !== undefined)
163 171 fingerprint(record.taskFingerprint, "task fingerprint");
164 172 const scores = exactObject(

extensions/overkill/lib/contracts.ts

Modified
8 8 } from "./checker.ts";
10 10 const MAX_SOURCE_BYTES = 256 * 1024;
11 +const MAX_CHECKER_BYTES = 256 * 1024;
11 12 const MAX_ITEMS_BYTES = 1024 * 1024;
12 13 const MAX_PROMPT_BYTES = 16 * 1024;
13 14 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
311 312 const fileStat = await stat(canonical);
312 313 if (!fileStat.isFile()) throw new Error(`${filename} must be a file`);
314 + if (filename === "check.mjs" && fileStat.size > MAX_CHECKER_BYTES)
315 + throw new Error("check.mjs exceeds 256 KiB");
313 316 files.set(filename, canonical);
315 318 const checkerPath = files.get("check.mjs");
322 325 for (const filename of REQUIRED_SUITE_FILES) {
323 326 const path = files.get(filename);
324 327 if (!path) throw new Error(`suite is missing ${filename}`);
325 - snapshot.set(filename, await readFile(path));
328 + const bytes = await readFile(path);
329 + if (filename === "check.mjs" && bytes.byteLength > MAX_CHECKER_BYTES)
330 + throw new Error("check.mjs exceeds 256 KiB");
331 + snapshot.set(filename, bytes);
327 333 const ids = new Set<string>();
328 334 const train = validateItems(

extensions/overkill/lib/modes.ts

Modified
3 3 const MAX_DIFF_LINES = 200;
4 4 const MAX_DIFF_BYTES = 32 * 1024;
5 5 const DIFF_TRUNCATION = "…[diff truncated]";
6 6 const DIFF_CONTEXT = 3;
7 7 const MAX_DIFF_MATRIX_CELLS = 100_000;
8 +const DIFF_PREVIEW_LINES = 4;
9 10 type DiffLine = { kind: " " | "+" | "-"; text: string };
22 23 sourcePath: string;
23 24 suitePath: string;
24 25 splitCounts: SplitCounts;
26 + warning?: string;
25 27 }): string {
26 28 const calls = upperBoundCalls(options.splitCounts);
27 29 return [
29 31 `Suite: ${sanitizeTerminalText(options.suitePath)}`,
30 32 `Splits: train ${options.splitCounts.train}, validation ${options.splitCounts.val}, test ${options.splitCounts.test}`,
31 33 `Upper bound: ${calls.target} target calls, ${calls.optimizer} optimizer calls.`,
32 - "The trusted checker executes project code.",
34 + ...(options.warning ? [`Warning: ${options.warning}`] : []),
35 + "The trusted checker executes project code with your process environment.",
33 36 "Overkill will not write the source skill or suite. Continue?",
34 37 ].join("\n");
40 +export function formatScore(score: number): string {
41 + return score.toFixed(3).replace(/\.?0+$/u, "");
37 44 export function formatProgress(options: {
38 45 stage: string;
46 + terminal?: string | null;
39 47 completed?: number;
40 48 total?: number;
41 49 currentScore?: number;
42 50 bestScore?: number;
43 51 }): string {
44 - const fields = ["Overkill", options.stage];
52 + const stage =
53 + options.terminal === "staged"
54 + ? "candidate staged"
55 + : options.stage === "complete" && options.terminal === "no_improvement"
56 + ? "no improvement"
57 + : options.stage;
58 + const fields = ["Overkill", stage];
45 59 if (options.completed !== undefined)
46 60 fields.push(
47 61 options.total === undefined
48 62 ? String(options.completed)
49 63 : `${options.completed}/${options.total}`,
51 - if (options.bestScore !== undefined) fields.push(`best ${options.bestScore}`);
65 + if (options.bestScore !== undefined)
66 + fields.push(`best ${formatScore(options.bestScore)}`);
52 67 else if (options.currentScore !== undefined)
53 - fields.push(`score ${options.currentScore}`);
68 + fields.push(`score ${formatScore(options.currentScore)}`);
54 69 return fields.join(" ");
155 170 return `@@ -${normalizedBeforeStart},${beforeCount} +${normalizedAfterStart},${afterCount} @@\n${hunk.map((line) => `${line.kind}${line.text}`).join("\n")}`;
173 +export function buildReviewDiffPreview(diff: string): string {
174 + const changes = diff
175 + .split("\n")
176 + .filter(
177 + (line) =>
178 + (line.startsWith("+") && !line.startsWith("+++")) ||
179 + (line.startsWith("-") && !line.startsWith("---")),
180 + );
181 + const preview = changes.slice(0, DIFF_PREVIEW_LINES);
182 + if (changes.length > preview.length)
183 + preview.push(`… ${changes.length - preview.length} more changed lines`);
184 + return preview.join("\n");
158 187 export function buildReviewDiff(
159 188 sourcePath: string,
160 189 stagedPath: string,

extensions/overkill/lib/optimizer.ts

Modified
246 246 await onProgress?.(progress);
247 247 ensureNotCancelled();
249 + const parsedOutput = async <T>(
250 + text: string,
251 + parse: (value: unknown) => T,
252 + retryInstruction: string,
253 + ) => {
254 + let first: unknown;
255 + try {
256 + first = await prompt(text);
257 + } catch (error) {
258 + if (
259 + !(error instanceof Error) ||
260 + error.message !== "optimizer must emit exactly one structured output"
262 + throw error;
264 + try {
265 + return parse(first);
266 + } catch {
267 + return parse(await prompt(`${text}\nRetry: ${retryInstruction}`));
269 + };
270 + const proposal = async (text: string) =>
271 + await parsedOutput(
272 + text,
273 + assertProposal,
274 + "the previous structured output was malformed. Return exactly one proposal string and no edits.",
275 + );
276 + const patch = async (text: string) =>
277 + await parsedOutput(
278 + text,
279 + assertPatch,
280 + "the previous structured output was malformed. Return only one valid patch with one to four atomic edits.",
281 + );
250 283 const failure =
251 284 options.failures.length === 0
252 285 ? { proposal: "" }
253 286 : progress.failure === undefined
254 - ? assertProposal(
255 - await prompt(
256 - `phase:failure\nReflect on failed trajectories. Identify root causes and concrete body changes; do not emit a patch.\nfailures:${boundedJson(options.failures, 32 * 1024)}`,
257 - ),
287 + ? await proposal(
288 + `phase:failure\nReflect on failed trajectories. Identify root causes and concrete body changes; do not emit a patch.\nfailures:${boundedJson(options.failures, 32 * 1024)}`,
259 290 : { proposal: progress.failure };
260 291 if (options.failures.length > 0 && progress.failure === undefined)
263 294 options.successes.length === 0
264 295 ? { proposal: "" }
265 296 : progress.success === undefined
266 - ? assertProposal(
267 - await prompt(
268 - `phase:success\nReflect on successful trajectories and constraints that changes must preserve; do not emit a patch.\nsuccesses:${boundedJson(options.successes, 32 * 1024)}`,
269 - ),
297 + ? await proposal(
298 + `phase:success\nReflect on successful trajectories and constraints that changes must preserve; do not emit a patch.\nsuccesses:${boundedJson(options.successes, 32 * 1024)}`,
271 300 : { proposal: progress.success };
272 301 if (options.successes.length > 0 && progress.success === undefined)
273 302 await saveProgress({ ...progress, success: success.proposal });
274 303 const merged =
275 304 progress.merged === undefined
276 - ? assertProposal(
277 - await prompt(
278 - `phase:merge\nMerge proposals, prioritizing failure fixes while preserving success constraints. Return one concise proposal, not a patch.\ncontext:${boundedJson({ failure, success }, 32 * 1024)}`,
279 - ),
305 + ? await proposal(
306 + `phase:merge\nMerge proposals, prioritizing failure fixes while preserving success constraints. Return one concise proposal, not a patch.\ncontext:${boundedJson({ failure, success }, 32 * 1024)}`,
281 308 : { proposal: progress.merged };
282 309 if (progress.merged === undefined)
283 310 await saveProgress({ ...progress, merged: merged.proposal });
284 - const patch = assertPatch(
285 - await prompt(
286 - `phase:ranking\nRank concrete edits for expected validation improvement, avoid prior rejections, then call structured_output exactly once with patch JSON {"edits":[{"op":"append"|"insert_after"|"replace"|"delete","target"?:string,"content"?:string}]}. Use one to four atomic edits.\ncontext:${rankingContext({ body: options.body, proposal: merged.proposal, rejections: options.rejections })}`,
287 - ),
311 + const result = await patch(
312 + `phase:ranking\nRank concrete edits for expected validation improvement, avoid prior rejections, then call structured_output exactly once with patch JSON {"edits":[{"op":"append"|"insert_after"|"replace"|"delete","target"?:string,"content"?:string}]}. Use one to four atomic edits.\ncontext:${rankingContext({ body: options.body, proposal: merged.proposal, rejections: options.rejections })}`,
289 - return { patch, calls };
314 + return { patch: result, calls };
290 315 } finally {
291 316 await Promise.resolve(session.dispose());

extensions/overkill/lib/preflight.ts

Modified
67 67 return { source, sourceBytes, sourcePath, loadedSkill, suite };
70 -export async function prepareSuiteRun(options: SuiteRunOptions): Promise<{
70 +export async function prepareSuiteRun(
71 + options: SuiteRunOptions,
72 + expected?: { sourceFingerprint: string; suiteFingerprint: string },
73 +): Promise<{
71 74 directory: string;
72 75 manifest: RunManifest;
73 76 source: SourceSkill;
78 81 const { source, sourceBytes, sourcePath, loadedSkill, suite } =
79 82 await inspectSuiteRun(options);
83 + const sourceFingerprint = fingerprintSource(sourceBytes);
84 + const suiteFingerprint =
85 + suite.fingerprint ??
86 + (() => {
87 + throw new Error("validated suite fingerprint is unavailable");
88 + })();
89 + if (
90 + expected &&
91 + (expected.sourceFingerprint !== sourceFingerprint ||
92 + expected.suiteFingerprint !== suiteFingerprint)
93 + )
94 + throw new Error("source or suite changed after confirmation");
80 95 if (!options.model) throw new Error("selected model is unavailable");
81 96 const runId = randomUUID();
82 97 const manifest: RunManifest = {
83 98 version: 1,
84 99 runId,
85 100 kind: "suite",
86 - source: { path: sourcePath, fingerprint: fingerprintSource(sourceBytes) },
87 - suite: {
88 - path: suite.suitePath,
89 - fingerprint:
90 - suite.fingerprint ??
91 - (() => {
92 - throw new Error("validated suite fingerprint is unavailable");
93 - })(),
94 - },
101 + source: { path: sourcePath, fingerprint: sourceFingerprint },
102 + suite: { path: suite.suitePath, fingerprint: suiteFingerprint },
95 103 model: options.model,
96 104 sessionId: options.sessionId,
97 105 linkEntryId: null,

extensions/overkill/lib/rollouts.ts

Modified
29 29 } from "./run-state.ts";
31 31 const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"] as const;
32 +export const TARGET_CALL_TIMEOUT_MS = 900_000;
33 34 type FrozenModel = { provider: string; id: string; thinking: string };
79 80 createAgentSession as unknown as TargetSdkSeam["createAgentSession"],
83 +export async function promptTarget(
84 + target: TargetSession,
85 + prompt: string,
86 +): Promise<void> {
87 + let timer: ReturnType<typeof setTimeout> | undefined;
88 + try {
89 + await Promise.race([
90 + target.prompt(prompt, { expandPromptTemplates: true }),
91 + new Promise<never>((_, reject) => {
92 + timer = setTimeout(() => {
93 + void target.abort().catch(() => {});
94 + reject(
95 + new Error(
96 + `target rollout timed out after ${TARGET_CALL_TIMEOUT_MS / 1000}s`,
97 + ),
98 + );
99 + }, TARGET_CALL_TIMEOUT_MS);
100 + }),
101 + ]);
102 + } finally {
103 + if (timer !== undefined) clearTimeout(timer);
82 107 export type BaselineSeam = {
83 108 createTarget: () => Promise<TargetSession>;
84 109 executeChecker?: (options: {
561 586 await requestAbort();
562 587 throw new RolloutCancelledError();
564 - await target.prompt(`/skill:${options.source.name} ${item.prompt}`, {
565 - expandPromptTemplates: true,
566 - });
589 + await promptTarget(
590 + target,
591 + `/skill:${options.source.name} ${item.prompt}`,
592 + );
567 593 if (finalResponse === undefined) {
568 594 if (cancelled(options.signal)) {
569 595 await requestAbort();

extensions/overkill/lib/run-state.ts

Modified
1 1 import { randomUUID } from "node:crypto";
2 -import { readFileSync } from "node:fs";
2 +import { readFileSync, realpathSync } from "node:fs";
3 3 import {
4 4 mkdir,
5 5 readFile,
30 30 "stage",
31 31 "terminal",
32 32 "harvestFingerprint",
33 + "miningPromptVersion",
33 34 "taskFingerprint",
34 35 "scores",
35 36 "calls",
994 995 export async function readFrozenReviewArtifacts(
995 996 directory: string,
996 997 ): Promise<FrozenReviewArtifacts> {
997 - const manifest = await readManifest(directory);
998 - const paths = reviewPaths(directory, manifest);
998 + const root = await realpath(directory);
999 + const manifest = await readManifest(root);
1000 + const paths = reviewPaths(root, manifest);
999 1001 return {
1000 1002 ...paths,
1001 - source: await readFile(join(directory, "baseline-snapshot.md"), "utf8"),
1003 + source: await readFile(join(root, "baseline-snapshot.md"), "utf8"),
1002 1004 staged: paths.stagedPath ? await readFile(paths.stagedPath, "utf8") : null,
1006 1008 export function readFrozenReviewArtifactsSync(
1007 1009 directory: string,
1008 1010 ): FrozenReviewArtifacts {
1011 + const root = realpathSync(directory);
1009 1012 const manifestValue: unknown = JSON.parse(
1010 - readFileSync(join(directory, "manifest.json"), "utf8"),
1013 + readFileSync(join(root, "manifest.json"), "utf8"),
1012 1015 assertManifest(manifestValue);
1013 - const paths = reviewPaths(directory, manifestValue);
1016 + const paths = reviewPaths(root, manifestValue);
1014 1017 return {
1015 1018 ...paths,
1016 - source: readFileSync(join(directory, "baseline-snapshot.md"), "utf8"),
1019 + source: readFileSync(join(root, "baseline-snapshot.md"), "utf8"),
1017 1020 staged: paths.stagedPath ? readFileSync(paths.stagedPath, "utf8") : null,
1117 1120 ): Promise<void> {
1118 1121 const canonicalRoot = await realpath(runRoot);
1119 1122 const requestedRun = resolve(runDirectory);
1123 + const requestedParent = await realpath(dirname(requestedRun));
1121 - dirname(requestedRun) !== canonicalRoot ||
1125 + requestedParent !== canonicalRoot ||
1122 1126 basename(requestedRun).length === 0
1124 1128 throw new Error("can only discard a direct private run directory");

package-lock.json

Modified
11 11 "extensions/*"
13 13 "devDependencies": {
14 + "@earendil-works/pi-agent-core": "0.84.2",
15 + "@earendil-works/pi-ai": "0.84.2",
16 + "@earendil-works/pi-client": "0.84.2",
17 + "@earendil-works/pi-coding-agent": "0.84.2",
18 + "@earendil-works/pi-protocol": "0.84.2",
19 + "@earendil-works/pi-telemetry": "0.84.2",
20 + "@earendil-works/pi-tui": "0.84.2",
14 21 "@fast-check/vitest": "^0.4.1",
15 22 "@playwright/test": "^1.61.0",
16 23 "@vitest/coverage-istanbul": "^4.1.9",
46 53 "@earendil-works/pi-tui": "*"
49 - "extensions/builtin-tools": {
50 - "name": "@bugabinga/pi-ext-builtin-tools",
51 - "license": "MIT",
52 - "devDependencies": {
53 - "@marcfargas/pi-test-harness": "^0.6.1",
54 - "vitest": "^4.1.9"
55 - },
56 - "peerDependencies": {
57 - "@earendil-works/pi-coding-agent": "*"
58 - }
59 - },
60 56 "extensions/cmprss": {
61 57 "name": "@bugabinga/pi-ext-cmprss",
62 58 "license": "MIT",
569 565 "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.91.1.tgz",
570 566 "integrity": "sha512-LAmu761tSN9r66ixvmciswUj/ZC+1Q4iAfpedTfSVLeswRwnY3n2Nb6Tsk+cLPP28aLOPWeMgIuTuCcMC6W/iw==",
571 567 "license": "MIT",
572 - "peer": true,
573 568 "dependencies": {
574 569 "json-schema-to-ts": "^3.1.1"
590 585 "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-browser/-/sha256-browser-5.2.0.tgz",
591 586 "integrity": "sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==",
592 587 "license": "Apache-2.0",
593 - "peer": true,
594 588 "dependencies": {
595 589 "@aws-crypto/sha256-js": "^5.2.0",
596 590 "@aws-crypto/supports-web-crypto": "^5.2.0",
606 600 "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-js/-/sha256-js-5.2.0.tgz",
607 601 "integrity": "sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==",
608 602 "license": "Apache-2.0",
609 - "peer": true,
610 603 "dependencies": {
611 604 "@aws-crypto/util": "^5.2.0",
612 605 "@aws-sdk/types": "^3.222.0",
621 614 "resolved": "https://registry.npmjs.org/@aws-crypto/supports-web-crypto/-/supports-web-crypto-5.2.0.tgz",
622 615 "integrity": "sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==",
623 616 "license": "Apache-2.0",
624 - "peer": true,
625 617 "dependencies": {
626 618 "tslib": "^2.6.2"
631 623 "resolved": "https://registry.npmjs.org/@aws-crypto/util/-/util-5.2.0.tgz",
632 624 "integrity": "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==",
633 625 "license": "Apache-2.0",
634 - "peer": true,
635 626 "dependencies": {
636 627 "@aws-sdk/types": "^3.222.0",
637 628 "@smithy/util-utf8": "^2.0.0",
643 634 "resolved": "https://registry.npmjs.org/@aws-sdk/client-bedrock-runtime/-/client-bedrock-runtime-3.1048.0.tgz",
644 635 "integrity": "sha512-u+NT61JZEkRFtpL0CAw1N1dwxnaLgwVXQl/zjJxTGgLyS/jTIdg2SdoEoCTHxgDyCnqa1HEi9QOoE9/pYRNpOQ==",
645 636 "license": "Apache-2.0",
646 - "peer": true,
647 637 "dependencies": {
648 638 "@aws-crypto/sha256-browser": "5.2.0",
649 639 "@aws-crypto/sha256-js": "5.2.0",
669 659 "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.977.6.tgz",
670 660 "integrity": "sha512-QiaJV4/zDrB4ZY2mfeSXSzSTc36W16sZXcGz+SPFk0CJ26gziO0cS+4LjJUMAbdeeBOvS0k0Aq1cZpfGdUXxSw==",
671 661 "license": "Apache-2.0",
672 - "peer": true,
673 662 "dependencies": {
674 663 "@aws-sdk/types": "^3.974.2",
675 664 "@aws-sdk/xml-builder": "^3.972.37",
689 678 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.67.tgz",
690 679 "integrity": "sha512-rcIpk5kxUqDaaNa6Xk23pQ6ViY7jlqzmfFWCahQcBT97ddXaXYYwzCen9Tz1Jvo6aJft6wDl5bN44/Jw5B4oLA==",
691 680 "license": "Apache-2.0",
692 - "peer": true,
693 681 "dependencies": {
694 682 "@aws-sdk/core": "^3.977.6",
695 683 "@aws-sdk/types": "^3.974.2",
706 694 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.69.tgz",
707 695 "integrity": "sha512-nggwJtZ4eeNsUw5IeWBMXsi1ryct5idi0K+/SCRF3kybLubOMaNTb3XCihXpWMiVpyzyPeIrl0zTkzhBH9porA==",
708 696 "license": "Apache-2.0",
709 - "peer": true,
710 697 "dependencies": {
711 698 "@aws-sdk/core": "^3.977.6",
712 699 "@aws-sdk/types": "^3.974.2",
725 712 "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.9.13.tgz",
726 713 "integrity": "sha512-Nmd/Nl35zfYrd+a6OO2cDJb3GPh9bgTjIUhcM+JFfjpp8/osCgboDV5nCT1I01Pv6R13eSKDKLSoVa5ZB6Zsfw==",
727 714 "license": "Apache-2.0",
728 - "peer": true,
729 715 "dependencies": {
730 716 "@smithy/core": "^3.31.1",
731 717 "@smithy/types": "^4.16.1",
740 726 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.12.tgz",
741 727 "integrity": "sha512-pNEf/OeyN5X3VmLKlgSO6TqaWmW10CvI3TfwL1XhsuhYjSLT2VDaxFnCPHnOeQXSaFisMX4jNhpETriqN8DOmg==",
742 728 "license": "Apache-2.0",
743 - "peer": true,
744 729 "dependencies": {
745 730 "@aws-sdk/core": "^3.977.6",
746 731 "@aws-sdk/credential-provider-env": "^3.972.67",
765 750 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.74.tgz",
766 751 "integrity": "sha512-0AQfDcf99TNmqVKv0owHrw/TQs6i4ZE5t9qmz6NvO53bE/sA/tpXhXL9AAcEP1qHc6Zzjd1UMb69+/9zdhvY3g==",
767 752 "license": "Apache-2.0",
768 - "peer": true,
769 753 "dependencies": {
770 754 "@aws-sdk/core": "^3.977.6",
771 755 "@aws-sdk/nested-clients": "^3.997.41",
783 767 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.78.tgz",
784 768 "integrity": "sha512-OgPAnfvbGAMWac6yvxJ1ihslrvDpPVwR68D2csospdNCCyPvHk9JLzYKwz48SNiS1T2znDwHauywRKRFfpyYng==",
785 769 "license": "Apache-2.0",
786 - "peer": true,
787 770 "dependencies": {
788 771 "@aws-sdk/credential-provider-env": "^3.972.67",
789 772 "@aws-sdk/credential-provider-http": "^3.972.69",
806 789 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.67.tgz",
807 790 "integrity": "sha512-IlUEejorGTWKb4/Dm7K5Yw4QxUmXLThLhrvBmzVBqZFTbW72cv9LTcITmo1dsnYriALE4h68mOq4LB99x6sQ7Q==",
808 791 "license": "Apache-2.0",
809 - "peer": true,
810 792 "dependencies": {
811 793 "@aws-sdk/core": "^3.977.6",
812 794 "@aws-sdk/types": "^3.974.2",
823 805 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.11.tgz",
824 806 "integrity": "sha512-gAQBkBZxUB84d71+pPcI9L+jh2ujhuAVxc/4FgGiWFDjkPBlMKxzd5XDtkSXTFX8Ro7ansnT88+XadasxMeCRw==",
825 807 "license": "Apache-2.0",
826 - "peer": true,
827 808 "dependencies": {
828 809 "@aws-sdk/core": "^3.977.6",
829 810 "@aws-sdk/nested-clients": "^3.997.41",
842 823 "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1103.0.tgz",
843 824 "integrity": "sha512-N4wy26MNn31ItGVHYHPrEuCIFY4MBBjC+C5v1lJKqIUSA7OZBdhleCY53zCCrXn27hsk7YNOaTuhQu807S4AfQ==",
844 825 "license": "Apache-2.0",
845 - "peer": true,
846 826 "dependencies": {
847 827 "@aws-sdk/core": "^3.977.6",
848 828 "@aws-sdk/nested-clients": "^3.997.41",
860 840 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.73.tgz",
861 841 "integrity": "sha512-SnlEmQa6SjOgs6iOPLUQl1Eyq4AKiAdPQlkOhFhqNfDtDCwibMGvL6QlkSmf3o6vAUSImzdPCxowT5dfQUZP1A==",
862 842 "license": "Apache-2.0",
863 - "peer": true,
864 843 "dependencies": {
865 844 "@aws-sdk/core": "^3.977.6",
866 845 "@aws-sdk/nested-clients": "^3.997.41",
878 857 "resolved": "https://registry.npmjs.org/@aws-sdk/eventstream-handler-node/-/eventstream-handler-node-3.972.31.tgz",
879 858 "integrity": "sha512-/BRzvkp46mF6eXBL/l9WKPQQfifLlUPaWli6n9/T/WDLUg8he7TCyuNFnk6RvHP5j5W/kMj5Gxw7W778LJaXDA==",
880 859 "license": "Apache-2.0",
881 - "peer": true,
882 860 "dependencies": {
883 861 "@aws-sdk/types": "^3.974.2",
884 862 "@smithy/core": "^3.31.1",
894 872 "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-eventstream/-/middleware-eventstream-3.972.26.tgz",
895 873 "integrity": "sha512-2eIvouTZoxPu5ClHY6ij13De1yhY8Rmllt0dlGeBNXX3wmR7fU1pvMCGb50fKm1GxcuntWK0t1T0cMjTyDoUQA==",
896 874 "license": "Apache-2.0",
897 - "peer": true,
898 875 "dependencies": {
899 876 "@aws-sdk/types": "^3.974.2",
900 877 "@smithy/core": "^3.31.1",
910 887 "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-websocket/-/middleware-websocket-3.972.49.tgz",
911 888 "integrity": "sha512-wGYJvu1/stdWuzGcNyh44u8aY7ArU8XFrMesBlzIYn70HWVCRBNEngQexDuPIMu0NEgsKGKmTc0uvnS/bF7KWw==",
912 889 "license": "Apache-2.0",
913 - "peer": true,
914 890 "dependencies": {
915 891 "@aws-sdk/core": "^3.977.6",
916 892 "@aws-sdk/types": "^3.974.2",
929 905 "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.41.tgz",
930 906 "integrity": "sha512-RDHqPGQWlF6tatA/Tp3rg6oIwtgN9IVderxE+9av2Y93Dfyu+mO1hZ5Bu2jpfZg2rwdNbsssnwM+sLafIczMlQ==",
931 907 "license": "Apache-2.0",
932 - "peer": true,
933 908 "dependencies": {
934 909 "@aws-sdk/core": "^3.977.6",
935 910 "@aws-sdk/signature-v4-multi-region": "^3.996.43",
949 924 "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.9.13.tgz",
950 925 "integrity": "sha512-Nmd/Nl35zfYrd+a6OO2cDJb3GPh9bgTjIUhcM+JFfjpp8/osCgboDV5nCT1I01Pv6R13eSKDKLSoVa5ZB6Zsfw==",
951 926 "license": "Apache-2.0",
952 - "peer": true,
953 927 "dependencies": {
954 928 "@smithy/core": "^3.31.1",
955 929 "@smithy/types": "^4.16.1",
964 938 "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.43.tgz",
965 939 "integrity": "sha512-lKekx8bLBXSv4O+cslk9Zfnw2XKSkWBs3uWL5QGhH2ZAQfNS7FE0vcSSN2vD/AhxX54ZTywWxR4STThoeOXlBA==",
966 940 "license": "Apache-2.0",
967 - "peer": true,
968 941 "dependencies": {
969 942 "@aws-sdk/types": "^3.974.2",
970 943 "@smithy/signature-v4": "^5.6.12",
980 953 "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1048.0.tgz",
981 954 "integrity": "sha512-k0y/GcuesuSfWyUM0WamrGyeZmltRYaPbHO82UDA6mZ/doB+FOHKutikPAtSXMn/hDz970cF+iRuuiYO9VEbAA==",
982 955 "license": "Apache-2.0",
983 - "peer": true,
984 956 "dependencies": {
985 957 "@aws-sdk/core": "^3.974.11",
986 958 "@aws-sdk/nested-clients": "^3.997.9",
998 970 "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.2.tgz",
999 971 "integrity": "sha512-3W6IUtSxFbH6X7Wb7DzGCV5QiFQsd0g8bOfntpmDxQlzBoKWUMBu/JPQR0DwkE+Hpnxd6db1tXbOwdeHddG6cA==",
1000 972 "license": "Apache-2.0",
1001 - "peer": true,
1002 973 "dependencies": {
1003 974 "@smithy/types": "^4.16.1",
1004 975 "tslib": "^2.6.2"
1012 983 "resolved": "https://registry.npmjs.org/@aws-sdk/util-locate-window/-/util-locate-window-3.965.8.tgz",
1013 984 "integrity": "sha512-uUbMs1cBZPafD0ohUj6EwNf0fPZ534NvBxHox4hjX+0Rxq5paSYUem7+hi833pYrzrcnBATKIYpR02MDXT5M9g==",
1014 985 "license": "Apache-2.0",
1015 - "peer": true,
1016 986 "dependencies": {
1017 987 "tslib": "^2.6.2"
1025 995 "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.37.tgz",
1026 996 "integrity": "sha512-zKq4HQum8JwDyEuyfuI4bbiAcU0KxP6qy+9PR/IsR92IyE/DaBAikzAS50tjxip4bqIIANpCcG+Yyj6CVhXupg==",
1027 997 "license": "Apache-2.0",
1028 - "peer": true,
1029 998 "dependencies": {
1030 999 "@smithy/types": "^4.16.1",
1031 1000 "tslib": "^2.6.2"
1039 1008 "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
1040 1009 "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
1041 1010 "license": "Apache-2.0",
1042 - "peer": true,
1043 1011 "engines": {
1044 1012 "node": ">=18.0.0"
1241 1209 "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
1242 1210 "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
1243 1211 "license": "MIT",
1244 - "peer": true,
1245 1212 "engines": {
1246 1213 "node": ">=6.9.0"
1308 1275 "resolved": "extensions/btw",
1309 1276 "link": true
1311 - "node_modules/@bugabinga/pi-ext-builtin-tools": {
1312 - "resolved": "extensions/builtin-tools",
1313 - "link": true
1314 - },
1315 1278 "node_modules/@bugabinga/pi-ext-cmprss": {
1316 1279 "resolved": "extensions/cmprss",
1317 1280 "link": true
1486 1449 "license": "MIT"
1488 1451 "node_modules/@earendil-works/pi-agent-core": {
1489 - "version": "0.84.1",
1490 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.84.1.tgz",
1491 - "integrity": "sha512-evyzXYWCLQGmcaBYHlmSku02r8qoN4SGI60GZABo6iV+H+nqX+P9ud8fEZ4GmRq9mUSREvvfX+w9dA9ThF9C6w==",
1452 + "version": "0.84.2",
1453 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.84.2.tgz",
1454 + "integrity": "sha512-8Pn3wSCxj0cfo5I6jxQYVB/3uuQRmHhAlEclyjqpOuMEdQMIODHizRogv56FLdbU+dTiGnybeHQ2N+sV1/L2YA==",
1492 1455 "license": "MIT",
1493 - "peer": true,
1494 1456 "dependencies": {
1495 - "@earendil-works/pi-ai": "^0.84.1",
1496 - "@earendil-works/pi-telemetry": "^0.84.1",
1457 + "@earendil-works/pi-ai": "^0.84.2",
1458 + "@earendil-works/pi-telemetry": "^0.84.2",
1497 1459 "diff": "8.0.4",
1498 1460 "ignore": "7.0.5",
1499 1461 "typebox": "1.3.7",
1507 1469 "version": "1.3.7",
1508 1470 "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.7.tgz",
1509 1471 "integrity": "sha512-meKuifc33Pccx0O6PdIzYMq3Og8zvP4TIi/a+Bw3AEMZMxOD0+RHGQvpglEe6Zdy3wZ8nqn/j95h8LUZLk/6Hg==",
1510 - "license": "MIT",
1511 - "peer": true
1472 + "license": "MIT"
1513 1474 "node_modules/@earendil-works/pi-ai": {
1514 - "version": "0.84.1",
1515 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.84.1.tgz",
1516 - "integrity": "sha512-wMsAdJMxuNri08vLqTyYVI201DQQezGhPSTkzYsHdw5dYX3rCNwEmSvpaAwhi7ELKI/2tE/CEgSWg/6iRxSgdQ==",
1475 + "version": "0.84.2",
1476 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.84.2.tgz",
1477 + "integrity": "sha512-6MzsrYIYNVlE7SfpbL2yYb67Qo58p/7Q+xWG1RZvoX1P80aRCHSod2/13aFpxkow1lPO2LEh3c495J0Gwmyjig==",
1517 1478 "license": "MIT",
1518 - "peer": true,
1519 1479 "dependencies": {
1520 1480 "@anthropic-ai/sdk": "0.91.1",
1521 1481 "@aws-sdk/client-bedrock-runtime": "3.1048.0",
1522 - "@earendil-works/pi-telemetry": "^0.84.1",
1482 + "@earendil-works/pi-telemetry": "^0.84.2",
1523 1483 "@google/genai": "1.52.0",
1524 - "@mistralai/mistralai": "2.2.6",
1525 1484 "@opentelemetry/api": "1.9.0",
1526 1485 "@smithy/node-http-handler": "4.7.3",
1527 1486 "http-proxy-agent": "7.0.2",
1528 1487 "https-proxy-agent": "7.0.6",
1529 - "openai": "6.26.0",
1488 + "openai": "6.40.0",
1530 1489 "partial-json": "0.1.7",
1531 1490 "typebox": "1.3.7"
1541 1500 "version": "1.3.7",
1542 1501 "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.7.tgz",
1543 1502 "integrity": "sha512-meKuifc33Pccx0O6PdIzYMq3Og8zvP4TIi/a+Bw3AEMZMxOD0+RHGQvpglEe6Zdy3wZ8nqn/j95h8LUZLk/6Hg==",
1503 + "license": "MIT"
1504 + },
1505 + "node_modules/@earendil-works/pi-client": {
1506 + "version": "0.84.2",
1507 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-client/-/pi-client-0.84.2.tgz",
1508 + "integrity": "sha512-/RFSPhD/bZbpOp1oJj+UneSUFSgZhWxzcSENUY+8+8xhoBrWXMYI2t77XNx4Yf+c8YK2qTHquForhNcelYpXvg==",
1509 + "dev": true,
1544 1510 "license": "MIT",
1545 - "peer": true
1511 + "dependencies": {
1512 + "@earendil-works/pi-protocol": "^0.84.2"
1513 + },
1514 + "engines": {
1515 + "node": ">=22.19.0"
1547 1518 "node_modules/@earendil-works/pi-coding-agent": {
1548 - "version": "0.84.1",
1549 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.84.1.tgz",
1550 - "integrity": "sha512-ncAqFrG+iybuPGOhMiZoEHkEzTpJgz3guYD32pD+M7ucc0WeHmauP6wa7qwP8V/KWvsZDVNa5XGsdZ7fkC7w7A==",
1519 + "version": "0.84.2",
1520 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.84.2.tgz",
1521 + "integrity": "sha512-l4E+B7hgXKWddRo8bC/eSue2aWZjEgJ9xIpf5p0Og+lq8a2TArCwJ0HCoCPCgaBP/tN4zbYH/wOwvx9pJpeLCA==",
1551 1522 "hasShrinkwrap": true,
1552 1523 "license": "MIT",
1553 - "peer": true,
1554 1524 "dependencies": {
1555 - "@earendil-works/pi-agent-core": "^0.84.1",
1556 - "@earendil-works/pi-ai": "^0.84.1",
1557 - "@earendil-works/pi-client": "^0.84.1",
1558 - "@earendil-works/pi-protocol": "^0.84.1",
1559 - "@earendil-works/pi-tui": "^0.84.1",
1525 + "@earendil-works/pi-agent-core": "^0.84.2",
1526 + "@earendil-works/pi-ai": "^0.84.2",
1527 + "@earendil-works/pi-client": "^0.84.2",
1528 + "@earendil-works/pi-protocol": "^0.84.2",
1529 + "@earendil-works/pi-tui": "^0.84.2",
1560 1530 "@silvia-odwyer/photon-node": "0.3.4",
1561 1531 "chalk": "5.6.2",
1562 1532 "cross-spawn": "7.0.6",
1589 1559 "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.91.1.tgz",
1590 1560 "integrity": "sha512-LAmu761tSN9r66ixvmciswUj/ZC+1Q4iAfpedTfSVLeswRwnY3n2Nb6Tsk+cLPP28aLOPWeMgIuTuCcMC6W/iw==",
1591 1561 "license": "MIT",
1592 - "peer": true,
1593 1562 "dependencies": {
1594 1563 "json-schema-to-ts": "^3.1.1"
1610 1579 "resolved": "https://registry.npmjs.org/@aws-crypto/crc32/-/crc32-5.2.0.tgz",
1611 1580 "integrity": "sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==",
1612 1581 "license": "Apache-2.0",
1613 - "peer": true,
1614 1582 "dependencies": {
1615 1583 "@aws-crypto/util": "^5.2.0",
1616 1584 "@aws-sdk/types": "^3.222.0",
1625 1593 "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-browser/-/sha256-browser-5.2.0.tgz",
1626 1594 "integrity": "sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==",
1627 1595 "license": "Apache-2.0",
1628 - "peer": true,
1629 1596 "dependencies": {
1630 1597 "@aws-crypto/sha256-js": "^5.2.0",
1631 1598 "@aws-crypto/supports-web-crypto": "^5.2.0",
1641 1608 "resolved": "https://registry.npmjs.org/@aws-crypto/sha256-js/-/sha256-js-5.2.0.tgz",
1642 1609 "integrity": "sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==",
1643 1610 "license": "Apache-2.0",
1644 - "peer": true,
1645 1611 "dependencies": {
1646 1612 "@aws-crypto/util": "^5.2.0",
1647 1613 "@aws-sdk/types": "^3.222.0",
1656 1622 "resolved": "https://registry.npmjs.org/@aws-crypto/supports-web-crypto/-/supports-web-crypto-5.2.0.tgz",
1657 1623 "integrity": "sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==",
1658 1624 "license": "Apache-2.0",
1659 - "peer": true,
1660 1625 "dependencies": {
1661 1626 "tslib": "^2.6.2"
1666 1631 "resolved": "https://registry.npmjs.org/@aws-crypto/util/-/util-5.2.0.tgz",
1667 1632 "integrity": "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==",
1668 1633 "license": "Apache-2.0",
1669 - "peer": true,
1670 1634 "dependencies": {
1671 1635 "@aws-sdk/types": "^3.222.0",
1672 1636 "@smithy/util-utf8": "^2.0.0",
1678 1642 "resolved": "https://registry.npmjs.org/@aws-sdk/client-bedrock-runtime/-/client-bedrock-runtime-3.1048.0.tgz",
1679 1643 "integrity": "sha512-u+NT61JZEkRFtpL0CAw1N1dwxnaLgwVXQl/zjJxTGgLyS/jTIdg2SdoEoCTHxgDyCnqa1HEi9QOoE9/pYRNpOQ==",
1680 1644 "license": "Apache-2.0",
1681 - "peer": true,
1682 1645 "dependencies": {
1683 1646 "@aws-crypto/sha256-browser": "5.2.0",
1684 1647 "@aws-crypto/sha256-js": "5.2.0",
1704 1667 "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.974.11.tgz",
1705 1668 "integrity": "sha512-QpnINq5FZH6EOaDEkmHdT7eUunbvD27pDNQypaWjFyYz7Zl1q3UCMQErBZxpmfGfI7MvI2TlK8KTkgNpv8b1ug==",
1706 1669 "license": "Apache-2.0",
1707 - "peer": true,
1708 1670 "dependencies": {
1709 1671 "@aws-sdk/types": "^3.973.8",
1710 1672 "@aws-sdk/xml-builder": "^3.972.24",
1724 1686 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.37.tgz",
1725 1687 "integrity": "sha512-/jpPvEh6f7ntmIzf7dNxoNX6Q8vt8UpesCjbW6mFfk4V1NW6bIy9qxcQ6WbA8As5yQhsZOe+xeNd4xHX8kdY2Q==",
1726 1688 "license": "Apache-2.0",
1727 - "peer": true,
1728 1689 "dependencies": {
1729 1690 "@aws-sdk/core": "^3.974.11",
1730 1691 "@aws-sdk/types": "^3.973.8",
1741 1702 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.39.tgz",
1742 1703 "integrity": "sha512-pIgTpisWyWg7X1bUbzSjuUYosYTD0Ghz2M0hkSTmb3a6i3qV3uU+NYJPI/E2XSC0HcsZh5rsLPzeXrkb2DS0Cg==",
1743 1704 "license": "Apache-2.0",
1744 - "peer": true,
1745 1705 "dependencies": {
1746 1706 "@aws-sdk/core": "^3.974.11",
1747 1707 "@aws-sdk/types": "^3.973.8",
1760 1720 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.972.41.tgz",
1761 1721 "integrity": "sha512-u2tyjaxJJzW8UtW4SM1ZcPMDwO6y+kV+llvou+Adts0FAKyzes5jG4izQN+KX3yE8ZROpS5y1LJ//xL2iSf76w==",
1762 1722 "license": "Apache-2.0",
1763 - "peer": true,
1764 1723 "dependencies": {
1765 1724 "@aws-sdk/core": "^3.974.11",
1766 1725 "@aws-sdk/credential-provider-env": "^3.972.37",
1785 1744 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.41.tgz",
1786 1745 "integrity": "sha512-0LBitxXiAiaE5nlFPfpNIww/8FRY/I7WIndWsc9GmNFOM7cE1wNpVNQEGEk9Outg5l8xl+3vybxFyUy4l9q/LQ==",
1787 1746 "license": "Apache-2.0",
1788 - "peer": true,
1789 1747 "dependencies": {
1790 1748 "@aws-sdk/core": "^3.974.11",
1791 1749 "@aws-sdk/nested-clients": "^3.997.9",
1803 1761 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.42.tgz",
1804 1762 "integrity": "sha512-D4oon2zbqqsWOJUM99Gm3/ZyJ0IJvTXVN3PyloGb3kQEyI36fjCZheZj422lAgTWWd6TSHgiImLt3RIaLdv3dQ==",
1805 1763 "license": "Apache-2.0",
1806 - "peer": true,
1807 1764 "dependencies": {
1808 1765 "@aws-sdk/credential-provider-env": "^3.972.37",
1809 1766 "@aws-sdk/credential-provider-http": "^3.972.39",
1826 1783 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.37.tgz",
1827 1784 "integrity": "sha512-7nVaHBUaWIddASYfVaA9O4D5ZVjewU3sCol9WqZPGfW0nR+0WqE0xHZnD/U2L33PlOB8KNXGKZ6wOES/QijKzg==",
1828 1785 "license": "Apache-2.0",
1829 - "peer": true,
1830 1786 "dependencies": {
1831 1787 "@aws-sdk/core": "^3.974.11",
1832 1788 "@aws-sdk/types": "^3.973.8",
1843 1799 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.972.41.tgz",
1844 1800 "integrity": "sha512-IOWAWEHe5LkjSKkkUUX9ciV6Y1scHTsnfEkdt5yyC4Slrc7AGbkLPrpntjqh18ksJAMOaVhoBsO8p2WyTcY2wQ==",
1845 1801 "license": "Apache-2.0",
1846 - "peer": true,
1847 1802 "dependencies": {
1848 1803 "@aws-sdk/core": "^3.974.11",
1849 1804 "@aws-sdk/nested-clients": "^3.997.9",
1862 1817 "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.41.tgz",
1863 1818 "integrity": "sha512-mbACk9Yypa8nm4iGZLs0PofOXEcTDOUw6wDnsPXNDNSd2WNXs1tSo+6nc/fh0jLYdfVZThhBL98PHW4aXFsG5A==",
1864 1819 "license": "Apache-2.0",
1865 - "peer": true,
1866 1820 "dependencies": {
1867 1821 "@aws-sdk/core": "^3.974.11",
1868 1822 "@aws-sdk/nested-clients": "^3.997.9",
1880 1834 "resolved": "https://registry.npmjs.org/@aws-sdk/eventstream-handler-node/-/eventstream-handler-node-3.972.16.tgz",
1881 1835 "integrity": "sha512-yedpPgKftqjU5SlPFHfqWpOw6xSCRieWRG1euWOlXn4WJxt2VX92VprCa2PpSOXjVCAeK6dTjW9eJRXVig9yGA==",
1882 1836 "license": "Apache-2.0",
1883 - "peer": true,
1884 1837 "dependencies": {
1885 1838 "@aws-sdk/types": "^3.973.8",
1886 1839 "@smithy/core": "^3.24.2",
1896 1849 "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-eventstream/-/middleware-eventstream-3.972.12.tgz",
1897 1850 "integrity": "sha512-tHTHHCHNrq6XklQvlzHBDJG4Iuhh7NVPRdtmvP+nHFA+5sxPlIDzlAHHgfoYHGvT3NXP1yVP/L5c3opUn6T3Qg==",
1898 1851 "license": "Apache-2.0",
1899 - "peer": true,
1900 1852 "dependencies": {
1901 1853 "@aws-sdk/types": "^3.973.8",
1902 1854 "@smithy/core": "^3.24.2",
1912 1864 "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-websocket/-/middleware-websocket-3.972.19.tgz",
1913 1865 "integrity": "sha512-mkEhOGYozqKQkbFaVrjwr0faiwwZza1v5/jSY6Tucm3bD+uKTazIUH/4Yo6aMnQD2ua2W9cMP6s8mvwTcjtqHw==",
1914 1866 "license": "Apache-2.0",
1915 - "peer": true,
1916 1867 "dependencies": {
1917 1868 "@aws-sdk/core": "^3.974.11",
1918 1869 "@aws-sdk/types": "^3.973.8",
1931 1882 "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.9.tgz",
1932 1883 "integrity": "sha512-jPR3rnmRI4hWYyzfmTGBr7NblMp8QYYeflHXba1H6+7CGrWVqWKQzaXFQ4qbExqPRsXN3T3L3JxFhr6aouXUGQ==",
1933 1884 "license": "Apache-2.0",
1934 - "peer": true,
1935 1885 "dependencies": {
1936 1886 "@aws-crypto/sha256-browser": "5.2.0",
1937 1887 "@aws-crypto/sha256-js": "5.2.0",
1953 1903 "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.27.tgz",
1954 1904 "integrity": "sha512-0Phbz4t6HI3D3skxvG2uI+VWU034/nSIw1T8d+FPzzQG9EQTrw94o9mOKO2Gv3n3Oc8P7JD7RAUxkoneLWv5Eg==",
1955 1905 "license": "Apache-2.0",
1956 - "peer": true,
1957 1906 "dependencies": {
1958 1907 "@aws-sdk/types": "^3.973.8",
1959 1908 "@smithy/core": "^3.24.2",
1970 1919 "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1048.0.tgz",
1971 1920 "integrity": "sha512-k0y/GcuesuSfWyUM0WamrGyeZmltRYaPbHO82UDA6mZ/doB+FOHKutikPAtSXMn/hDz970cF+iRuuiYO9VEbAA==",
1972 1921 "license": "Apache-2.0",
1973 - "peer": true,
1974 1922 "dependencies": {
1975 1923 "@aws-sdk/core": "^3.974.11",
1976 1924 "@aws-sdk/nested-clients": "^3.997.9",
1988 1936 "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.973.8.tgz",
1989 1937 "integrity": "sha512-gjlAdtHMbtR9X5iIhVUvbVcy55KnznpC6bkDUWW9z915bi0ckdUr5cjf16Kp6xq0bP5HBD2xzgbL9F9Quv5vUw==",
1990 1938 "license": "Apache-2.0",
1991 - "peer": true,
1992 1939 "dependencies": {
1993 1940 "@smithy/types": "^4.14.1",
1994 1941 "tslib": "^2.6.2"
2002 1949 "resolved": "https://registry.npmjs.org/@aws-sdk/util-locate-window/-/util-locate-window-3.965.5.tgz",
2003 1950 "integrity": "sha512-WhlJNNINQB+9qtLtZJcpQdgZw3SCDCpXdUJP7cToGwHbCWCnRckGlc6Bx/OhWwIYFNAn+FIydY8SZ0QmVu3xTQ==",
2004 1951 "license": "Apache-2.0",
2005 - "peer": true,
2006 1952 "dependencies": {
2007 1953 "tslib": "^2.6.2"
2015 1961 "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.24.tgz",
2016 1962 "integrity": "sha512-V8z5YcDPfsvzrBlj0xR1vhRtocblhYbqdreCJB/voGd4Sr5zjNAeWxexbnqVtskTJe0vFb5KMqbSL++ePl+zRw==",
2017 1963 "license": "Apache-2.0",
2018 - "peer": true,
2019 1964 "dependencies": {
2020 1965 "@nodable/entities": "2.1.0",
2021 1966 "@smithy/types": "^4.14.1",
2031 1976 "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.4.tgz",
2032 1977 "integrity": "sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ==",
2033 1978 "license": "Apache-2.0",
2034 - "peer": true,
2035 1979 "engines": {
2036 1980 "node": ">=18.0.0"
2041 1985 "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz",
2042 1986 "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
2043 1987 "license": "MIT",
2044 - "peer": true,
2045 1988 "engines": {
2046 1989 "node": ">=6.9.0"
2049 1992 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-agent-core": {
2050 - "version": "0.84.1",
2051 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.84.1.tgz",
1993 + "version": "0.84.2",
1994 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.84.2.tgz",
2052 1995 "license": "MIT",
2053 - "peer": true,
2054 1996 "dependencies": {
2055 - "@earendil-works/pi-ai": "^0.84.1",
2056 - "@earendil-works/pi-telemetry": "^0.84.1",
1997 + "@earendil-works/pi-ai": "^0.84.2",
1998 + "@earendil-works/pi-telemetry": "^0.84.2",
2057 1999 "diff": "8.0.4",
2058 2000 "ignore": "7.0.5",
2059 2001 "typebox": "1.3.7",
2066 2008 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-ai": {
2067 - "version": "0.84.1",
2068 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.84.1.tgz",
2009 + "version": "0.84.2",
2010 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.84.2.tgz",
2069 2011 "license": "MIT",
2070 - "peer": true,
2071 2012 "dependencies": {
2072 2013 "@anthropic-ai/sdk": "0.91.1",
2073 2014 "@aws-sdk/client-bedrock-runtime": "3.1048.0",
2074 - "@earendil-works/pi-telemetry": "^0.84.1",
2015 + "@earendil-works/pi-telemetry": "^0.84.2",
2075 2016 "@google/genai": "1.52.0",
2076 - "@mistralai/mistralai": "2.2.6",
2077 2017 "@opentelemetry/api": "1.9.0",
2078 2018 "@smithy/node-http-handler": "4.7.3",
2079 2019 "http-proxy-agent": "7.0.2",
2080 2020 "https-proxy-agent": "7.0.6",
2081 - "openai": "6.26.0",
2021 + "openai": "6.40.0",
2082 2022 "partial-json": "0.1.7",
2083 2023 "typebox": "1.3.7"
2092 2032 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-client": {
2093 - "version": "0.84.1",
2094 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-client/-/pi-client-0.84.1.tgz",
2033 + "version": "0.84.2",
2034 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-client/-/pi-client-0.84.2.tgz",
2095 2035 "license": "MIT",
2096 - "peer": true,
2097 2036 "dependencies": {
2098 - "@earendil-works/pi-protocol": "^0.84.1"
2037 + "@earendil-works/pi-protocol": "^0.84.2"
2100 2039 "engines": {
2101 2040 "node": ">=22.19.0"
2104 2043 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-protocol": {
2105 - "version": "0.84.1",
2106 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-protocol/-/pi-protocol-0.84.1.tgz",
2044 + "version": "0.84.2",
2045 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-protocol/-/pi-protocol-0.84.2.tgz",
2107 2046 "license": "MIT",
2108 - "peer": true,
2109 2047 "dependencies": {
2110 2048 "typebox": "1.3.7"
2116 2054 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-telemetry": {
2117 - "version": "0.84.1",
2118 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-telemetry/-/pi-telemetry-0.84.1.tgz",
2055 + "version": "0.84.2",
2056 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-telemetry/-/pi-telemetry-0.84.2.tgz",
2119 2057 "license": "MIT",
2120 - "peer": true,
2121 2058 "engines": {
2122 2059 "node": ">=22.19.0"
2125 2062 "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui": {
2126 - "version": "0.84.1",
2127 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.84.1.tgz",
2063 + "version": "0.84.2",
2064 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.84.2.tgz",
2128 2065 "license": "MIT",
2129 - "peer": true,
2130 2066 "dependencies": {
2131 2067 "get-east-asian-width": "1.6.0",
2132 2068 "marked": "18.0.5"
2141 2077 "integrity": "sha512-gwSvbpiN/17O9TbsqSsE/OzZcpv5Fo4RQjdngGgogtuB9RsyJ8ZHhX5KjHj1bp5N9snN2eK8LDGXSaWW2hof8Q==",
2142 2078 "hasInstallScript": true,
2143 2079 "license": "Apache-2.0",
2144 - "peer": true,
2145 2080 "dependencies": {
2146 2081 "google-auth-library": "^10.3.0",
2147 2082 "p-retry": "^4.6.2",
2166 2101 "integrity": "sha512-ABnA53mdfkGZwOFUdZNv2S0CWGO/EIuPj8Vv9xmBFmSYg/qFc7ihO6q5FcQjvoE67kZpWkEc4AhD6B/os04yuA==",
2167 2102 "license": "MIT",
2168 2103 "optional": true,
2169 - "peer": true,
2170 2104 "engines": {
2171 2105 "node": ">= 10"
2195 2129 "os": [
2196 2130 "darwin"
2198 - "peer": true,
2199 2132 "engines": {
2200 2133 "node": ">= 10"
2209 2142 "os": [
2210 2143 "darwin"
2212 - "peer": true,
2213 2145 "engines": {
2214 2146 "node": ">= 10"
2226 2158 "os": [
2227 2159 "darwin"
2229 - "peer": true,
2230 2161 "engines": {
2231 2162 "node": ">= 10"
2243 2174 "os": [
2244 2175 "linux"
2246 - "peer": true,
2247 2177 "engines": {
2248 2178 "node": ">= 10"
2260 2190 "os": [
2261 2191 "linux"
2263 - "peer": true,
2264 2193 "engines": {
2265 2194 "node": ">= 10"
2277 2206 "os": [
2278 2207 "linux"
2280 - "peer": true,
2281 2209 "engines": {
2282 2210 "node": ">= 10"
2294 2222 "os": [
2295 2223 "linux"
2297 - "peer": true,
2298 2225 "engines": {
2299 2226 "node": ">= 10"
2311 2238 "os": [
2312 2239 "linux"
2314 - "peer": true,
2315 2241 "engines": {
2316 2242 "node": ">= 10"
2328 2254 "os": [
2329 2255 "win32"
2331 - "peer": true,
2332 2257 "engines": {
2333 2258 "node": ">= 10"
2345 2270 "os": [
2346 2271 "win32"
2348 - "peer": true,
2349 2273 "engines": {
2350 2274 "node": ">= 10"
2353 - "node_modules/@earendil-works/pi-coding-agent/node_modules/@mistralai/mistralai": {
2354 - "version": "2.2.6",
2355 - "resolved": "https://registry.npmjs.org/@mistralai/mistralai/-/mistralai-2.2.6.tgz",
2356 - "integrity": "sha512-W8pX7zHxjJvMIpw8JMxeJEleapXX0Q9NPszdNzqkM3MIEoIGPObdodujj+WHteXEvGfaP/AMwlNyRfEzSY6dQQ==",
2357 - "license": "Apache-2.0",
2358 - "peer": true,
2359 - "dependencies": {
2360 - "@opentelemetry/semantic-conventions": "^1.40.0",
2361 - "ws": "^8.18.0",
2362 - "zod": "^3.25.0 || ^4.0.0",
2363 - "zod-to-json-schema": "^3.25.0"
2364 - },
2365 - "peerDependencies": {
2366 - "@opentelemetry/api": "^1.9.0"
2367 - },
2368 - "peerDependenciesMeta": {
2369 - "@opentelemetry/api": {
2370 - "optional": true
2373 - },
2374 2277 "node_modules/@earendil-works/pi-coding-agent/node_modules/@nodable/entities": {
2375 2278 "version": "2.1.0",
2376 2279 "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.1.0.tgz",
2381 2284 "url": "https://github.com/sponsors/nodable"
2384 - "license": "MIT",
2385 - "peer": true
2287 + "license": "MIT"
2387 2289 "node_modules/@earendil-works/pi-coding-agent/node_modules/@opentelemetry/api": {
2388 2290 "version": "1.9.0",
2389 2291 "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
2390 2292 "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
2391 2293 "license": "Apache-2.0",
2392 - "peer": true,
2393 2294 "engines": {
2394 2295 "node": ">=8.0.0"
2397 - "node_modules/@earendil-works/pi-coding-agent/node_modules/@opentelemetry/semantic-conventions": {
2398 - "version": "1.41.1",
2399 - "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.41.1.tgz",
2400 - "integrity": "sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA==",
2401 - "license": "Apache-2.0",
2402 - "peer": true,
2403 - "engines": {
2404 - "node": ">=14"
2406 - },
2407 2298 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/aspromise": {
2408 2299 "version": "1.1.2",
2409 2300 "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
2410 2301 "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
2411 - "license": "BSD-3-Clause",
2412 - "peer": true
2302 + "license": "BSD-3-Clause"
2414 2304 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/base64": {
2415 2305 "version": "1.1.2",
2416 2306 "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
2417 2307 "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
2418 - "license": "BSD-3-Clause",
2419 - "peer": true
2308 + "license": "BSD-3-Clause"
2421 2310 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/codegen": {
2422 2311 "version": "2.0.5",
2423 2312 "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
2424 2313 "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
2425 - "license": "BSD-3-Clause",
2426 - "peer": true
2314 + "license": "BSD-3-Clause"
2428 2316 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/eventemitter": {
2429 2317 "version": "1.1.1",
2430 2318 "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
2431 2319 "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
2432 - "license": "BSD-3-Clause",
2433 - "peer": true
2320 + "license": "BSD-3-Clause"
2435 2322 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/fetch": {
2436 2323 "version": "1.1.1",
2437 2324 "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
2438 2325 "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
2439 2326 "license": "BSD-3-Clause",
2440 - "peer": true,
2441 2327 "dependencies": {
2442 2328 "@protobufjs/aspromise": "^1.1.1"
2446 2332 "version": "1.0.2",
2447 2333 "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
2448 2334 "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
2449 - "license": "BSD-3-Clause",
2450 - "peer": true
2335 + "license": "BSD-3-Clause"
2452 2337 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/path": {
2453 2338 "version": "1.1.2",
2454 2339 "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
2455 2340 "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
2456 - "license": "BSD-3-Clause",
2457 - "peer": true
2341 + "license": "BSD-3-Clause"
2459 2343 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/pool": {
2460 2344 "version": "1.1.0",
2461 2345 "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
2462 2346 "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
2463 - "license": "BSD-3-Clause",
2464 - "peer": true
2347 + "license": "BSD-3-Clause"
2466 2349 "node_modules/@earendil-works/pi-coding-agent/node_modules/@protobufjs/utf8": {
2467 2350 "version": "1.1.1",
2468 2351 "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.1.tgz",
2469 2352 "integrity": "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==",
2470 - "license": "BSD-3-Clause",
2471 - "peer": true
2353 + "license": "BSD-3-Clause"
2473 2355 "node_modules/@earendil-works/pi-coding-agent/node_modules/@silvia-odwyer/photon-node": {
2474 2356 "version": "0.3.4",
2475 2357 "resolved": "https://registry.npmjs.org/@silvia-odwyer/photon-node/-/photon-node-0.3.4.tgz",
2476 2358 "integrity": "sha512-bnly4BKB3KDTFxrUIcgCLbaeVVS8lrAkri1pEzskpmxu9MdfGQTy8b8EgcD83ywD3RPMsIulY8xJH5Awa+t9fA==",
2477 - "license": "Apache-2.0",
2478 - "peer": true
2359 + "license": "Apache-2.0"
2480 2361 "node_modules/@earendil-works/pi-coding-agent/node_modules/@smithy/core": {
2481 2362 "version": "3.24.3",
2482 2363 "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.24.3.tgz",
2483 2364 "integrity": "sha512-Ep/7tPamGY8mgESE3LyLKtxJyy6U52WWAqr/3wial47Sj4u3PiIF73AOGI27UyLy9duTkhZbgzodOfLV4TduZg==",
2484 2365 "license": "Apache-2.0",
2485 - "peer": true,
2486 2366 "dependencies": {
2487 2367 "@aws-crypto/crc32": "5.2.0",
2488 2368 "@smithy/types": "^4.14.2",
2497 2377 "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.3.3.tgz",
2498 2378 "integrity": "sha512-I2Bti0DKFo2IJyN28ijCsx51BAumEYR4/1yZ1FXyBygy9MqbnMqCev4JPth/MbpRfBSRAX35hITSnAdJRo1u5w==",
2499 2379 "license": "Apache-2.0",
2500 - "peer": true,
2501 2380 "dependencies": {
2502 2381 "@smithy/core": "^3.24.3",
2503 2382 "@smithy/types": "^4.14.2",
2512 2391 "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.4.3.tgz",
2513 2392 "integrity": "sha512-F+DRf8IJazRJgYog2A/yJK7eYVc0rqTlRzO+5ZxjJd4WkZoKz0IJRncf7G6t1pdVT3kryJcwuTFhN1c5m6N47A==",
2514 2393 "license": "Apache-2.0",
2515 - "peer": true,
2516 2394 "dependencies": {
2517 2395 "@smithy/core": "^3.24.3",
2518 2396 "@smithy/types": "^4.14.2",
2527 2405 "resolved": "https://registry.npmjs.org/@smithy/is-array-buffer/-/is-array-buffer-2.2.0.tgz",
2528 2406 "integrity": "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==",
2529 2407 "license": "Apache-2.0",
2530 - "peer": true,
2531 2408 "dependencies": {
2532 2409 "tslib": "^2.6.2"
2540 2417 "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.7.3.tgz",
2541 2418 "integrity": "sha512-/jPhevcTFPMVl6KNjbaI47iOg1zxC7IsnX4PQDGVZKMFceOXtB8IEYaB7a9VvkP/3oC60WzTeKocvSI7vLT0vA==",
2542 2419 "license": "Apache-2.0",
2543 - "peer": true,
2544 2420 "dependencies": {
2545 2421 "@smithy/core": "^3.24.3",
2546 2422 "@smithy/types": "^4.14.2",
2555 2431 "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.4.3.tgz",
2556 2432 "integrity": "sha512-53+75QuPl6DL+ct6vVEB51FDO5oulXr20TPV46VvJZg76lIlXNWfxi8j+G2V/t0I2qxCBOa3vX/8bmjrpFVo9g==",
2557 2433 "license": "Apache-2.0",
2558 - "peer": true,
2559 2434 "dependencies": {
2560 2435 "@smithy/core": "^3.24.3",
2561 2436 "@smithy/types": "^4.14.2",
2570 2445 "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.14.2.tgz",
2571 2446 "integrity": "sha512-P+otAxbV4CqBybp7EkcJCrig63yE2E7PuNVOmilVMRcx/O+QDzGULTrKsq4DV13gSfak9ObPrWaHl/9bL5YcWw==",
2572 2447 "license": "Apache-2.0",
2573 - "peer": true,
2574 2448 "dependencies": {
2575 2449 "tslib": "^2.6.2"
2583 2457 "resolved": "https://registry.npmjs.org/@smithy/util-buffer-from/-/util-buffer-from-2.2.0.tgz",
2584 2458 "integrity": "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==",
2585 2459 "license": "Apache-2.0",
2586 - "peer": true,
2587 2460 "dependencies": {
2588 2461 "@smithy/is-array-buffer": "^2.2.0",
2589 2462 "tslib": "^2.6.2"
2597 2470 "resolved": "https://registry.npmjs.org/@smithy/util-utf8/-/util-utf8-2.3.0.tgz",
2598 2471 "integrity": "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==",
2599 2472 "license": "Apache-2.0",
2600 - "peer": true,
2601 2473 "dependencies": {
2602 2474 "@smithy/util-buffer-from": "^2.2.0",
2603 2475 "tslib": "^2.6.2"
2611 2483 "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.19.tgz",
2612 2484 "integrity": "sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==",
2613 2485 "license": "MIT",
2614 - "peer": true,
2615 2486 "dependencies": {
2616 2487 "undici-types": "~6.21.0"
2621 2492 "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
2622 2493 "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
2623 2494 "license": "MIT",
2624 - "peer": true,
2625 2495 "engines": {
2626 2496 "node": ">= 14"
2631 2501 "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
2632 2502 "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
2633 2503 "license": "MIT",
2634 - "peer": true,
2635 2504 "engines": {
2636 2505 "node": "18 || 20 || >=22"
2654 2523 "url": "https://feross.org/support"
2657 - "license": "MIT",
2658 - "peer": true
2526 + "license": "MIT"
2660 2528 "node_modules/@earendil-works/pi-coding-agent/node_modules/bignumber.js": {
2661 2529 "version": "9.3.1",
2662 2530 "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz",
2663 2531 "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==",
2664 2532 "license": "MIT",
2665 - "peer": true,
2666 2533 "engines": {
2667 2534 "node": "*"
2671 2538 "version": "2.14.1",
2672 2539 "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
2673 2540 "integrity": "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==",
2674 - "license": "MIT",
2675 - "peer": true
2541 + "license": "MIT"
2677 2543 "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion": {
2678 2544 "version": "5.0.9",
2679 2545 "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
2680 2546 "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
2681 2547 "license": "MIT",
2682 - "peer": true,
2683 2548 "dependencies": {
2684 2549 "balanced-match": "^4.0.2"
2691 2556 "version": "1.0.1",
2692 2557 "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
2693 2558 "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
2694 - "license": "BSD-3-Clause",
2695 - "peer": true
2559 + "license": "BSD-3-Clause"
2697 2561 "node_modules/@earendil-works/pi-coding-agent/node_modules/chalk": {
2698 2562 "version": "5.6.2",
2699 2563 "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
2700 2564 "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
2701 2565 "license": "MIT",
2702 - "peer": true,
2703 2566 "engines": {
2704 2567 "node": "^12.17.0 || ^14.13 || >=16.0.0"
2712 2575 "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
2713 2576 "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
2714 2577 "license": "MIT",
2715 - "peer": true,
2716 2578 "dependencies": {
2717 2579 "path-key": "^3.1.0",
2718 2580 "shebang-command": "^2.0.0",
2727 2589 "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
2728 2590 "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
2729 2591 "license": "MIT",
2730 - "peer": true,
2731 2592 "engines": {
2732 2593 "node": ">= 12"
2737 2598 "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
2738 2599 "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
2739 2600 "license": "MIT",
2740 - "peer": true,
2741 2601 "dependencies": {
2742 2602 "ms": "^2.1.3"
2755 2615 "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.4.tgz",
2756 2616 "integrity": "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==",
2757 2617 "license": "BSD-3-Clause",
2758 - "peer": true,
2759 2618 "engines": {
2760 2619 "node": ">=0.3.1"
2765 2624 "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
2766 2625 "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
2767 2626 "license": "Apache-2.0",
2768 - "peer": true,
2769 2627 "dependencies": {
2770 2628 "safe-buffer": "^5.0.1"
2774 2632 "version": "3.0.2",
2775 2633 "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
2776 2634 "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
2777 - "license": "MIT",
2778 - "peer": true
2635 + "license": "MIT"
2780 2637 "node_modules/@earendil-works/pi-coding-agent/node_modules/fast-xml-builder": {
2781 2638 "version": "1.2.0",
2790 2647 "license": "MIT",
2791 - "peer": true,
2792 2648 "dependencies": {
2793 2649 "path-expression-matcher": "^1.5.0",
2794 2650 "xml-naming": "^0.1.0"
2807 2663 "license": "MIT",
2808 - "peer": true,
2809 2664 "dependencies": {
2810 2665 "@nodable/entities": "^2.1.0",
2811 2666 "fast-xml-builder": "^1.1.7",
2833 2688 "license": "MIT",
2834 - "peer": true,
2835 2689 "dependencies": {
2836 2690 "node-domexception": "^1.0.0",
2837 2691 "web-streams-polyfill": "^3.0.3"
2845 2699 "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
2846 2700 "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
2847 2701 "license": "MIT",
2848 - "peer": true,
2849 2702 "dependencies": {
2850 2703 "fetch-blob": "^3.1.2"
2858 2711 "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.4.tgz",
2859 2712 "integrity": "sha512-bTIgTsM2bWn3XklZISBTQX7ZSddGW+IO3bMdGaemHZ3tbqExMENHLx6kKZ/KlejgrMtj8q7wBItt51yegqalrA==",
2860 2713 "license": "Apache-2.0",
2861 - "peer": true,
2862 2714 "dependencies": {
2863 2715 "extend": "^3.0.2",
2864 2716 "https-proxy-agent": "^7.0.1",
2873 2725 "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-8.1.2.tgz",
2874 2726 "integrity": "sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==",
2875 2727 "license": "Apache-2.0",
2876 - "peer": true,
2877 2728 "dependencies": {
2878 2729 "gaxios": "^7.0.0",
2879 2730 "google-logging-utils": "^1.0.0",
2888 2739 "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
2889 2740 "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==",
2890 2741 "license": "MIT",
2891 - "peer": true,
2892 2742 "engines": {
2893 2743 "node": ">=18"
2901 2751 "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
2902 2752 "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
2903 2753 "license": "BlueOak-1.0.0",
2904 - "peer": true,
2905 2754 "dependencies": {
2906 2755 "minimatch": "^10.2.2",
2907 2756 "minipass": "^7.1.3",
2919 2768 "resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.6.2.tgz",
2920 2769 "integrity": "sha512-e27Z6EThmVNNvtYASwQxose/G57rkRuaRbQyxM2bvYLLX/GqWZ5chWq2EBoUchJbCc57eC9ArzO5wMsEmWftCw==",
2921 2770 "license": "Apache-2.0",
2922 - "peer": true,
2923 2771 "dependencies": {
2924 2772 "base64-js": "^1.3.0",
2925 2773 "ecdsa-sig-formatter": "^1.0.11",
2937 2785 "resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.3.tgz",
2938 2786 "integrity": "sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==",
2939 2787 "license": "Apache-2.0",
2940 - "peer": true,
2941 2788 "engines": {
2942 2789 "node": ">=14"
2946 2793 "version": "4.2.11",
2947 2794 "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
2948 2795 "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
2949 - "license": "ISC",
2950 - "peer": true
2796 + "license": "ISC"
2952 2798 "node_modules/@earendil-works/pi-coding-agent/node_modules/grok-mermaid": {
2953 2799 "version": "0.2.2",
2954 2800 "resolved": "https://registry.npmjs.org/grok-mermaid/-/grok-mermaid-0.2.2.tgz",
2955 2801 "integrity": "sha512-XcJEP5dDC8liHBh52mlLjU18fNvu1ckFsu0QpIG3+APZ270fsj9wxpiA6cOURmbUEuoMVgjbC2+UYgTdCqqgzA==",
2956 2802 "license": "Apache-2.0",
2957 - "peer": true,
2958 2803 "engines": {
2959 2804 "node": ">=18"
2964 2809 "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.7.3.tgz",
2965 2810 "integrity": "sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==",
2966 2811 "license": "BSD-3-Clause",
2967 - "peer": true,
2968 2812 "engines": {
2969 2813 "node": "*"
2974 2818 "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-9.0.3.tgz",
2975 2819 "integrity": "sha512-Hc+ghLoSt6QaYZUv0WBiIvmMDZuZZ7oaDvdH8MbfOO4lOsxdXLEvuC6ePoGs9H1X9oCLyq6+NVN0MKqD+ydxyg==",
2976 2820 "license": "ISC",
2977 - "peer": true,
2978 2821 "dependencies": {
2979 2822 "lru-cache": "^11.1.0"
2987 2830 "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
2988 2831 "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
2989 2832 "license": "MIT",
2990 - "peer": true,
2991 2833 "dependencies": {
2992 2834 "agent-base": "^7.1.0",
2993 2835 "debug": "^4.3.4"
3001 2843 "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
3002 2844 "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
3003 2845 "license": "MIT",
3004 - "peer": true,
3005 2846 "dependencies": {
3006 2847 "agent-base": "^7.1.2",
3007 2848 "debug": "4"
3015 2856 "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
3016 2857 "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
3017 2858 "license": "MIT",
3018 - "peer": true,
3019 2859 "engines": {
3020 2860 "node": ">= 4"
3024 2864 "version": "2.0.0",
3025 2865 "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
3026 2866 "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
3027 - "license": "ISC",
3028 - "peer": true
2867 + "license": "ISC"
3030 2869 "node_modules/@earendil-works/pi-coding-agent/node_modules/jiti": {
3031 2870 "version": "2.7.0",
3032 2871 "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
3033 2872 "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==",
3034 2873 "license": "MIT",
3035 - "peer": true,
3036 2874 "bin": {
3037 2875 "jiti": "lib/jiti-cli.mjs"
3042 2880 "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
3043 2881 "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
3044 2882 "license": "MIT",
3045 - "peer": true,
3046 2883 "dependencies": {
3047 2884 "bignumber.js": "^9.0.0"
3052 2889 "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
3053 2890 "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
3054 2891 "license": "MIT",
3055 - "peer": true,
3056 2892 "dependencies": {
3057 2893 "@babel/runtime": "^7.18.3",
3058 2894 "ts-algebra": "^2.0.0"
3066 2902 "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
3067 2903 "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
3068 2904 "license": "MIT",
3069 - "peer": true,
3070 2905 "dependencies": {
3071 2906 "buffer-equal-constant-time": "^1.0.1",
3072 2907 "ecdsa-sig-formatter": "1.0.11",
3078 2913 "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
3079 2914 "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
3080 2915 "license": "MIT",
3081 - "peer": true,
3082 2916 "dependencies": {
3083 2917 "jwa": "^2.0.1",
3084 2918 "safe-buffer": "^5.0.1"
3088 2922 "version": "5.3.2",
3089 2923 "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
3090 2924 "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
3091 - "license": "Apache-2.0",
3092 - "peer": true
2925 + "license": "Apache-2.0"
3094 2927 "node_modules/@earendil-works/pi-coding-agent/node_modules/lru-cache": {
3095 2928 "version": "11.4.0",
3096 2929 "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.4.0.tgz",
3097 2930 "integrity": "sha512-W+R+kFL4HgVxONq2bhXPi3bGpzGe/yEhVOp233qw9wCRtgncJ15P3bC+e4zZMu4Cq7d+WAJjXGW0uUkifhcatA==",
3098 2931 "license": "BlueOak-1.0.0",
3099 - "peer": true,
3100 2932 "engines": {
3101 2933 "node": "20 || >=22"
3106 2938 "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.5.tgz",
3107 2939 "integrity": "sha512-S6GcvALHg6K4ohtu4E7x0a1AqhAjp6cV8KhLSyN9qVapnzJkusVBxZRcIU9AeYsbe6P1hKDusSbEOzGyyuce6w==",
3108 2940 "license": "MIT",
3109 - "peer": true,
3110 2941 "bin": {
3111 2942 "marked": "bin/marked.js"
3119 2950 "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
3120 2951 "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
3121 2952 "license": "BlueOak-1.0.0",
3122 - "peer": true,
3123 2953 "dependencies": {
3124 2954 "brace-expansion": "^5.0.5"
3135 2965 "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
3136 2966 "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
3137 2967 "license": "BlueOak-1.0.0",
3138 - "peer": true,
3139 2968 "engines": {
3140 2969 "node": ">=16 || 14 >=14.17"
3144 2973 "version": "2.1.3",
3145 2974 "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
3146 2975 "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
3147 - "license": "MIT",
3148 - "peer": true
2976 + "license": "MIT"
3150 2978 "node_modules/@earendil-works/pi-coding-agent/node_modules/node-domexception": {
3151 2979 "version": "1.0.0",
3165 2993 "license": "MIT",
3166 - "peer": true,
3167 2994 "engines": {
3168 2995 "node": ">=10.5.0"
3173 3000 "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
3174 3001 "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
3175 3002 "license": "MIT",
3176 - "peer": true,
3177 3003 "dependencies": {
3178 3004 "data-uri-to-buffer": "^4.0.0",
3179 3005 "fetch-blob": "^3.1.4",
3190 3016 "node_modules/@earendil-works/pi-coding-agent/node_modules/openai": {
3191 - "version": "6.26.0",
3192 - "resolved": "https://registry.npmjs.org/openai/-/openai-6.26.0.tgz",
3193 - "integrity": "sha512-zd23dbWTjiJ6sSAX6s0HrCZi41JwTA1bQVs0wLQPZ2/5o2gxOJA5wh7yOAUgwYybfhDXyhwlpeQf7Mlgx8EOCA==",
3017 + "version": "6.40.0",
3018 + "resolved": "https://registry.npmjs.org/openai/-/openai-6.40.0.tgz",
3019 + "integrity": "sha512-MWtTjd/gQt4jpbji61NTgFWJLoY/PdRJ6wG9/ZDRMYNMlBKrCrSlkLI+KgHP1vR1qT6LKSAyAqIxno6lcK9JiA==",
3194 3020 "license": "Apache-2.0",
3195 - "peer": true,
3196 - "bin": {
3197 - "openai": "bin/cli"
3198 - },
3199 3021 "peerDependencies": {
3200 3022 "ws": "^8.18.0",
3201 3023 "zod": "^3.25 || ^4.0"
3214 3036 "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz",
3215 3037 "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==",
3216 3038 "license": "MIT",
3217 - "peer": true,
3218 3039 "dependencies": {
3219 3040 "@types/retry": "0.12.0",
3220 3041 "retry": "^0.13.1"
3227 3048 "version": "0.12.0",
3228 3049 "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz",
3229 3050 "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==",
3230 - "license": "MIT",
3231 - "peer": true
3051 + "license": "MIT"
3233 3053 "node_modules/@earendil-works/pi-coding-agent/node_modules/partial-json": {
3234 3054 "version": "0.1.7",
3235 3055 "resolved": "https://registry.npmjs.org/partial-json/-/partial-json-0.1.7.tgz",
3236 3056 "integrity": "sha512-Njv/59hHaokb/hRUjce3Hdv12wd60MtM9Z5Olmn+nehe0QDAsRtRbJPvJ0Z91TusF0SuZRIvnM+S4l6EIP8leA==",
3237 - "license": "MIT",
3238 - "peer": true
3057 + "license": "MIT"
3240 3059 "node_modules/@earendil-works/pi-coding-agent/node_modules/path-expression-matcher": {
3241 3060 "version": "1.5.0",
3250 3069 "license": "MIT",
3251 - "peer": true,
3252 3070 "engines": {
3253 3071 "node": ">=14.0.0"
3258 3076 "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
3259 3077 "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
3260 3078 "license": "MIT",
3261 - "peer": true,
3262 3079 "engines": {
3263 3080 "node": ">=8"
3268 3085 "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
3269 3086 "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
3270 3087 "license": "BlueOak-1.0.0",
3271 - "peer": true,
3272 3088 "dependencies": {
3273 3089 "lru-cache": "^11.0.0",
3274 3090 "minipass": "^7.1.2"
3285 3101 "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
3286 3102 "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
3287 3103 "license": "MIT",
3288 - "peer": true,
3289 3104 "dependencies": {
3290 3105 "graceful-fs": "^4.2.4",
3291 3106 "retry": "^0.12.0",
3297 3112 "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
3298 3113 "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
3299 3114 "license": "MIT",
3300 - "peer": true,
3301 3115 "engines": {
3302 3116 "node": ">= 4"
3308 3122 "integrity": "sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw==",
3309 3123 "hasInstallScript": true,
3310 3124 "license": "BSD-3-Clause",
3311 - "peer": true,
3312 3125 "dependencies": {
3313 3126 "@protobufjs/aspromise": "^1.1.2",
3314 3127 "@protobufjs/base64": "^1.1.2",
3331 3144 "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
3332 3145 "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
3333 3146 "license": "MIT",
3334 - "peer": true,
3335 3147 "engines": {
3336 3148 "node": ">= 4"
3354 3166 "url": "https://feross.org/support"
3357 - "license": "MIT",
3358 - "peer": true
3169 + "license": "MIT"
3360 3171 "node_modules/@earendil-works/pi-coding-agent/node_modules/semver": {
3361 3172 "version": "7.8.0",
3362 3173 "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.0.tgz",
3363 3174 "integrity": "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==",
3364 3175 "license": "ISC",
3365 - "peer": true,
3366 3176 "bin": {
3367 3177 "semver": "bin/semver.js"
3375 3185 "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
3376 3186 "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
3377 3187 "license": "MIT",
3378 - "peer": true,
3379 3188 "dependencies": {
3380 3189 "shebang-regex": "^3.0.0"
3388 3197 "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
3389 3198 "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
3390 3199 "license": "MIT",
3391 - "peer": true,
3392 3200 "engines": {
3393 3201 "node": ">=8"
3397 3205 "version": "3.0.7",
3398 3206 "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
3399 3207 "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
3400 - "license": "ISC",
3401 - "peer": true
3208 + "license": "ISC"
3403 3210 "node_modules/@earendil-works/pi-coding-agent/node_modules/strnum": {
3404 3211 "version": "2.3.0",
3410 3217 "url": "https://github.com/sponsors/NaturalIntelligence"
3413 - "license": "MIT",
3414 - "peer": true
3220 + "license": "MIT"
3416 3222 "node_modules/@earendil-works/pi-coding-agent/node_modules/ts-algebra": {
3417 3223 "version": "2.0.0",
3418 3224 "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
3419 3225 "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
3420 - "license": "MIT",
3421 - "peer": true
3226 + "license": "MIT"
3423 3228 "node_modules/@earendil-works/pi-coding-agent/node_modules/tslib": {
3424 3229 "version": "2.8.1",
3425 3230 "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
3426 3231 "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
3427 - "license": "0BSD",
3428 - "peer": true
3232 + "license": "0BSD"
3430 3234 "node_modules/@earendil-works/pi-coding-agent/node_modules/typebox": {
3431 3235 "version": "1.3.7",
3432 3236 "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.7.tgz",
3433 3237 "integrity": "sha512-meKuifc33Pccx0O6PdIzYMq3Og8zvP4TIi/a+Bw3AEMZMxOD0+RHGQvpglEe6Zdy3wZ8nqn/j95h8LUZLk/6Hg==",
3434 - "license": "MIT",
3435 - "peer": true
3238 + "license": "MIT"
3437 3240 "node_modules/@earendil-works/pi-coding-agent/node_modules/undici": {
3438 3241 "version": "8.9.0",
3439 3242 "resolved": "https://registry.npmjs.org/undici/-/undici-8.9.0.tgz",
3440 3243 "integrity": "sha512-aWZpUj7XoGonMClx4gdDRfgBjqeA+F473aDmROQQbM9n6PRfK/u1q/a0X4wMTgcHfT8H6fpbt98PFuDUwFg2YA==",
3441 3244 "license": "MIT",
3442 - "peer": true,
3443 3245 "engines": {
3444 3246 "node": ">=22.19.0"
3448 3250 "version": "6.21.0",
3449 3251 "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
3450 3252 "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
3451 - "license": "MIT",
3452 - "peer": true
3253 + "license": "MIT"
3454 3255 "node_modules/@earendil-works/pi-coding-agent/node_modules/web-streams-polyfill": {
3455 3256 "version": "3.3.3",
3456 3257 "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
3457 3258 "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
3458 3259 "license": "MIT",
3459 - "peer": true,
3460 3260 "engines": {
3461 3261 "node": ">= 8"
3466 3266 "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
3467 3267 "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
3468 3268 "license": "ISC",
3469 - "peer": true,
3470 3269 "dependencies": {
3471 3270 "isexe": "^2.0.0"
3482 3281 "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
3483 3282 "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
3484 3283 "license": "MIT",
3485 - "peer": true,
3486 3284 "engines": {
3487 3285 "node": ">=10.0.0"
3512 3310 "license": "MIT",
3513 - "peer": true,
3514 3311 "engines": {
3515 3312 "node": ">=16.0.0"
3520 3317 "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
3521 3318 "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
3522 3319 "license": "ISC",
3523 - "peer": true,
3524 3320 "bin": {
3525 3321 "yaml": "bin.mjs"
3531 3327 "url": "https://github.com/sponsors/eemeli"
3534 - "node_modules/@earendil-works/pi-coding-agent/node_modules/zod": {
3535 - "version": "3.25.76",
3536 - "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
3537 - "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
3330 + "node_modules/@earendil-works/pi-protocol": {
3331 + "version": "0.84.2",
3332 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-protocol/-/pi-protocol-0.84.2.tgz",
3333 + "integrity": "sha512-jbBh03fkeckWEroHpcZBr4w5/Ibat8WwdXFlXHivYQImrQNFtLpDeL0t1cku4hmK0q3pceIRQHkw4fwbM4YILQ==",
3334 + "dev": true,
3538 3335 "license": "MIT",
3539 - "peer": true,
3540 - "funding": {
3541 - "url": "https://github.com/sponsors/colinhacks"
3336 + "dependencies": {
3337 + "typebox": "1.3.7"
3338 + },
3339 + "engines": {
3340 + "node": ">=22.19.0"
3544 - "node_modules/@earendil-works/pi-coding-agent/node_modules/zod-to-json-schema": {
3545 - "version": "3.25.2",
3546 - "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
3547 - "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
3548 - "license": "ISC",
3549 - "peer": true,
3550 - "peerDependencies": {
3551 - "zod": "^3.25.28 || ^4"
3343 + "node_modules/@earendil-works/pi-protocol/node_modules/typebox": {
3344 + "version": "1.3.7",
3345 + "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.7.tgz",
3346 + "integrity": "sha512-meKuifc33Pccx0O6PdIzYMq3Og8zvP4TIi/a+Bw3AEMZMxOD0+RHGQvpglEe6Zdy3wZ8nqn/j95h8LUZLk/6Hg==",
3347 + "dev": true,
3348 + "license": "MIT"
3554 3350 "node_modules/@earendil-works/pi-telemetry": {
3555 - "version": "0.84.1",
3556 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-telemetry/-/pi-telemetry-0.84.1.tgz",
3557 - "integrity": "sha512-180/xGJtsq7IoR3p9EKWjRd0e9M4DkxInhlo9xyD7prDC7Qrhqq+nhvwrW0lFjPfXcEI2FSHmGCSyvSJE9GsaQ==",
3351 + "version": "0.84.2",
3352 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-telemetry/-/pi-telemetry-0.84.2.tgz",
3353 + "integrity": "sha512-wg5caea7uIv1BHRBm2Y116RvFG4oSAiP5qk9tA2463PDGIr4K8M1Ceyyg5DOpF/shUUl0gk826yQJAeAcHYB9g==",
3558 3354 "license": "MIT",
3559 - "peer": true,
3560 3355 "engines": {
3561 3356 "node": ">=22.19.0"
3564 3359 "node_modules/@earendil-works/pi-tui": {
3565 - "version": "0.84.1",
3566 - "resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.84.1.tgz",
3567 - "integrity": "sha512-udeXFbgEhJ6JiB0uguwNVNkDy2FENfmtQwPcY+/iJ8GWeq18wkal1tKqa5YyeH0IqtX1vG0cGh8zfSYzyzVuLA==",
3360 + "version": "0.84.2",
3361 + "resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.84.2.tgz",
3362 + "integrity": "sha512-ds2TLihOnM5sLJB3VpXV6y0uR5efVuHf4MN7yDpsty6hA2DUO/EDVzjp/0od0G2JslzVLMjT8T8zavtxVb+qbg==",
3568 3363 "license": "MIT",
3569 - "peer": true,
3570 3364 "dependencies": {
3571 3365 "get-east-asian-width": "1.6.0",
3572 3366 "marked": "18.0.5"
3604 3398 "integrity": "sha512-gwSvbpiN/17O9TbsqSsE/OzZcpv5Fo4RQjdngGgogtuB9RsyJ8ZHhX5KjHj1bp5N9snN2eK8LDGXSaWW2hof8Q==",
3605 3399 "hasInstallScript": true,
3606 3400 "license": "Apache-2.0",
3607 - "peer": true,
3608 3401 "dependencies": {
3609 3402 "google-auth-library": "^10.3.0",
3610 3403 "p-retry": "^4.6.2",
3721 3514 "@chevrotain/types": "~11.1.2"
3724 - "node_modules/@mistralai/mistralai": {
3725 - "version": "2.2.6",
3726 - "resolved": "https://registry.npmjs.org/@mistralai/mistralai/-/mistralai-2.2.6.tgz",
3727 - "integrity": "sha512-W8pX7zHxjJvMIpw8JMxeJEleapXX0Q9NPszdNzqkM3MIEoIGPObdodujj+WHteXEvGfaP/AMwlNyRfEzSY6dQQ==",
3728 - "license": "Apache-2.0",
3729 - "peer": true,
3730 - "dependencies": {
3731 - "@opentelemetry/semantic-conventions": "^1.40.0",
3732 - "ws": "^8.18.0",
3733 - "zod": "^3.25.0 || ^4.0.0",
3734 - "zod-to-json-schema": "^3.25.0"
3735 - },
3736 - "peerDependencies": {
3737 - "@opentelemetry/api": "^1.9.0"
3738 - },
3739 - "peerDependenciesMeta": {
3740 - "@opentelemetry/api": {
3741 - "optional": true
3744 - },
3745 3517 "node_modules/@opentelemetry/api": {
3746 3518 "version": "1.9.0",
3747 3519 "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
3748 3520 "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
3749 3521 "license": "Apache-2.0",
3750 - "peer": true,
3751 3522 "engines": {
3752 3523 "node": ">=8.0.0"
3755 - "node_modules/@opentelemetry/semantic-conventions": {
3756 - "version": "1.43.0",
3757 - "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.43.0.tgz",
3758 - "integrity": "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg==",
3759 - "license": "Apache-2.0",
3760 - "peer": true,
3761 - "engines": {
3762 - "node": ">=14"
3764 - },
3765 3526 "node_modules/@oxc-project/types": {
3766 3527 "version": "0.143.0",
3767 3528 "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.143.0.tgz",
3904 3665 "version": "1.1.2",
3905 3666 "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
3906 3667 "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
3907 - "license": "BSD-3-Clause",
3908 - "peer": true
3668 + "license": "BSD-3-Clause"
3910 3670 "node_modules/@protobufjs/base64": {
3911 3671 "version": "1.1.2",
3912 3672 "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
3913 3673 "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
3914 - "license": "BSD-3-Clause",
3915 - "peer": true
3674 + "license": "BSD-3-Clause"
3917 3676 "node_modules/@protobufjs/codegen": {
3918 3677 "version": "2.0.5",
3919 3678 "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
3920 3679 "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
3921 - "license": "BSD-3-Clause",
3922 - "peer": true
3680 + "license": "BSD-3-Clause"
3924 3682 "node_modules/@protobufjs/eventemitter": {
3925 3683 "version": "1.1.1",
3926 3684 "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
3927 3685 "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
3928 - "license": "BSD-3-Clause",
3929 - "peer": true
3686 + "license": "BSD-3-Clause"
3931 3688 "node_modules/@protobufjs/fetch": {
3932 3689 "version": "1.1.1",
3933 3690 "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
3934 3691 "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
3935 3692 "license": "BSD-3-Clause",
3936 - "peer": true,
3937 3693 "dependencies": {
3938 3694 "@protobufjs/aspromise": "^1.1.1"
3942 3698 "version": "1.0.2",
3943 3699 "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
3944 3700 "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
3945 - "license": "BSD-3-Clause",
3946 - "peer": true
3701 + "license": "BSD-3-Clause"
3948 3703 "node_modules/@protobufjs/path": {
3949 3704 "version": "1.1.2",
3950 3705 "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
3951 3706 "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
3952 - "license": "BSD-3-Clause",
3953 - "peer": true
3707 + "license": "BSD-3-Clause"
3955 3709 "node_modules/@protobufjs/pool": {
3956 3710 "version": "1.1.0",
3957 3711 "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
3958 3712 "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
3959 - "license": "BSD-3-Clause",
3960 - "peer": true
3713 + "license": "BSD-3-Clause"
3962 3715 "node_modules/@protobufjs/utf8": {
3963 3716 "version": "1.1.2",
3964 3717 "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.2.tgz",
3965 3718 "integrity": "sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug==",
3966 - "license": "BSD-3-Clause",
3967 - "peer": true
3719 + "license": "BSD-3-Clause"
3969 3721 "node_modules/@rolldown/binding-android-arm64": {
3970 3722 "version": "1.2.3",
4347 4099 "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.31.1.tgz",
4348 4100 "integrity": "sha512-CyogUINxvi7C7LDsh8Syo6hVJOT9ckz4rG8dRZfTJ8r91HkMY59PnNooaj7WcHyxEkxPfBAmbgztZU+xTo76lg==",
4349 4101 "license": "Apache-2.0",
4350 - "peer": true,
4351 4102 "dependencies": {
4352 4103 "@smithy/types": "^4.16.1",
4353 4104 "tslib": "^2.6.2"
4361 4112 "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.4.16.tgz",
4362 4113 "integrity": "sha512-QfuLWAkLzptffFW980AFeHZFdqds2B64rpEd3uJ6lgs3xVn9QegGMUgUcj+4d7dRrAsya3r58ZKpku97WcFb4w==",
4363 4114 "license": "Apache-2.0",
4364 - "peer": true,
4365 4115 "dependencies": {
4366 4116 "@smithy/core": "^3.31.1",
4367 4117 "@smithy/types": "^4.16.1",
4376 4126 "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.6.13.tgz",
4377 4127 "integrity": "sha512-4fW86pEUOMbrD5nkbyl/tTvPHHWJFbuB2odl6ps9lWfHoXf9HWh3Q/Smh59qH1g7+c/BSZghX6bbUk4gsiMs8A==",
4378 4128 "license": "Apache-2.0",
4379 - "peer": true,
4380 4129 "dependencies": {
4381 4130 "@smithy/core": "^3.31.1",
4382 4131 "@smithy/types": "^4.16.1",
4391 4140 "resolved": "https://registry.npmjs.org/@smithy/is-array-buffer/-/is-array-buffer-2.2.0.tgz",
4392 4141 "integrity": "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==",
4393 4142 "license": "Apache-2.0",
4394 - "peer": true,
4395 4143 "dependencies": {
4396 4144 "tslib": "^2.6.2"
4404 4152 "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.7.3.tgz",
4405 4153 "integrity": "sha512-/jPhevcTFPMVl6KNjbaI47iOg1zxC7IsnX4PQDGVZKMFceOXtB8IEYaB7a9VvkP/3oC60WzTeKocvSI7vLT0vA==",
4406 4154 "license": "Apache-2.0",
4407 - "peer": true,
4408 4155 "dependencies": {
4409 4156 "@smithy/core": "^3.24.3",
4410 4157 "@smithy/types": "^4.14.2",
4419 4166 "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.6.12.tgz",
4420 4167 "integrity": "sha512-I6KLtq3H0qqSuV9vLglfi8puHqzygzWHOnI4z/Rdoo+q50vvo18vBRdPAvvEtcaKROz7Zn6qnPa14kRfPH6PcQ==",
4421 4168 "license": "Apache-2.0",
4422 - "peer": true,
4423 4169 "dependencies": {
4424 4170 "@smithy/core": "^3.31.1",
4425 4171 "@smithy/types": "^4.16.1",
4434 4180 "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.16.1.tgz",
4435 4181 "integrity": "sha512-0JFs3V2y2M9tKW5na/qxe69Zv+uxLMO7QBbhxF/FHu/Gp2NFZAAL9tWl9PU02xxo07pb3G9FTyjNc6D5uZrJIg==",
4436 4182 "license": "Apache-2.0",
4437 - "peer": true,
4438 4183 "dependencies": {
4439 4184 "tslib": "^2.6.2"
4447 4192 "resolved": "https://registry.npmjs.org/@smithy/util-buffer-from/-/util-buffer-from-2.2.0.tgz",
4448 4193 "integrity": "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==",
4449 4194 "license": "Apache-2.0",
4450 - "peer": true,
4451 4195 "dependencies": {
4452 4196 "@smithy/is-array-buffer": "^2.2.0",
4453 4197 "tslib": "^2.6.2"
4461 4205 "resolved": "https://registry.npmjs.org/@smithy/util-utf8/-/util-utf8-2.3.0.tgz",
4462 4206 "integrity": "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==",
4463 4207 "license": "Apache-2.0",
4464 - "peer": true,
4465 4208 "dependencies": {
4466 4209 "@smithy/util-buffer-from": "^2.2.0",
4467 4210 "tslib": "^2.6.2"
4811 4554 "resolved": "https://registry.npmjs.org/@types/node/-/node-26.2.0.tgz",
4812 4555 "integrity": "sha512-5IviulTZeRNp2vAJ514cc/HUlY5nZ9fCbq9DMyC52BrhFZACo3nI0R7qBxhQmo/d27NFe96ur/b7Wwxklda+kg==",
4813 4556 "license": "MIT",
4814 - "peer": true,
4815 4557 "dependencies": {
4816 4558 "undici-types": "~8.3.0"
4820 4562 "version": "0.12.0",
4821 4563 "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz",
4822 4564 "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==",
4823 - "license": "MIT",
4824 - "peer": true
4565 + "license": "MIT"
4826 4567 "node_modules/@types/trusted-types": {
4827 4568 "version": "2.0.7",
5004 4745 "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
5005 4746 "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
5006 4747 "license": "MIT",
5007 - "peer": true,
5008 4748 "engines": {
5009 4749 "node": ">= 14"
5047 4787 "url": "https://feross.org/support"
5050 - "license": "MIT",
5051 - "peer": true
4790 + "license": "MIT"
5053 4792 "node_modules/baseline-browser-mapping": {
5054 4793 "version": "2.11.13",
5068 4807 "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz",
5069 4808 "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==",
5070 4809 "license": "MIT",
5071 - "peer": true,
5072 4810 "engines": {
5073 4811 "node": "*"
5077 4815 "version": "2.14.1",
5078 4816 "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
5079 4817 "integrity": "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==",
5080 - "license": "MIT",
5081 - "peer": true
4818 + "license": "MIT"
5083 4820 "node_modules/browserslist": {
5084 4821 "version": "4.28.8",
5118 4855 "version": "1.0.1",
5119 4856 "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
5120 4857 "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
5121 - "license": "BSD-3-Clause",
5122 - "peer": true
4858 + "license": "BSD-3-Clause"
5124 4860 "node_modules/caniuse-lite": {
5125 4861 "version": "1.0.30001809",
5731 5467 "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
5732 5468 "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
5733 5469 "license": "MIT",
5734 - "peer": true,
5735 5470 "engines": {
5736 5471 "node": ">= 12"
5818 5553 "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.4.tgz",
5819 5554 "integrity": "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==",
5820 5555 "license": "BSD-3-Clause",
5821 - "peer": true,
5822 5556 "engines": {
5823 5557 "node": ">=0.3.1"
5837 5571 "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
5838 5572 "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
5839 5573 "license": "Apache-2.0",
5840 - "peer": true,
5841 5574 "dependencies": {
5842 5575 "safe-buffer": "^5.0.1"
6007 5740 "license": "MIT",
6008 - "peer": true,
6009 5741 "dependencies": {
6010 5742 "node-domexception": "^1.0.0",
6011 5743 "web-streams-polyfill": "^3.0.3"
6027 5759 "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
6028 5760 "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
6029 5761 "license": "MIT",
6030 - "peer": true,
6031 5762 "dependencies": {
6032 5763 "fetch-blob": "^3.1.2"
6055 5786 "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.3.0.tgz",
6056 5787 "integrity": "sha512-RB5vLV+vvQeoFPCX4QMK6/hjVkbIamPp1QSUD0CiZcnj12qbpiL+pLbYtgD+oZkWl0tl9z+o2Utp+MpM3QRhBA==",
6057 5788 "license": "Apache-2.0",
6058 - "peer": true,
6059 5789 "dependencies": {
6060 5790 "extend": "^3.0.2",
6061 5791 "https-proxy-agent": "^7.0.1",
6070 5800 "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-8.1.2.tgz",
6071 5801 "integrity": "sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==",
6072 5802 "license": "Apache-2.0",
6073 - "peer": true,
6074 5803 "dependencies": {
6075 5804 "gaxios": "^7.0.0",
6076 5805 "google-logging-utils": "^1.0.0",
6095 5824 "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
6096 5825 "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==",
6097 5826 "license": "MIT",
6098 - "peer": true,
6099 5827 "engines": {
6100 5828 "node": ">=18"
6114 5842 "resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.9.1.tgz",
6115 5843 "integrity": "sha512-i1ydyHrqcIxXkWh/uBmVkzCvIuq5yiK2ATndIe5XxKholrG/MTYP9xGYka4sQhrbIAgGjL2B6NOE7rFaiF3fXw==",
6116 5844 "license": "Apache-2.0",
6117 - "peer": true,
6118 5845 "dependencies": {
6119 5846 "base64-js": "^1.3.0",
6120 5847 "ecdsa-sig-formatter": "^1.0.11",
6132 5859 "resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.3.tgz",
6133 5860 "integrity": "sha512-eAmLkjDjAFCVXg7A1unxHsLf961m6y17QFqXqAXGj/gVkKFrEICfStRfwUlGNfeCEjNRa32JEWOUTlYXPyyKvA==",
6134 5861 "license": "Apache-2.0",
6135 - "peer": true,
6136 5862 "engines": {
6137 5863 "node": ">=14"
6483 6209 "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
6484 6210 "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
6485 6211 "license": "MIT",
6486 - "peer": true,
6487 6212 "dependencies": {
6488 6213 "agent-base": "^7.1.0",
6489 6214 "debug": "^4.3.4"
6497 6222 "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
6498 6223 "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
6499 6224 "license": "MIT",
6500 - "peer": true,
6501 6225 "dependencies": {
6502 6226 "agent-base": "^7.1.2",
6503 6227 "debug": "4"
6523 6247 "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
6524 6248 "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
6525 6249 "license": "MIT",
6526 - "peer": true,
6527 6250 "engines": {
6528 6251 "node": ">= 4"
6623 6346 "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
6624 6347 "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
6625 6348 "license": "MIT",
6626 - "peer": true,
6627 6349 "dependencies": {
6628 6350 "bignumber.js": "^9.0.0"
6633 6355 "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
6634 6356 "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
6635 6357 "license": "MIT",
6636 - "peer": true,
6637 6358 "dependencies": {
6638 6359 "@babel/runtime": "^7.18.3",
6639 6360 "ts-algebra": "^2.0.0"
6660 6381 "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
6661 6382 "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
6662 6383 "license": "MIT",
6663 - "peer": true,
6664 6384 "dependencies": {
6665 6385 "buffer-equal-constant-time": "^1.0.1",
6666 6386 "ecdsa-sig-formatter": "1.0.11",
6672 6392 "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
6673 6393 "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
6674 6394 "license": "MIT",
6675 - "peer": true,
6676 6395 "dependencies": {
6677 6396 "jwa": "^2.0.1",
6678 6397 "safe-buffer": "^5.0.1"
6997 6716 "version": "5.3.2",
6998 6717 "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
6999 6718 "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
7000 - "license": "Apache-2.0",
7001 - "peer": true
6719 + "license": "Apache-2.0"
7003 6721 "node_modules/longest-streak": {
7004 6722 "version": "3.1.0",
7107 6825 "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.5.tgz",
7108 6826 "integrity": "sha512-S6GcvALHg6K4ohtu4E7x0a1AqhAjp6cV8KhLSyN9qVapnzJkusVBxZRcIU9AeYsbe6P1hKDusSbEOzGyyuce6w==",
7109 6827 "license": "MIT",
7110 - "peer": true,
7111 6828 "bin": {
7112 6829 "marked": "bin/marked.js"
8104 7821 "license": "MIT",
8105 - "peer": true,
8106 7822 "engines": {
8107 7823 "node": ">=10.5.0"
8112 7828 "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
8113 7829 "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
8114 7830 "license": "MIT",
8115 - "peer": true,
8116 7831 "dependencies": {
8117 7832 "data-uri-to-buffer": "^4.0.0",
8118 7833 "fetch-blob": "^3.1.4",
8170 7885 "node_modules/openai": {
8171 - "version": "6.26.0",
8172 - "resolved": "https://registry.npmjs.org/openai/-/openai-6.26.0.tgz",
8173 - "integrity": "sha512-zd23dbWTjiJ6sSAX6s0HrCZi41JwTA1bQVs0wLQPZ2/5o2gxOJA5wh7yOAUgwYybfhDXyhwlpeQf7Mlgx8EOCA==",
7886 + "version": "6.40.0",
7887 + "resolved": "https://registry.npmjs.org/openai/-/openai-6.40.0.tgz",
7888 + "integrity": "sha512-MWtTjd/gQt4jpbji61NTgFWJLoY/PdRJ6wG9/ZDRMYNMlBKrCrSlkLI+KgHP1vR1qT6LKSAyAqIxno6lcK9JiA==",
8174 7889 "license": "Apache-2.0",
8175 - "peer": true,
8176 - "bin": {
8177 - "openai": "bin/cli"
8178 - },
8179 7890 "peerDependencies": {
8180 7891 "ws": "^8.18.0",
8181 7892 "zod": "^3.25 || ^4.0"
8194 7905 "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz",
8195 7906 "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==",
8196 7907 "license": "MIT",
8197 - "peer": true,
8198 7908 "dependencies": {
8199 7909 "@types/retry": "0.12.0",
8200 7910 "retry": "^0.13.1"
8225 7935 "version": "0.1.7",
8226 7936 "resolved": "https://registry.npmjs.org/partial-json/-/partial-json-0.1.7.tgz",
8227 7937 "integrity": "sha512-Njv/59hHaokb/hRUjce3Hdv12wd60MtM9Z5Olmn+nehe0QDAsRtRbJPvJ0Z91TusF0SuZRIvnM+S4l6EIP8leA==",
8228 - "license": "MIT",
8229 - "peer": true
7938 + "license": "MIT"
8231 7940 "node_modules/path-data-parser": {
8232 7941 "version": "0.1.0",
8373 8082 "integrity": "sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw==",
8374 8083 "hasInstallScript": true,
8375 8084 "license": "BSD-3-Clause",
8376 - "peer": true,
8377 8085 "dependencies": {
8378 8086 "@protobufjs/aspromise": "^1.1.2",
8379 8087 "@protobufjs/base64": "^1.1.2",
8700 8408 "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
8701 8409 "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
8702 8410 "license": "MIT",
8703 - "peer": true,
8704 8411 "engines": {
8705 8412 "node": ">= 4"
8780 8487 "url": "https://feross.org/support"
8783 - "license": "MIT",
8784 - "peer": true
8490 + "license": "MIT"
8786 8492 "node_modules/safer-buffer": {
8787 8493 "version": "2.1.2",
8999 8705 "version": "2.0.0",
9000 8706 "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
9001 8707 "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
9002 - "license": "MIT",
9003 - "peer": true
8708 + "license": "MIT"
9005 8710 "node_modules/ts-dedent": {
9006 8711 "version": "2.3.0",
9015 8720 "version": "2.8.1",
9016 8721 "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
9017 8722 "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
9018 - "license": "0BSD",
9019 - "peer": true
8723 + "license": "0BSD"
9021 8725 "node_modules/typebox": {
9022 8726 "version": "1.3.12",
9043 8747 "version": "8.3.0",
9044 8748 "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
9045 8749 "integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==",
9046 - "license": "MIT",
9047 - "peer": true
8750 + "license": "MIT"
9049 8752 "node_modules/unified": {
9050 8753 "version": "11.0.5",
9458 9161 "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
9459 9162 "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
9460 9163 "license": "MIT",
9461 - "peer": true,
9462 9164 "engines": {
9463 9165 "node": ">= 8"
9491 9193 "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
9492 9194 "integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
9493 9195 "license": "MIT",
9494 - "peer": true,
9495 9196 "engines": {
9496 9197 "node": ">=10.0.0"
9530 9231 "url": "https://github.com/sponsors/eemeli"
9533 - "node_modules/zod": {
9534 - "version": "4.4.3",
9535 - "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
9536 - "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
9537 - "license": "MIT",
9538 - "peer": true,
9539 - "funding": {
9540 - "url": "https://github.com/sponsors/colinhacks"
9542 - },
9543 - "node_modules/zod-to-json-schema": {
9544 - "version": "3.25.2",
9545 - "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
9546 - "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
9547 - "license": "ISC",
9548 - "peer": true,
9549 - "peerDependencies": {
9550 - "zod": "^3.25.28 || ^4"
9552 - },
9553 9234 "node_modules/zwitch": {
9554 9235 "version": "2.0.4",
9555 9236 "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",

package.json

Modified
14 14 "typecheck": "tsc --noEmit"
16 16 "devDependencies": {
17 + "@earendil-works/pi-agent-core": "0.84.2",
18 + "@earendil-works/pi-ai": "0.84.2",
19 + "@earendil-works/pi-client": "0.84.2",
20 + "@earendil-works/pi-coding-agent": "0.84.2",
21 + "@earendil-works/pi-protocol": "0.84.2",
22 + "@earendil-works/pi-telemetry": "0.84.2",
23 + "@earendil-works/pi-tui": "0.84.2",
17 24 "@fast-check/vitest": "^0.4.1",
18 25 "@playwright/test": "^1.61.0",
19 26 "@vitest/coverage-istanbul": "^4.1.9",