@yagni-app/code 0.2.1 → 0.3.1

package/dist/extension/ultra.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Ultra mode (/ultra) — an explicit, session-scoped dial for aggressive
+ * multi-agent orchestration ("the diamond": fan out → reduce → synthesize).
+ *
+ * Off by default so the trial-default behavior is unchanged; toggling on swaps
+ * the driver's delegation paragraph for the diamond directive (branding.ts's
+ * YAGNI_IDENTITY_ULTRA) and widens the subagent tool's per-call fan-out
+ * ceiling (subagents.ts). The two halves take effect at different moments:
+ * the fan-out ceiling is probed live on every subagent call, but the identity
+ * is read in index.ts's before_agent_start handler, which pi fires only when
+ * a NEW user prompt is submitted — a toggle mid-run leaves the running task on
+ * its existing instructions until the next message (the handler notifies when
+ * that is the case). Ultra is a prompt + ceiling change only: it never touches
+ * the permission mode, the model tier, or the /go pipeline.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export interface UltraHolder {
+    get(): boolean;
+    set(on: boolean): void;
+}
+export declare function createUltraHolder(initial?: boolean): UltraHolder;
+/**
+ * Wire the /ultra command onto a shared holder. No argument toggles; `on` /
+ * `off` set explicitly; `status` reports without changing anything.
+ */
+export declare function registerUltraCommand(pi: ExtensionAPI, holder: UltraHolder): void;
+//# sourceMappingURL=ultra.d.ts.map

package/dist/extension/ultra.js

@@ -0,0 +1,76 @@
+/**
+ * Ultra mode (/ultra) — an explicit, session-scoped dial for aggressive
+ * multi-agent orchestration ("the diamond": fan out → reduce → synthesize).
+ *
+ * Off by default so the trial-default behavior is unchanged; toggling on swaps
+ * the driver's delegation paragraph for the diamond directive (branding.ts's
+ * YAGNI_IDENTITY_ULTRA) and widens the subagent tool's per-call fan-out
+ * ceiling (subagents.ts). The two halves take effect at different moments:
+ * the fan-out ceiling is probed live on every subagent call, but the identity
+ * is read in index.ts's before_agent_start handler, which pi fires only when
+ * a NEW user prompt is submitted — a toggle mid-run leaves the running task on
+ * its existing instructions until the next message (the handler notifies when
+ * that is the case). Ultra is a prompt + ceiling change only: it never touches
+ * the permission mode, the model tier, or the /go pipeline.
+ */
+export function createUltraHolder(initial = false) {
+    let on = initial;
+    return {
+        get: () => on,
+        set: (v) => {
+            on = v;
+        },
+    };
+}
+/** Status chip shown while ultra is on (same footer surface as the /mode chip). */
+const ULTRA_STATUS = "◆ ultra";
+const ULTRA_ON_COPY = "Ultra mode ON: meaningful work fans out to parallel subagents, adversarial " +
+    "verification agents try to break the result, then the agent synthesizes. " +
+    "Expect more subagent spend per task.";
+const ULTRA_OFF_COPY = "Ultra mode OFF: back to delegate-when-useful.";
+/**
+ * Appended when the toggle lands mid-run: the identity swap only applies when
+ * the next prompt is submitted (see the module docblock), so without this note
+ * the chip flips while the running task visibly keeps its old behavior — which
+ * reads as ultra mode being broken.
+ */
+const MID_RUN_NOTE = " The task currently running keeps its existing instructions; the change takes full effect on your next message.";
+/**
+ * Wire the /ultra command onto a shared holder. No argument toggles; `on` /
+ * `off` set explicitly; `status` reports without changing anything.
+ */
+export function registerUltraCommand(pi, holder) {
+    pi.registerCommand("ultra", {
+        description: "Toggle ultra mode: aggressive fan-out/verify/synthesize orchestration. /ultra on | off | status.",
+        handler: async (args, ctx) => {
+            const notify = (m, t) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(m, t);
+            };
+            const arg = args.trim().toLowerCase();
+            if (arg && arg !== "on" && arg !== "off" && arg !== "status") {
+                notify(`Unknown argument "${arg}". Use /ultra, /ultra on, /ultra off, or /ultra status.`, "warning");
+                return;
+            }
+            if (arg === "status") {
+                notify(holder.get() ? ULTRA_ON_COPY : ULTRA_OFF_COPY, "info");
+                return;
+            }
+            const next = arg === "on" ? true : arg === "off" ? false : !holder.get();
+            holder.set(next);
+            try {
+                if (ctx.hasUI)
+                    ctx.ui.setStatus?.("yagni-ultra", next ? ULTRA_STATUS : undefined);
+            }
+            catch {
+                // The chip is chrome; never let it break /ultra.
+            }
+            // Guarded probe: test fakes (and any minimal harness ctx) may not carry
+            // isIdle, and its absence must read as idle, never as busy.
+            const midRun = typeof ctx.isIdle === "function" && !ctx.isIdle();
+            const copy = next ? ULTRA_ON_COPY : ULTRA_OFF_COPY;
+            notify(midRun ? copy + MID_RUN_NOTE : copy, "info");
+        },
+    });
+}
+//# sourceMappingURL=ultra.js.map

package/dist/launch.d.ts

@@ -71,6 +71,13 @@ export interface BuildLaunchOptions {
     cliVersion?: string;
     /** Base environment to extend (defaults to process.env at call sites). */
     baseEnv?: NodeJS.ProcessEnv;
+    /**
+     * Whether this launch freshly collapsed reasoning (seeded `hideThinkingBlock`
+     * for the first time). Forwarded as `YAGNI_HIDE_THINKING_SEEDED=1` so the
+     * extension can surface a single one-time "reasoning is collapsed" hint.
+     * Omitted/false on repeat launches: the hint must not re-nag.
+     */
+    hideThinkingSeeded?: boolean;
     /** Clock seam for the token-expiry preflight (defaults to Date.now). */
     now?: () => number;
     /**

package/dist/launch.js

@@ -7,6 +7,8 @@
  */
 import { randomUUID } from "node:crypto";
 import { agentDirEnvVar } from "./branding.js";
+import { PAD_X_ENV, resolvePadX } from "./padding.js";
+import { ENGINEERING_PRACTICE_SECTION, promptEnrichmentDisabled } from "./promptEnrichment.js";
 /**
  * How close to expiry the token can be before launch warns. A coding session
  * easily outlives a token, so warn early enough that re-logging in before a long
@@ -95,27 +97,37 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // Match the e2b harness defaults: skip pi's update check + telemetry.
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        // One-time marker for the "reasoning is collapsed" hint: only set on the
+        // launch that actually seeded the collapse default. Absent on every later
+        // launch so the hint never re-nags. (See hideThinkingSeeded in the docs.)
+        ...(opts.hideThinkingSeeded ? { YAGNI_HIDE_THINKING_SEEDED: "1" } : {}),
+        // Forward the chosen horizontal pad so the extension's footer aligns with
+        // the editor (which the launcher pads by seeding editorPaddingX). The
+        // footer can't read pi's settings, so the value crosses over env.
+        [PAD_X_ENV]: String(resolvePadX()),
     };
     // Always load our extension. Default the provider to `yagni` unless the user
     // explicitly chose one (so power users can still point pi elsewhere).
     const userChoseProvider = passthroughArgs.some(arg => arg === "--provider" || arg.startsWith("--provider="));
-    // Default the model to the `balanced` tier (YAG-380). Balanced drives on the
-    // judgment-grade `advanced` model and additionally lets the session escalate
-    // hard calls to `peak` through the capped ask_advisor tool. So it is strictly
-    // additive: no session reasons worse than plain advanced, and the hard ones
-    // can reason better. A user `--model` (e.g. `standard` or `efficient`) still
-    // wins. Without this, pi's default-model heuristic could land an interactive
-    // session on a weaker tier.
-    // Detect if the user explicitly set a model, whether via "--model" as a separate
-    // argument or using the equals form "--model=efficient". The previous check only
-    // caught the separate form, causing a duplicate "--model balanced" to be added
-    // when the equals form was used.
+    // Default the model to the `advanced` tier. The model is locked: the
+    // catalog is filtered to only `advanced` (see index.ts), so the user
+    // cannot switch to a different tier via /model or Ctrl+P. The proxy still
+    // resolves the tier to the concrete backing model.
     const userChoseModel = passthroughArgs.some(arg => arg === "--model" || arg.startsWith("--model="));
+    // Engineering-practice enrichment (YAG-496): appended to the DRIVER's system
+    // prompt only — /go stage children and subagents build their own pi argv, so
+    // this flag never reaches them. pi treats the value as literal text (it is
+    // never an existing file path) and slots it before <project_context>, so the
+    // user's repo instructions still outrank it. The flag is repeatable, so a
+    // user-passed --append-system-prompt coexists rather than conflicting; the
+    // opt-out is YAGNI_DISABLE_PROMPT_ENRICHMENT.
+    const enrichmentOff = promptEnrichmentDisabled(opts.baseEnv ?? process.env);
     const argv = [
         "-e",
         opts.extensionPath,
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
-        ...(userChoseModel ? [] : ["--model", "balanced"]),
+        ...(userChoseModel ? [] : ["--model", "advanced"]),
+        ...(enrichmentOff ? [] : ["--append-system-prompt", ENGINEERING_PRACTICE_SECTION]),
         ...(opts.extraAgentArgs ?? []),
         ...passthroughArgs,
     ];

package/dist/login.d.ts

@@ -34,8 +34,10 @@ type OpenRunner = (cmd: string, args: string[]) => Promise<void>;
  *
  *   macOS:   open <url>
  *   Linux:   xdg-open <url>
- *   Windows: cmd /c start "" <url>   (the empty "" is start's window-title slot;
- *            without it `start` swallows the URL as the title and opens nothing)
+ *   Windows: rundll32 url.dll,FileProtocolHandler <url>   (opens the default
+ *            browser without going through cmd.exe — `cmd /c start <url>`
+ *            re-parses its arguments as a shell line, so a hostile URL with
+ *            `&`/`^` metacharacters could execute commands)
  */
 export declare function resolveOpenCommand(url: string, platform?: NodeJS.Platform): {
     cmd: string;

package/dist/login.js

@@ -31,14 +31,17 @@ function isTimeoutError(err) {
  *
  *   macOS:   open <url>
  *   Linux:   xdg-open <url>
- *   Windows: cmd /c start "" <url>   (the empty "" is start's window-title slot;
- *            without it `start` swallows the URL as the title and opens nothing)
+ *   Windows: rundll32 url.dll,FileProtocolHandler <url>   (opens the default
+ *            browser without going through cmd.exe — `cmd /c start <url>`
+ *            re-parses its arguments as a shell line, so a hostile URL with
+ *            `&`/`^` metacharacters could execute commands)
  */
 export function resolveOpenCommand(url, platform = process.platform) {
     if (platform === "darwin")
         return { cmd: "open", args: [url] };
-    if (platform === "win32")
-        return { cmd: "cmd", args: ["/c", "start", "", url] };
+    if (platform === "win32") {
+        return { cmd: "rundll32", args: ["url.dll,FileProtocolHandler", url] };
+    }
     return { cmd: "xdg-open", args: [url] };
 }
 const spawnRunner = (cmd, args) => new Promise((resolve, reject) => {
@@ -50,6 +53,18 @@ const spawnRunner = (cmd, args) => new Promise((resolve, reject) => {
  * URL is still printed for manual copy. `runner` is injectable for tests.
  */
 export const realOpenUrl = (url, runner = spawnRunner) => {
+    // Only ever hand http(s) URLs to the OS opener — refuse file:, javascript:,
+    // or custom schemes a compromised server response could try to smuggle in.
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return Promise.resolve();
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return Promise.resolve();
+    }
     const { cmd, args } = resolveOpenCommand(url);
     return runner(cmd, args).catch(() => {
         // Silently fail — the user can still copy the URL manually.

package/dist/padding.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Single source of truth for the CLI's horizontal padding, shared by the
+ * launcher (which seeds the editor setting) and — via the `YAGNI_PAD_X` env the
+ * launcher forwards — pi-extension-yagni's footer.
+ *
+ * The value must match pi's `outputPad` (the chat/output area's left+right
+ * padding, which defaults to 1) so the input editor, the output stream, and
+ * the status bar all align on the same column. Keeping it in one module makes
+ * the coherence structural rather than eyeballed: change this one number and
+ * the editor, footer, and seeded default move together.
+ *
+ * Separators (the ─ rules above/below the input) intentionally stay full-bleed
+ * and are NOT padded — matching Claude Code's frame.
+ */
+export declare const PAD_X = 1;
+/** Left (and right) padding string applied to the editor and footer. */
+export declare const PAD_STR: string;
+/** Env var the launcher sets so the extension's footer can match the editor pad. */
+export declare const PAD_X_ENV = "YAGNI_PAD_X";
+/** Parse a pad width from the env override, falling back to {@link PAD_X}. */
+export declare function resolvePadX(raw?: string | undefined): number;
+//# sourceMappingURL=padding.d.ts.map

package/dist/padding.js

@@ -0,0 +1,25 @@
+/**
+ * Single source of truth for the CLI's horizontal padding, shared by the
+ * launcher (which seeds the editor setting) and — via the `YAGNI_PAD_X` env the
+ * launcher forwards — pi-extension-yagni's footer.
+ *
+ * The value must match pi's `outputPad` (the chat/output area's left+right
+ * padding, which defaults to 1) so the input editor, the output stream, and
+ * the status bar all align on the same column. Keeping it in one module makes
+ * the coherence structural rather than eyeballed: change this one number and
+ * the editor, footer, and seeded default move together.
+ *
+ * Separators (the ─ rules above/below the input) intentionally stay full-bleed
+ * and are NOT padded — matching Claude Code's frame.
+ */
+export const PAD_X = 1;
+/** Left (and right) padding string applied to the editor and footer. */
+export const PAD_STR = " ".repeat(PAD_X);
+/** Env var the launcher sets so the extension's footer can match the editor pad. */
+export const PAD_X_ENV = "YAGNI_PAD_X";
+/** Parse a pad width from the env override, falling back to {@link PAD_X}. */
+export function resolvePadX(raw = process.env[PAD_X_ENV]) {
+    const n = raw === undefined ? NaN : Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n >= 0 && n <= 3 ? n : PAD_X;
+}
+//# sourceMappingURL=padding.js.map

package/dist/promptEnrichment.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Engineering-practice prompt enrichment (YAG-496).
+ *
+ * pi's own base system prompt is deliberately thin (~15 lines: identity, tool
+ * one-liners, two generic guidelines). The extension adds identity, grounding,
+ * and product-tool guidance — but nothing about general engineering behavior:
+ * conventions, verification, commit discipline, communication style. This
+ * section carries that missing middle, curated from the prompt lineage shared
+ * by OpenCode/Claude Code/Kimi CLI and adapted to YAGNI Code's tools and
+ * autonomy posture.
+ *
+ * Delivery mechanism: pi's `--append-system-prompt <text>` flag, injected by
+ * the launcher (launch.ts). pi places appended text after its Guidelines and
+ * BEFORE the user's <project_context>, so repo instructions still outrank it.
+ * Because `/go` stage children and subagents build their own pi argv
+ * (pi-extension-yagni's pipeline/invocation.ts and pipeline/runner.ts), a
+ * launcher flag is structurally driver-only: child prompts are untouched by
+ * construction, not by an `if`. The piContract test pins both properties.
+ *
+ * Content constraints (enforced by test/promptEnrichment.test.ts):
+ * - must not contain the standalone word "pi" — the extension's brand scrub
+ *   rewrites it to "YAGNI Code" and would mangle the sentence;
+ * - must not OPEN with a "- " bullet line — pi's self-referential docs block
+ *   (which the extension strips with a regex that consumes consecutive
+ *   bullets) sits directly above this section in the assembled prompt;
+ * - no emojis (the section itself forbids them).
+ */
+/** Env switch that skips the enrichment entirely (sibling of
+ * YAGNI_DISABLE_BRANDING / YAGNI_DISABLE_CLAUDE_COMPAT, same semantics). */
+export declare const ENRICHMENT_DISABLE_ENV = "YAGNI_DISABLE_PROMPT_ENRICHMENT";
+/** `"1"`/anything truthy disables; unset, empty, and `"0"` keep it on. */
+export declare function promptEnrichmentDisabled(env: NodeJS.ProcessEnv): boolean;
+/**
+ * The section appended to the driver session's system prompt. Keep it curated,
+ * not encyclopedic: every line here spends attention budget on an open-weight
+ * model, and the load-bearing instructions (ask_yagni contract, delegation)
+ * live elsewhere in the prompt.
+ */
+export declare const ENGINEERING_PRACTICE_SECTION = "Engineering practice:\n\nBias to action: when the user asks you to implement, fix, or change something, use your tools to make the actual edits and run the actual commands \u2014 do not answer with a description of what you would do, or with code for the user to apply themselves. When the user asks HOW to approach something, answer the question first; do not jump into making changes they have not asked for.\n\nConventions:\n- Never assume a library is available, however well known. Before using one, confirm the project already depends on it (its package manifest, or imports in neighboring files).\n- When editing, read the surrounding code and its imports first; match the file's existing style, naming, and patterns rather than introducing your own.\n- When creating a new file or component, study an existing sibling first and follow its structure.\n- Never write code that logs or exposes secrets, keys, or credentials.\n\nVerification:\n- Consider what the code you are changing is supposed to do (from its name, location, and callers) before you change it.\n- Verify changes with the project's own tests when possible. Never assume a test framework or command \u2014 check the README, package scripts, or neighboring tests for the real one.\n- After completing a task, run the project's lint and typecheck commands if you know them; if you cannot find them, ask the user and suggest recording them in AGENTS.md for next time.\n\nVersion control:\n- No unsolicited commits: commit only when the user asked for one or the task at hand clearly calls for it.\n\nGit safety:\n- You may be in a dirty git worktree. Never revert existing changes you did not make unless explicitly asked \u2014 these were made by the user.\n- If there are unrelated changes in files you are touching, read and work with them rather than reverting.\n- If changes appear in unrelated files, ignore them and do not revert.\n- Do not amend a commit unless explicitly asked.\n- If you notice unexpected changes you did not make while working, stop immediately and ask the user.\n- Never use destructive git commands (git reset --hard, git checkout --) unless the user explicitly requests or approves them.\n\nTodo discipline:\n- Track multi-step work with todo_write: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.\n- Do not batch-complete items or create single-step plans. Skip planning for trivially small work (~25% of tasks).\n\nMode awareness:\n- In auto mode, proactively run tests, lint, and typecheck after your changes.\n- In review mode, propose verification steps but wait for approval before running them.\n- In plan mode, explore and design only \u2014 the gate holds all writes.\n\nCommunication:\n- Answer directly, without preamble or postamble (\"Here is what I will do next...\", \"Based on the information provided...\"). Match the length of your answer to the question.\n- After making edits, report the outcome briefly; do not restate the diff or explain the code you just wrote unless asked.\n- Do not add code comments that narrate what you changed or why the change is correct; comments are for future readers of the code.\n- Reference code as file_path:line_number so the user can jump to it.\n- Before running a non-trivial command that changes state, say in one line what it does and why.\n- Never guess or fabricate URLs. Only use URLs the user provided or that appear in local files.\n- No emojis unless the user asks for them.";
+//# sourceMappingURL=promptEnrichment.d.ts.map

package/dist/promptEnrichment.js

@@ -0,0 +1,85 @@
+/**
+ * Engineering-practice prompt enrichment (YAG-496).
+ *
+ * pi's own base system prompt is deliberately thin (~15 lines: identity, tool
+ * one-liners, two generic guidelines). The extension adds identity, grounding,
+ * and product-tool guidance — but nothing about general engineering behavior:
+ * conventions, verification, commit discipline, communication style. This
+ * section carries that missing middle, curated from the prompt lineage shared
+ * by OpenCode/Claude Code/Kimi CLI and adapted to YAGNI Code's tools and
+ * autonomy posture.
+ *
+ * Delivery mechanism: pi's `--append-system-prompt <text>` flag, injected by
+ * the launcher (launch.ts). pi places appended text after its Guidelines and
+ * BEFORE the user's <project_context>, so repo instructions still outrank it.
+ * Because `/go` stage children and subagents build their own pi argv
+ * (pi-extension-yagni's pipeline/invocation.ts and pipeline/runner.ts), a
+ * launcher flag is structurally driver-only: child prompts are untouched by
+ * construction, not by an `if`. The piContract test pins both properties.
+ *
+ * Content constraints (enforced by test/promptEnrichment.test.ts):
+ * - must not contain the standalone word "pi" — the extension's brand scrub
+ *   rewrites it to "YAGNI Code" and would mangle the sentence;
+ * - must not OPEN with a "- " bullet line — pi's self-referential docs block
+ *   (which the extension strips with a regex that consumes consecutive
+ *   bullets) sits directly above this section in the assembled prompt;
+ * - no emojis (the section itself forbids them).
+ */
+/** Env switch that skips the enrichment entirely (sibling of
+ * YAGNI_DISABLE_BRANDING / YAGNI_DISABLE_CLAUDE_COMPAT, same semantics). */
+export const ENRICHMENT_DISABLE_ENV = "YAGNI_DISABLE_PROMPT_ENRICHMENT";
+/** `"1"`/anything truthy disables; unset, empty, and `"0"` keep it on. */
+export function promptEnrichmentDisabled(env) {
+    const value = env[ENRICHMENT_DISABLE_ENV];
+    return value !== undefined && value !== "" && value !== "0";
+}
+/**
+ * The section appended to the driver session's system prompt. Keep it curated,
+ * not encyclopedic: every line here spends attention budget on an open-weight
+ * model, and the load-bearing instructions (ask_yagni contract, delegation)
+ * live elsewhere in the prompt.
+ */
+export const ENGINEERING_PRACTICE_SECTION = `Engineering practice:
+
+Bias to action: when the user asks you to implement, fix, or change something, use your tools to make the actual edits and run the actual commands — do not answer with a description of what you would do, or with code for the user to apply themselves. When the user asks HOW to approach something, answer the question first; do not jump into making changes they have not asked for.
+
+Conventions:
+- Never assume a library is available, however well known. Before using one, confirm the project already depends on it (its package manifest, or imports in neighboring files).
+- When editing, read the surrounding code and its imports first; match the file's existing style, naming, and patterns rather than introducing your own.
+- When creating a new file or component, study an existing sibling first and follow its structure.
+- Never write code that logs or exposes secrets, keys, or credentials.
+
+Verification:
+- Consider what the code you are changing is supposed to do (from its name, location, and callers) before you change it.
+- Verify changes with the project's own tests when possible. Never assume a test framework or command — check the README, package scripts, or neighboring tests for the real one.
+- After completing a task, run the project's lint and typecheck commands if you know them; if you cannot find them, ask the user and suggest recording them in AGENTS.md for next time.
+
+Version control:
+- No unsolicited commits: commit only when the user asked for one or the task at hand clearly calls for it.
+
+Git safety:
+- You may be in a dirty git worktree. Never revert existing changes you did not make unless explicitly asked — these were made by the user.
+- If there are unrelated changes in files you are touching, read and work with them rather than reverting.
+- If changes appear in unrelated files, ignore them and do not revert.
+- Do not amend a commit unless explicitly asked.
+- If you notice unexpected changes you did not make while working, stop immediately and ask the user.
+- Never use destructive git commands (git reset --hard, git checkout --) unless the user explicitly requests or approves them.
+
+Todo discipline:
+- Track multi-step work with todo_write: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.
+- Do not batch-complete items or create single-step plans. Skip planning for trivially small work (~25% of tasks).
+
+Mode awareness:
+- In auto mode, proactively run tests, lint, and typecheck after your changes.
+- In review mode, propose verification steps but wait for approval before running them.
+- In plan mode, explore and design only — the gate holds all writes.
+
+Communication:
+- Answer directly, without preamble or postamble ("Here is what I will do next...", "Based on the information provided..."). Match the length of your answer to the question.
+- After making edits, report the outcome briefly; do not restate the diff or explain the code you just wrote unless asked.
+- Do not add code comments that narrate what you changed or why the change is correct; comments are for future readers of the code.
+- Reference code as file_path:line_number so the user can jump to it.
+- Before running a non-trivial command that changes state, say in one line what it does and why.
+- Never guess or fabricate URLs. Only use URLs the user provided or that appear in local files.
+- No emojis unless the user asks for them.`;
+//# sourceMappingURL=promptEnrichment.js.map

package/dist/signalForward.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Termination-signal forwarding: launcher → pi child.
+ *
+ * In the interactive TUI the tty is in raw mode, so Ctrl+C never raises
+ * SIGINT; this path covers `yagni -p`/piped/CI runs and an external
+ * `kill <launcher pid>`. Policy:
+ *
+ *  - The FIRST signal asks pi to shut down cleanly. SIGINT is translated to
+ *    SIGTERM because pi installs a graceful handler for SIGTERM (it kills its
+ *    tracked children) but none for SIGINT — a raw SIGINT would drop pi on the
+ *    default disposition with no cleanup.
+ *  - Any SECOND signal hard-kills pi's whole process TREE. A bare SIGKILL to
+ *    pi's pid would bypass its exit sweep (SIGKILL runs no handlers) and leave
+ *    /go workers alive, so the launcher enumerates and kills the descendants
+ *    itself: `ps` walk on POSIX, `taskkill /T /F` on Windows.
+ */
+/** The minimal child surface the forwarder needs (ChildProcess satisfies it). */
+export interface KillableChild {
+    pid?: number | undefined;
+    kill(signal: NodeJS.Signals): boolean;
+}
+/** The launcher-terminating signals that are forwarded rather than obeyed. */
+export declare const FORWARDED_SIGNALS: readonly NodeJS.Signals[];
+/**
+ * PURE policy for the FIRST signal: which signal the child receives when the
+ * launcher gets `received` (SIGINT is translated, the rest pass through).
+ * Escalation is not expressed here — a second signal goes through the tree
+ * kill, not a forwarded signal.
+ */
+export declare function forwardedSignal(received: NodeJS.Signals): NodeJS.Signals;
+/**
+ * PURE: the launcher's own exit code for the child's (code, signal) exit tuple.
+ * A signal-terminated child maps to the conventional 128+n (bash parity:
+ * SIGTERM→143, SIGKILL→137, SIGINT→130), so a cancelled run never reads as
+ * success to scripts or CI.
+ */
+export declare function exitCodeFor(code: number | null, signal: NodeJS.Signals | null): number;
+/**
+ * PURE: given `ps -A -o pid=,ppid=` output lines, collect every descendant of
+ * the given roots (children, grandchildren, ...), breadth-first. Mirrored in
+ * pi-extension-yagni's childRegistry (the packages are intentionally
+ * independent); keep the two in sync.
+ */
+export declare function descendantsOf(roots: number[], psLines: string[]): number[];
+/**
+ * Synchronously SIGKILL a process AND its descendants (POSIX `ps` walk /
+ * Windows `taskkill /T /F`). Throw-proof; fail-soft to a direct kill when no
+ * process snapshot is readable.
+ */
+export declare function killTreeSync(pid: number): void;
+/**
+ * Subscribe the forwarding policy for every signal in {@link FORWARDED_SIGNALS}.
+ * `subscribe` and `killTree` default to the real process surfaces and are
+ * injectable so tests never install real handlers, raise real signals, or kill
+ * real processes. Returns the forward function itself (also for tests).
+ * pid guard: a child whose spawn failed has no pid, and `kill()` would resolve
+ * that to the whole process group.
+ */
+export declare function installSignalForwarding(child: KillableChild, subscribe?: (sig: NodeJS.Signals, handler: () => void) => void, killTree?: (pid: number) => void): (sig: NodeJS.Signals) => void;
+//# sourceMappingURL=signalForward.d.ts.map

package/dist/signalForward.js

@@ -0,0 +1,130 @@
+/**
+ * Termination-signal forwarding: launcher → pi child.
+ *
+ * In the interactive TUI the tty is in raw mode, so Ctrl+C never raises
+ * SIGINT; this path covers `yagni -p`/piped/CI runs and an external
+ * `kill <launcher pid>`. Policy:
+ *
+ *  - The FIRST signal asks pi to shut down cleanly. SIGINT is translated to
+ *    SIGTERM because pi installs a graceful handler for SIGTERM (it kills its
+ *    tracked children) but none for SIGINT — a raw SIGINT would drop pi on the
+ *    default disposition with no cleanup.
+ *  - Any SECOND signal hard-kills pi's whole process TREE. A bare SIGKILL to
+ *    pi's pid would bypass its exit sweep (SIGKILL runs no handlers) and leave
+ *    /go workers alive, so the launcher enumerates and kills the descendants
+ *    itself: `ps` walk on POSIX, `taskkill /T /F` on Windows.
+ */
+import { spawnSync } from "node:child_process";
+import { constants as osConstants } from "node:os";
+/** The launcher-terminating signals that are forwarded rather than obeyed. */
+export const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+/**
+ * PURE policy for the FIRST signal: which signal the child receives when the
+ * launcher gets `received` (SIGINT is translated, the rest pass through).
+ * Escalation is not expressed here — a second signal goes through the tree
+ * kill, not a forwarded signal.
+ */
+export function forwardedSignal(received) {
+    return received === "SIGINT" ? "SIGTERM" : received;
+}
+/**
+ * PURE: the launcher's own exit code for the child's (code, signal) exit tuple.
+ * A signal-terminated child maps to the conventional 128+n (bash parity:
+ * SIGTERM→143, SIGKILL→137, SIGINT→130), so a cancelled run never reads as
+ * success to scripts or CI.
+ */
+export function exitCodeFor(code, signal) {
+    if (code != null)
+        return code;
+    if (signal)
+        return 128 + (osConstants.signals[signal] ?? 15);
+    return 0;
+}
+/**
+ * PURE: given `ps -A -o pid=,ppid=` output lines, collect every descendant of
+ * the given roots (children, grandchildren, ...), breadth-first. Mirrored in
+ * pi-extension-yagni's childRegistry (the packages are intentionally
+ * independent); keep the two in sync.
+ */
+export function descendantsOf(roots, psLines) {
+    const childrenByParent = new Map();
+    for (const line of psLines) {
+        const m = line.trim().match(/^(\d+)\s+(\d+)$/);
+        if (!m)
+            continue;
+        const pid = Number(m[1]);
+        const ppid = Number(m[2]);
+        const list = childrenByParent.get(ppid) ?? [];
+        list.push(pid);
+        childrenByParent.set(ppid, list);
+    }
+    const found = [];
+    const queue = [...roots];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        for (const child of childrenByParent.get(next) ?? []) {
+            found.push(child);
+            queue.push(child);
+        }
+    }
+    return found;
+}
+/**
+ * Synchronously SIGKILL a process AND its descendants (POSIX `ps` walk /
+ * Windows `taskkill /T /F`). Throw-proof; fail-soft to a direct kill when no
+ * process snapshot is readable.
+ */
+export function killTreeSync(pid) {
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+        }
+        catch {
+            /* best effort */
+        }
+        return;
+    }
+    let descendants = [];
+    try {
+        const ps = spawnSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8" });
+        if (ps.status === 0 && typeof ps.stdout === "string") {
+            descendants = descendantsOf([pid], ps.stdout.split("\n"));
+        }
+    }
+    catch {
+        /* no snapshot: fall through to the direct kill */
+    }
+    for (const target of [pid, ...descendants]) {
+        try {
+            process.kill(target, "SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+    }
+}
+/**
+ * Subscribe the forwarding policy for every signal in {@link FORWARDED_SIGNALS}.
+ * `subscribe` and `killTree` default to the real process surfaces and are
+ * injectable so tests never install real handlers, raise real signals, or kill
+ * real processes. Returns the forward function itself (also for tests).
+ * pid guard: a child whose spawn failed has no pid, and `kill()` would resolve
+ * that to the whole process group.
+ */
+export function installSignalForwarding(child, subscribe = (sig, handler) => process.on(sig, handler), killTree = killTreeSync) {
+    let received = 0;
+    const forward = (sig) => {
+        const prior = received;
+        received += 1;
+        if (!child.pid)
+            return;
+        if (prior > 0)
+            killTree(child.pid);
+        else
+            child.kill(forwardedSignal(sig));
+    };
+    for (const sig of FORWARDED_SIGNALS)
+        subscribe(sig, () => forward(sig));
+    return forward;
+}
+//# sourceMappingURL=signalForward.js.map

package/dist/token.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `yagni token` — print the active environment's API token to stdout.
+ *
+ * This is the credential feed for `yagni connect claude-code`: Claude Code's
+ * `apiKeyHelper` runs this command (re-running on 401 and on a TTL), so the
+ * contract is strict — stdout carries the TOKEN AND NOTHING ELSE (Claude Code
+ * v2.1.227+ rejects helpers that print banners), and every notice goes to
+ * stderr. Riding the same refresh-at-launch client as the launcher means a
+ * token that enters the 7-day rotation window is rotated and persisted here
+ * too, so a Claude Code session keeps working without the user ever running
+ * `yagni` itself.
+ */
+import { maybeRefreshAtLaunch } from "./refresh.js";
+import type { Credentials } from "./credentials.js";
+import { type Profile } from "./profiles.js";
+export interface TokenCommandDeps {
+    readProfile?: () => Promise<Profile>;
+    refresh?: typeof maybeRefreshAtLaunch;
+    persist?: (name: string, creds: Credentials) => Promise<void>;
+    now?: () => number;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function tokenCommand(deps?: TokenCommandDeps): Promise<number>;
+//# sourceMappingURL=token.d.ts.map