@yagni-app/code 0.2.0 → 0.3.0

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,19 +22,10 @@ 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;
-/**
- * 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.
- */
 export declare class RerouteNotifier {
     private readonly seen;
     observe(headers: HeaderMap): string | null;

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,25 +33,36 @@ 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
+ * VISION_REROUTE_LADDER (yagniCodeV1.ts). Used only to tell an upgrade
+ * reroute from a downgrade so the "Billed as" clause names the tier the
+ * proxy actually bills.
+ */
+const TIER_LADDER = ["efficient", "standard", "advanced", "peak"];
 export class RerouteNotifier {
     seen = new Set();
     observe(headers) {
         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);
@@ -54,13 +70,18 @@ export class RerouteNotifier {
         // assertBillableTier throws if it ever reaches pricing) — for a balanced
         // reroute the bill IS the resolved tier (`reroute.to`; yagniCodeV1.ts's
         // `billedTier` takes its `effectiveModel` arm here), so a "Billed as
-        // balanced" clause would name a non-price. Only a CONCRETE from-tier
-        // still bills at its own pre-reroute rate (Task 3's invariant: a re-route
-        // never moves anyone's price), so only then is a distinct "Billed as X"
-        // line honest.
+        // balanced" clause would name a non-price.
         if (reroute.from === "balanced") {
             return `Your image was handled on the ${reroute.to} tier.`;
         }
+        // Concrete tiers bill the CHEAPER of requested and served (yagniCodeV1.ts's
+        // billedTier): an UPGRADE still bills the pre-reroute tier, so a distinct
+        // "Billed as X" line is honest; a DOWNGRADE bills the served tier, where
+        // that clause would name a price the proxy did not charge.
+        const downgraded = TIER_LADDER.indexOf(reroute.to) < TIER_LADDER.indexOf(reroute.from);
+        if (downgraded) {
+            return `Your image was handled on the ${reroute.to} tier. Billed as ${reroute.to}.`;
+        }
         return `Your image was handled on the ${reroute.to} tier. Billed as ${reroute.from}.`;
     }
 }

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