@yagni-app/code 0.2.1 → 0.3.1

package/dist/extension/pipeline/runner.js

@@ -23,6 +23,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { trackChild } from "./childRegistry.js";
 import { finalOutputFrom, foldEvent, newEventAccumulator } from "./events.js";
 import { buildStageInvocation, groundedChildArgv } from "./invocation.js";
 import { personaBody } from "./personas.js";
@@ -151,6 +152,9 @@ export async function runStage(stage, ctx, deps) {
                 shell: false,
                 stdio: ["ignore", "pipe", "pipe"],
             });
+            // Register with the exit sweep so quitting pi (/exit, double Ctrl+C,
+            // SIGTERM) can never orphan a stage child into the background.
+            trackChild(proc);
             let buffer = "";
             // `overlong` = we are mid-way through a line that already blew the cap; we
             // discard incoming bytes until its terminating newline, then drop the line.

package/dist/extension/pipeline/verify.d.ts

@@ -239,6 +239,10 @@ export declare function buildVerifyEnv(source?: NodeJS.ProcessEnv): NodeJS.Proce
  * once instead of parking in watch mode until the 10-min cap kills it.
  */
 export declare function buildTestEnv(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function makeDefaultExec(opts?: {
+    graceMs?: number;
+    killTree?: (pid: number) => void;
+}): VerifyExec;
 export interface MakeRunVerifyOpts {
     detect?: (cwd: string, changedDirs: string[]) => VerifyCommand[];
     /**

package/dist/extension/pipeline/verify.js

@@ -52,6 +52,7 @@ import { readFileSync } from "node:fs";
 // backslashed strings that no longer compare equal to the git-derived repoRoot
 // and would break the walk-up termination check.
 import { basename, dirname, join } from "node:path/posix";
+import { killTreeSync, trackChild } from "./childRegistry.js";
 import { composeAbortSignal } from "./resilience.js";
 import { scrubSecrets } from "./scrubSecrets.js";
 import { snapshotWorkspace } from "./workspace.js";
@@ -595,33 +596,54 @@ export function buildTestEnv(source = process.env) {
 // — signalling the WHOLE process group and killing the parent. Abort is wired
 // manually with an explicit pid guard; a killed child reaches the callback with
 // a code-less error, which stays the same fail-open rejection as before.
-const defaultExec = (argv, cwd, signal, env) => new Promise((resolve, reject) => {
-    if (signal.aborted)
-        return reject(new Error("verify aborted before start"));
-    const child = execFile(argv[0], argv.slice(1), { cwd, env: env ?? buildVerifyEnv(), maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
-        signal.removeEventListener("abort", onAbort);
-        const output = `${stdout ?? ""}${stderr ?? ""}`;
-        if (err) {
-            // A non-zero EXIT is a verify failure (carries a numeric code); a spawn
-            // error (ENOENT) or an abort has no numeric code and is a fail-open.
-            const code = err.code;
-            if (typeof code === "number")
-                return resolve({ code, output });
-            return reject(err);
-        }
-        resolve({ code: 0, output });
+//
+// Abort escalates: SIGTERM first (a test runner gets its grace to flush), then
+// after `graceMs` a TREE SIGKILL — a stubborn runner (or a descendant it
+// spawned that holds the stdio pipes open) would otherwise leave the promise
+// pending forever, hanging /stop and the run with it.
+export function makeDefaultExec(opts = {}) {
+    const graceMs = opts.graceMs ?? 5000;
+    const killTree = opts.killTree ?? killTreeSync;
+    return (argv, cwd, signal, env) => new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new Error("verify aborted before start"));
+        let settled = false;
+        let killTimer;
+        const child = execFile(argv[0], argv.slice(1), { cwd, env: env ?? buildVerifyEnv(), maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
+            settled = true;
+            if (killTimer)
+                clearTimeout(killTimer);
+            signal.removeEventListener("abort", onAbort);
+            const output = `${stdout ?? ""}${stderr ?? ""}`;
+            if (err) {
+                // A non-zero EXIT is a verify failure (carries a numeric code); a spawn
+                // error (ENOENT) or an abort has no numeric code and is a fail-open.
+                const code = err.code;
+                if (typeof code === "number")
+                    return resolve({ code, output });
+                return reject(err);
+            }
+            resolve({ code: 0, output });
+        });
+        trackChild(child);
+        const onAbort = () => {
+            try {
+                if (child.pid)
+                    child.kill("SIGTERM");
+            }
+            catch {
+                /* ignore */
+            }
+            killTimer = setTimeout(() => {
+                if (!settled && child.pid)
+                    killTree(child.pid);
+            }, graceMs);
+            killTimer.unref?.();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
     });
-    const onAbort = () => {
-        try {
-            if (child.pid)
-                child.kill("SIGTERM");
-        }
-        catch {
-            /* ignore */
-        }
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-});
+}
+const defaultExec = makeDefaultExec();
 /**
  * Build the runVerify function injected into the orchestrator. It discovers the
  * changed package(s) (scoped to this run's diff via `baselinePaths`), detects a

package/dist/extension/recordDecisionTool.d.ts

@@ -1,5 +1,6 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { type FlywheelState } from "./flywheel.js";
 /** Options for {@link makeRecordDecisionTool}. */
 export interface MakeRecordDecisionToolOptions {
     baseUrl: string;
@@ -7,6 +8,13 @@ export interface MakeRecordDecisionToolOptions {
     fetchImpl?: typeof fetch;
     /** Idempotency-key source (default: crypto.randomUUID); injected in tests. */
     makeIdempotencyKey?: () => string;
+    /**
+     * Shared flywheel session state (Run 7). A record_decision that follows a
+     * surfaced no-position suggestion sends `dedupe: true` — a mid-run agent
+     * has no human to adjudicate a near-duplicate. A human `/decide` never
+     * rides this state.
+     */
+    flywheel?: FlywheelState;
 }
 /** The durable fields of a recorded product-intent decision. */
 export interface RecordDecisionParams {

package/dist/extension/recordDecisionTool.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { Type } from "typebox";
+import { consumeFlywheelAttribution } from "./flywheel.js";
 import { sendOrSpool } from "./spool.js";
 /**
  * POST a single decision to the token-scoped grounding endpoint and return its
@@ -67,12 +68,20 @@ export function makeRecordDecisionTool(opts) {
             // never bank the same decision twice. Transport failures and 5xx are
             // spooled durably instead of lost (R4 write half).
             const idempotencyKey = (opts.makeIdempotencyKey ?? randomUUID)();
+            // Run 7 flywheel attribution: a record answering the QUESTION a
+            // surfaced no-position suggestion asked about asks the backend to
+            // dedupe against active decisions first (decisive, not advisory — no
+            // human is present). An unrelated record never inherits the flag.
+            const flywheelAttributed = opts.flywheel
+                ? consumeFlywheelAttribution(opts.flywheel, params.question)
+                : false;
             const outcome = await sendOrSpool(opts, "record_decision", "/api/yagni-code/decisions", {
                 question: params.question,
                 decision: params.decision,
                 rationale: params.rationale,
                 repo: params.repo,
                 workItemId: params.workItemId,
+                ...(flywheelAttributed ? { dedupe: true } : {}),
             }, idempotencyKey, signal);
             if (outcome.kind === "rejected") {
                 throw new Error(outcome.message);
@@ -92,6 +101,21 @@ export function makeRecordDecisionTool(opts) {
                 };
             }
             const data = outcome.json;
+            if (data?.deduped) {
+                // The backend matched an existing active decision and inserted
+                // nothing; surface it so the agent leans on the recorded judgment.
+                const existing = data.existing;
+                const summary = existing?.decision ? ` ${existing.decision}` : "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `An equivalent decision is already recorded; nothing new was banked.${summary}`,
+                        },
+                    ],
+                    details: { id: existing?.id ?? null, spooled: false },
+                };
+            }
             return {
                 content: [{ type: "text", text: "Recorded the decision in YAGNI." }],
                 details: { id: data?.id ?? null, spooled: false },

package/dist/extension/redact.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Heuristic secret redaction for Guardian storage events (YAG-510).
+ *
+ * Applied client-side, BEFORE anything leaves the machine, to both the
+ * command and the Guardian rationale (which routinely quotes the command) —
+ * and only on the raw storage tier; the base tier never transmits either.
+ *
+ * Honest scope: this catches the obvious, well-known secret shapes. A secret
+ * in a novel shape gets through — which is why raw-tier storage is an
+ * explicit-consent, per-workspace opt-in and never a default.
+ *
+ * Pure, no external deps (bundling constraint — see execPolicy.ts header).
+ */
+/**
+ * Redact known secret shapes from a command or rationale string. Structure
+ * is preserved (only matched values become [REDACTED]) so the redacted text
+ * stays analyzable.
+ */
+export declare function redactCommand(text: string): string;
+//# sourceMappingURL=redact.d.ts.map

package/dist/extension/redact.js

@@ -0,0 +1,64 @@
+/**
+ * Heuristic secret redaction for Guardian storage events (YAG-510).
+ *
+ * Applied client-side, BEFORE anything leaves the machine, to both the
+ * command and the Guardian rationale (which routinely quotes the command) —
+ * and only on the raw storage tier; the base tier never transmits either.
+ *
+ * Honest scope: this catches the obvious, well-known secret shapes. A secret
+ * in a novel shape gets through — which is why raw-tier storage is an
+ * explicit-consent, per-workspace opt-in and never a default.
+ *
+ * Pure, no external deps (bundling constraint — see execPolicy.ts header).
+ */
+const REDACTED = "[REDACTED]";
+/** Exactly 40 hex chars = a git SHA; keep those readable for analysis. */
+function isGitSha(token) {
+    return /^[0-9a-f]{40}$/i.test(token);
+}
+const RULES = [
+    // Known token shapes (provider-prefixed credentials).
+    { re: /\bAKIA[0-9A-Z]{16}\b/g },
+    { re: /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g },
+    { re: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g },
+    { re: /\bsk-[A-Za-z0-9_-]{16,}\b/g },
+    { re: /\bxox[bpsaro]-[A-Za-z0-9-]{10,}\b/g },
+    { re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{4,}(?:\.[A-Za-z0-9_-]+)?\b/g }, // JWT
+    { re: /\bglsa_[A-Za-z0-9_]{20,}\b/g },
+    { re: /\b(?:fly|glpat|npm)_[A-Za-z0-9_-]{16,}\b/g },
+    // Authorization headers: keep the scheme, redact the credential.
+    { re: /\b(Authorization:\s*(?:Bearer|Basic|Token)\s+)[^\s"']+/gi, keepGroup1: true },
+    // key=value / --key value / --key=value with a secret-shaped key.
+    {
+        re: /((?:--?[A-Za-z0-9_-]*)?(?:password|passwd|secret|token|api[_-]?key|auth)[A-Za-z0-9_-]*\s*[=\s]\s*)[^\s"']+/gi,
+        keepGroup1: true,
+    },
+    // user:pass@ in URLs — redact the password only.
+    { re: /(\/\/[^\s/:@"']+:)[^\s@"']+(?=@)/g, keepGroup1: true },
+];
+/** High-entropy runs: 32+ base64/hex chars — except exact git SHAs. */
+const LONG_RUN_RE = /[A-Za-z0-9+/=_-]{32,}/g;
+/**
+ * Redact known secret shapes from a command or rationale string. Structure
+ * is preserved (only matched values become [REDACTED]) so the redacted text
+ * stays analyzable.
+ */
+export function redactCommand(text) {
+    let out = text;
+    for (const rule of RULES) {
+        out = out.replace(rule.re, (match, g1) => rule.keepGroup1 && typeof g1 === "string" ? `${g1}${REDACTED}` : REDACTED);
+    }
+    out = out.replace(LONG_RUN_RE, (match) => {
+        if (isGitSha(match))
+            return match;
+        if (match === REDACTED.slice(1, -1))
+            return match;
+        // Plain long words (paths, flags already handled above) that are all
+        // lowercase letters are more likely English than entropy; keep them.
+        if (/^[a-z]+$/.test(match) || /^[A-Z]+$/.test(match))
+            return match;
+        return REDACTED;
+    });
+    return out;
+}
+//# sourceMappingURL=redact.js.map

package/dist/extension/rerouteNotice.d.ts

@@ -4,7 +4,7 @@
  * The backend sets `x-yagni-model-reroute: <requested>-><effective>:vision` on
  * every response it silently upgrades for image content (yagniCodeV1.ts). pi's
  * `after_provider_response` event is the only client-side seam that sees raw
- * response headers (verified against pi 0.83.0's AfterProviderResponseEvent:
+ * response headers (verified against pi 0.84.1's AfterProviderResponseEvent:
  * `{ type: "after_provider_response", status: number, headers: Record<string,
  * string> }` in dist/core/extensions/types.d.ts). Its docs (extensions.md,
  * "after_provider_response") describe `event.headers` as "normalized response
@@ -22,9 +22,8 @@ export interface Reroute {
 export type HeaderMap = Record<string, string | undefined>;
 /**
  * Parse the `x-yagni-model-reroute` header. Returns null when the header is
- * absent, does not match `<from>-><to>:<reason>`, or the reason is not
- * "vision" (the notice copy says "Your image", which only a vision reroute
- * can honestly claim).
+ * absent, does not match `<from>-><to>:<reason>`, or the reason is not a
+ * known reason (vision or policy; see KNOWN_REASONS).
  */
 export declare function parseReroute(headers: HeaderMap): Reroute | null;
 export declare class RerouteNotifier {

package/dist/extension/rerouteNotice.js

@@ -4,7 +4,7 @@
  * The backend sets `x-yagni-model-reroute: <requested>-><effective>:vision` on
  * every response it silently upgrades for image content (yagniCodeV1.ts). pi's
  * `after_provider_response` event is the only client-side seam that sees raw
- * response headers (verified against pi 0.83.0's AfterProviderResponseEvent:
+ * response headers (verified against pi 0.84.1's AfterProviderResponseEvent:
  * `{ type: "after_provider_response", status: number, headers: Record<string,
  * string> }` in dist/core/extensions/types.d.ts). Its docs (extensions.md,
  * "after_provider_response") describe `event.headers` as "normalized response
@@ -14,11 +14,16 @@
  */
 const REROUTE_HEADER = "x-yagni-model-reroute";
 const REROUTE_PATTERN = /^(.+?)->(.+?):(\w+)$/;
+/** Reroute reasons the client understands. `policy` (caller→tier routing,
+ * 2026-08-11 spec) is parsed but deliberately produces NO user notice: the
+ * spec keeps per-request routing quiet — /cost and the savings receipts are
+ * the user-facing surface. `vision` keeps its one-time notice ("Your image…"
+ * is copy only a vision reroute can honestly claim). */
+const KNOWN_REASONS = new Set(["vision", "policy"]);
 /**
  * Parse the `x-yagni-model-reroute` header. Returns null when the header is
- * absent, does not match `<from>-><to>:<reason>`, or the reason is not
- * "vision" (the notice copy says "Your image", which only a vision reroute
- * can honestly claim).
+ * absent, does not match `<from>-><to>:<reason>`, or the reason is not a
+ * known reason (vision or policy; see KNOWN_REASONS).
  */
 export function parseReroute(headers) {
     const value = headers[REROUTE_HEADER];
@@ -28,17 +33,19 @@ export function parseReroute(headers) {
     if (!match)
         return null;
     const [, from, to, reason] = match;
-    if (reason !== "vision")
+    if (!KNOWN_REASONS.has(reason))
         return null;
     return { from, to, reason };
 }
 /**
  * Dedupe wrapper around {@link parseReroute}: `observe` returns the notice
- * message at most once per distinct from->to pair for the life of the
- * instance (i.e. per session), and null otherwise (absent, malformed, or
- * already-seen). Returning the message rather than taking a notify callback
- * keeps the caller in charge of the ctx it has on hand at call time, instead
- * of this class holding a stale reference across calls.
+ * message at most once per distinct from->to->reason triple for the life of
+ * the instance (i.e. per session), and null otherwise (absent, malformed,
+ * already-seen, or a non-vision reason — `policy` reroutes are parsed but
+ * deliberately silent; see KNOWN_REASONS). Returning the message rather than
+ * taking a notify callback keeps the caller in charge of the ctx it has on
+ * hand at call time, instead of this class holding a stale reference across
+ * calls.
  */
 /**
  * The concrete tier ladder cheapest-first, mirroring the proxy's
@@ -53,7 +60,9 @@ export class RerouteNotifier {
         const reroute = parseReroute(headers);
         if (!reroute)
             return null;
-        const key = `${reroute.from}->${reroute.to}`;
+        if (reroute.reason !== "vision")
+            return null;
+        const key = `${reroute.from}->${reroute.to}:${reroute.reason}`;
         if (this.seen.has(key))
             return null;
         this.seen.add(key);

package/dist/extension/subagentRender.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Live progress model + TUI renderers for the `subagent` tool.
+ *
+ * The model half is PURE (mirrors `pipeline/activity.ts`): `applyChildEvent`
+ * folds one NDJSON event from a child into a bounded per-task progress record,
+ * and `finalizeTask` stamps the outcome from the runner's `StageResult`. The
+ * tool carries the folded records in its `details`, so every partial update the
+ * TUI sees is a complete picture of all tasks.
+ *
+ * The renderer half implements pi's per-tool rendering seam (`renderCall` /
+ * `renderResult`). Collapsed-while-running is the two-line pattern: a stable
+ * `agent — task` title over a churning `↳ current tool` line. Completion is a
+ * one-line receipt (`✓ agent · N tool uses · Xk tokens · Ys`); expanded shows
+ * the curated action log and the full report as markdown. String assembly is
+ * kept in pure helpers over a minimal {@link RenderTheme} so tests run against
+ * plain text — renderer exceptions are swallowed by pi (silently degrading to
+ * the bare title bar), so everything here must stay boringly total.
+ */
+import { type Component } from "@earendil-works/pi-tui";
+import type { JsonEvent, StageResult, StageUsage } from "./pipeline/types.js";
+/** The minimal slice of pi's `Theme` the renderers style with (same shape as FeedTheme). */
+export interface RenderTheme {
+    bold(text: string): string;
+    fg(color: string, text: string): string;
+}
+/** One curated line of a child's activity (tool action or narration headline). */
+export interface SubagentActionEntry {
+    kind: "action" | "narration";
+    text: string;
+    state: "running" | "done" | "error";
+    /** Resolves a running tool start against its end event. */
+    toolCallId?: string;
+}
+/** Live/final progress of one subagent task; rides the tool's `details`. */
+export interface SubagentTaskProgress {
+    agent: string;
+    task: string;
+    status: "running" | "done" | "error";
+    /** -1 while the child is still running (mirrors the pi subagent example). */
+    exitCode: number;
+    startedAt: number;
+    endedAt?: number;
+    toolCalls: number;
+    toolErrors: number;
+    usage: StageUsage;
+    /** Bounded curated log; oldest entries are dropped past ACTION_LOG_MAX. */
+    actions: SubagentActionEntry[];
+    droppedActions: number;
+    /** The child's final report, present once the task resolved. */
+    report?: string;
+    stopReason?: string;
+    errorMessage?: string;
+}
+export interface SubagentDetails {
+    tasks: SubagentTaskProgress[];
+}
+/** Bound on the retained action log so a chatty child cannot grow details unbounded. */
+export declare const ACTION_LOG_MAX = 120;
+export declare function newTaskProgress(agent: string, task: string, startedAt: number): SubagentTaskProgress;
+/**
+ * Fold one child NDJSON event into the task's progress. Returns true when the
+ * record changed (the tool emits an update), false for events we drop.
+ */
+export declare function applyChildEvent(p: SubagentTaskProgress, ev: JsonEvent): boolean;
+/** Stamp the runner's outcome onto the progress record. */
+export declare function finalizeTask(p: SubagentTaskProgress, result: StageResult, endedAt: number): void;
+/** 532 → "532", 41_234 → "41.2k", 1_240_000 → "1.2M". */
+export declare function formatTokens(n: number): string;
+/** 42_000 → "42s", 81_000 → "1m 21s", 3_720_000 → "1h 2m". */
+export declare function formatDuration(ms: number): string;
+/**
+ * The two-line live status for one running task: a stable `agent — task` title
+ * over the churning current-action line with elapsed time and live tokens.
+ */
+export declare function runningLines(p: SubagentTaskProgress, theme: RenderTheme, now: number, frame: string): string[];
+/** One-line completion receipt: `✓ agent · N tool uses · Xk tokens · Ys · $c`. */
+export declare function receiptLine(p: SubagentTaskProgress, theme: RenderTheme): string;
+/**
+ * Plain-text (no theme) summary for the partial result's `content`, so headless
+ * consumers and pi's fallback renderer still see live progress.
+ */
+export declare function progressSummaryText(tasks: SubagentTaskProgress[], now: number): string;
+/** The harness "Working…" replacement while subagents run. */
+export declare function formatWorkingMessage(tasks: SubagentTaskProgress[], now: number): string;
+/** The subagent tool's argument shape, partial while the model streams it. */
+interface SubagentCallArgs {
+    task?: string;
+    agent?: string;
+    tasks?: Array<{
+        task?: string;
+        agent?: string;
+    }>;
+}
+/** Renderer-row state shared across renders of one tool call (context.state). */
+interface LiveRenderState {
+    timer?: ReturnType<typeof setInterval>;
+}
+interface RenderContextSlice {
+    state?: LiveRenderState;
+    invalidate: () => void;
+}
+/** Title painted the moment the call streams in (before any execution output). */
+export declare function renderSubagentCall(args: SubagentCallArgs | undefined, theme: RenderTheme, _context: unknown): Component;
+/**
+ * A prose body as markdown when the TUI's markdown theme is available.
+ * `getMarkdownTheme()` hands back a lazy proxy that only throws when a style is
+ * first USED, so the fallback must wrap `render`, not construction — otherwise
+ * an uninitialized theme would blow up mid-paint and pi would silently degrade
+ * the whole row to the bare title bar.
+ */
+export declare function markdownOrPlain(body: string, theme: RenderTheme): Component;
+/**
+ * Result renderer: live two-line status per task while partial; receipts plus
+ * report preview when collapsed; action log plus full markdown report when
+ * expanded. Drives its own refresh while running via an unref'd interval on
+ * `context.state` (pi has no unmount hook — the final render clears it).
+ */
+export declare function renderSubagentResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: unknown;
+}, options: {
+    expanded: boolean;
+    isPartial: boolean;
+}, theme: RenderTheme, context: RenderContextSlice): Component;
+export {};
+//# sourceMappingURL=subagentRender.d.ts.map