@yagni-app/code 0.3.0 → 0.3.1

package/dist/extension/askAdvisorTool.d.ts

@@ -26,10 +26,12 @@
  * this module is the I/O.
  */
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { type AdvisorLimits, type AdvisorStateHandle } from "./advisor.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
-import type { PipelineStage } from "./pipeline/types.js";
+import { type PipelineStage } from "./pipeline/types.js";
+import { type RenderTheme, type SubagentTaskProgress } from "./subagentRender.js";
 /**
  * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
  * reason documented there: enough tools to navigate instead of flailing on a
@@ -66,10 +68,18 @@ export declare function buildConsultBrief(params: {
  * persona, and that is the advisor's own.
  */
 export declare function advisorStage(): PipelineStage;
-export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): ToolDefinition<typeof parameters, {
+/** The ask_advisor result details: consult accounting plus the live progress
+ * record the subagent renderers paint (one task, the consult itself). */
+export interface AdvisorToolDetails {
     consults: number;
     cost: number;
-}>;
+    tasks?: SubagentTaskProgress[];
+}
+/** Title painted the moment the ask_advisor call streams in. */
+export declare function renderAdvisorCall(args: {
+    question?: string;
+} | undefined, theme: RenderTheme, _context: unknown): Component;
+export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): ToolDefinition<typeof parameters, AdvisorToolDetails>;
 /**
  * `/advise <question>` — the manual escalation lever.
  *
@@ -77,6 +87,11 @@ export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): Too
  * consult draws on the same cap rather than opening a side channel around it.
  * The advice is sent into the conversation (like /go-compare's report) so the
  * driver sees it in context and can act on it.
+ *
+ * A command has no tool row for pi to render, so the live view is an
+ * aboveEditor widget painted from the tool's partial updates: the same
+ * two-line `agent — task` / `↳ current tool` status the subagent tool shows,
+ * driven by a spinner ticker so it visibly moves between child events.
  */
 export declare function registerAdviseCommand(pi: ExtensionAPI, tool: ReturnType<typeof makeAskAdvisorTool>): void;
 export {};

package/dist/extension/askAdvisorTool.js

@@ -25,9 +25,14 @@
  * The gate, the cap and the spend ceiling live in `advisor.ts` and are pure;
  * this module is the I/O.
  */
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { ADVISOR_MODEL_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatConsultCost, } from "./advisor.js";
+import { SPINNER_FRAMES } from "./pipeline/activityFeed.js";
+import { withResilience } from "./pipeline/resilience.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
+import { DEFAULT_RESILIENCE_POLICY } from "./pipeline/types.js";
+import { applyChildEvent, finalizeTask, formatWorkingMessage, newTaskProgress, progressSummaryText, receiptLine, renderSubagentResult, runningLines, } from "./subagentRender.js";
 /**
  * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
  * reason documented there: enough tools to navigate instead of flailing on a
@@ -71,9 +76,33 @@ export function advisorStage() {
         taskTemplate: "{ticket}",
     };
 }
+/** Spinner cadence for the advisor's live views; matches subagentRender. */
+const SPINNER_TICK_MS = 120;
+/** Question preview width on the call title line. */
+const QUESTION_PREVIEW_MAX = 128;
+function clip(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+/** Title painted the moment the ask_advisor call streams in. */
+export function renderAdvisorCall(args, theme, _context) {
+    const title = theme.fg("toolTitle", theme.bold("advisor"));
+    let text = `${title} ${theme.fg("accent", "peak-tier consult")}`;
+    if (args?.question)
+        text += `\n  ${theme.fg("dim", clip(args.question, QUESTION_PREVIEW_MAX))}`;
+    return new Text(text, 0, 0);
+}
 export function makeAskAdvisorTool(opts) {
     const limits = opts.limits ?? DEFAULT_ADVISOR_LIMITS;
-    const runStage = opts.runStage ?? defaultRunStage;
+    // The default runner rides the /go pipeline's resilience wrapper, exactly
+    // like the subagent tool: idle + wall-clock ceilings and transient-only
+    // retry, so a stalled consult child aborts honestly instead of hanging the
+    // driver's tool call until the user presses Esc. The synthetic stage id is
+    // "plan" (read-only tools, no bash), so the wrapper's write-gate never
+    // blocks a retry — re-running a consult cannot double-apply anything.
+    const runStage = opts.runStage ?? withResilience(defaultRunStage, DEFAULT_RESILIENCE_POLICY);
     return {
         name: "ask_advisor",
         label: "Ask the advisor",
@@ -95,6 +124,8 @@ export function makeAskAdvisorTool(opts) {
             "The advice comes back as plain text: act on it, and call record_decision when it settles a product-intent call so the next agent inherits it.",
         ],
         parameters,
+        renderCall: renderAdvisorCall,
+        renderResult: renderSubagentResult,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             // Read the LIVE session model: pi's picker can change it after this tool
             // was registered, in both directions.
@@ -109,19 +140,51 @@ export function makeAskAdvisorTool(opts) {
                     details: { consults: opts.state.read().consults, cost: 0 },
                 };
             }
-            onUpdate?.({
-                content: [{ type: "text", text: "Consulting the advisor…" }],
-                details: { consults: opts.state.read().consults, cost: 0 },
-            });
-            const result = await runStage(advisorStage(), { ticket: buildConsultBrief(params) }, {
-                cwd: ctx?.cwd ?? process.cwd(),
-                ...(signal ? { signal } : {}),
-                // YAG-471: attribute the consult's completions to the advisor, not
-                // the "plan" stage id advisorStage() borrows (see its docblock).
-                callerLabel: "advisor",
-            });
+            // Live progress, exactly the subagent tool's shape: the folded record
+            // rides every partial update's `details.tasks` (painted by
+            // renderSubagentResult), the plain-text summary rides `content` for
+            // headless consumers, and the harness "Working…" line mirrors it.
+            const progress = newTaskProgress("advisor", params.question, Date.now());
+            const ui = ctx?.hasUI ? ctx.ui : undefined;
+            let lastWorking;
+            const emit = () => {
+                const now = Date.now();
+                onUpdate?.({
+                    content: [{ type: "text", text: progressSummaryText([progress], now) }],
+                    details: {
+                        consults: opts.state.read().consults,
+                        cost: progress.usage.cost,
+                        tasks: [{ ...progress, actions: [...progress.actions], usage: { ...progress.usage } }],
+                    },
+                });
+                const working = formatWorkingMessage([progress], now);
+                if (ui && working !== lastWorking) {
+                    lastWorking = working;
+                    ui.setWorkingMessage?.(working);
+                }
+            };
+            emit();
+            let result;
+            try {
+                result = await runStage(advisorStage(), { ticket: buildConsultBrief(params) }, {
+                    cwd: ctx?.cwd ?? process.cwd(),
+                    ...(signal ? { signal } : {}),
+                    // YAG-471: attribute the consult's completions to the advisor, not
+                    // the "plan" stage id advisorStage() borrows (see its docblock).
+                    callerLabel: "advisor",
+                    onEvent: (ev) => {
+                        if (applyChildEvent(progress, ev))
+                            emit();
+                    },
+                });
+            }
+            finally {
+                // Restore the default "Working…" text whether we resolved or threw.
+                ui?.setWorkingMessage?.();
+            }
             const cost = result.usage?.cost ?? 0;
             const state = opts.state.record(cost);
+            finalizeTask(progress, result, Date.now());
             if (result.exitCode !== 0 && !result.finalOutput.trim()) {
                 // Fail honestly rather than returning an empty recommendation. The
                 // consult still counts: it spawned, and it may well have spent.
@@ -134,7 +197,7 @@ export function makeAskAdvisorTool(opts) {
                                 `Decide this one yourself.`,
                         },
                     ],
-                    details: { consults: state.consults, cost },
+                    details: { consults: state.consults, cost, tasks: [progress] },
                 };
             }
             return {
@@ -144,11 +207,13 @@ export function makeAskAdvisorTool(opts) {
                         text: `${result.finalOutput.trim()}\n\n${formatConsultCost({ cost, consults: state.consults, limits })}`,
                     },
                 ],
-                details: { consults: state.consults, cost },
+                details: { consults: state.consults, cost, tasks: [progress] },
             };
         },
     };
 }
+/** The widget key the /advise live panel paints under. */
+const ADVISE_WIDGET_KEY = "yagni-advise";
 /**
  * `/advise <question>` — the manual escalation lever.
  *
@@ -156,6 +221,11 @@ export function makeAskAdvisorTool(opts) {
  * consult draws on the same cap rather than opening a side channel around it.
  * The advice is sent into the conversation (like /go-compare's report) so the
  * driver sees it in context and can act on it.
+ *
+ * A command has no tool row for pi to render, so the live view is an
+ * aboveEditor widget painted from the tool's partial updates: the same
+ * two-line `agent — task` / `↳ current tool` status the subagent tool shows,
+ * driven by a spinner ticker so it visibly moves between child events.
  */
 export function registerAdviseCommand(pi, tool) {
     pi.registerCommand("advise", {
@@ -175,8 +245,41 @@ export function registerAdviseCommand(pi, tool) {
                 return;
             }
             notify("Consulting the peak-tier advisor. This reads the repo, so it takes a moment.", "info");
+            // Live panel state: the newest folded progress record from the tool's
+            // partial updates, repainted on a spinner tick until the consult ends.
+            let progress;
+            let paintTimer;
+            const theme = ctx.hasUI ? ctx.ui.theme : undefined;
+            const paint = () => {
+                if (!ctx.hasUI || !theme || !progress)
+                    return;
+                const now = Date.now();
+                const lines = progress.status === "running"
+                    ? runningLines(progress, theme, now, SPINNER_FRAMES[Math.floor(now / SPINNER_TICK_MS) % SPINNER_FRAMES.length])
+                    : [receiptLine(progress, theme)];
+                ctx.ui.setWidget?.(ADVISE_WIDGET_KEY, lines, { placement: "aboveEditor" });
+            };
+            const onUpdate = (update) => {
+                const task = update.details?.tasks?.[0];
+                if (!task)
+                    return;
+                progress = task;
+                if (ctx.hasUI && theme && !paintTimer) {
+                    paintTimer = setInterval(paint, SPINNER_TICK_MS);
+                    paintTimer.unref?.();
+                }
+                paint();
+            };
+            const clearPanel = () => {
+                if (paintTimer) {
+                    clearInterval(paintTimer);
+                    paintTimer = undefined;
+                }
+                if (ctx.hasUI)
+                    ctx.ui.setWidget?.(ADVISE_WIDGET_KEY, undefined);
+            };
             try {
-                const out = await tool.execute("advise", { question }, ctx.signal, undefined, ctx);
+                const out = await tool.execute("advise", { question }, ctx.signal, onUpdate, ctx);
                 const text = out.content
                     .map((c) => c.text ?? "")
                     .join("\n")
@@ -188,6 +291,9 @@ export function registerAdviseCommand(pi, tool) {
                 notify(`/advise failed: ${message}`, "error");
                 await pi.sendUserMessage(`/advise failed: ${message}`);
             }
+            finally {
+                clearPanel();
+            }
         },
     });
 }

package/dist/extension/askYagniTool.d.ts

@@ -1,11 +1,20 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { type FlywheelState } from "./flywheel.js";
 import { type RepoDocSnippet } from "./repoDocs.js";
 /** A single source citation returned by the YAGNI `ask` endpoint. */
 export interface Citation {
     title: string;
     url: string;
 }
+/**
+ * How hard the answer may be leaned on (mirror of `@yagni/shared`'s
+ * AskStanding — mirrored locally by this extension's no-workspace-imports
+ * convention, see costHud.ts).
+ */
+export type AskStanding = "confirmed" | "asserted" | "inferred" | "no_position";
+/** One line the TUI shows above the answer, per standing. */
+export declare const STANDING_LINES: Record<AskStanding, string>;
 /** Options for {@link makeAskYagniTool}. */
 export interface MakeAskYagniToolOptions {
     baseUrl: string;
@@ -19,6 +28,19 @@ export interface MakeAskYagniToolOptions {
      * checkout's own era, since the docs are read from the tree being edited.
      */
     collectDocs?: (cwd: string, query: string) => RepoDocSnippet[];
+    /**
+     * Shared flywheel session state (Run 7): caps how many no-position
+     * recordSuggestions reach the model per session and attributes the
+     * follow-up record_decision for dedupe. Absent → suggestions always
+     * surface, nothing is attributed (tests, older wiring).
+     */
+    flywheel?: FlywheelState;
+    /**
+     * The session repo (`owner/name`), for the backend's soft-scoped decision
+     * read (workspace-level decisions plus this repo's own — never another
+     * repo's conventions). Absent keeps the workspace-wide read.
+     */
+    getRepo?: () => string | undefined;
 }
 declare const parameters: Type.TObject<{
     question: Type.TString;
@@ -34,6 +56,7 @@ declare const parameters: Type.TObject<{
  */
 export declare function makeAskYagniTool(opts: MakeAskYagniToolOptions): ToolDefinition<typeof parameters, {
     citations: Citation[];
+    standing?: AskStanding;
 }>;
 export {};
 //# sourceMappingURL=askYagniTool.d.ts.map

package/dist/extension/askYagniTool.js

@@ -1,8 +1,21 @@
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { canSurfaceSuggestion, noteSuggestionSurfaced } from "./flywheel.js";
 import { collectRepoDocs } from "./repoDocs.js";
 import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
 import { markdownOrPlain } from "./subagentRender.js";
+/** One line the TUI shows above the answer, per standing. */
+export const STANDING_LINES = {
+    confirmed: "Grounded in a confirmed decision",
+    asserted: "Grounded in a recorded assumption, not yet verified",
+    inferred: "Inferred from workspace context, not a recorded decision",
+    no_position: "No recorded position in this workspace",
+};
+function standingLine(value) {
+    return typeof value === "string" && value in STANDING_LINES
+        ? STANDING_LINES[value]
+        : undefined;
+}
 const parameters = Type.Object({
     question: Type.String(),
     context: Type.Optional(Type.String()),
@@ -40,6 +53,7 @@ export function makeAskYagniTool(opts) {
             "Call ask_yagni BEFORE guessing about anything organization- or codebase-specific (conventions, policies, architecture, ownership, product decisions).",
             "Pass the user's actual question; add relevant local context (file paths, snippets) in the optional `context` field.",
             "When you use an answer, quote or reference its citations so the user can verify the source.",
+            "Answers carry a standing: treat a confirmed decision as settled; when you lean on an unverified assumption or an inference, say so where the work is reviewed; when there is no recorded position, follow the answer's instruction to record the assumption you proceed on.",
         ],
         parameters,
         renderCall(args, theme) {
@@ -55,8 +69,11 @@ export function makeAskYagniTool(opts) {
             const citations = result.details?.citations ?? [];
             if (isPartial)
                 return new Text(t.fg("muted", answer || "Asking YAGNI…"), 0, 0);
+            const standing = standingLine(result.details?.standing);
             if (expanded) {
                 const container = new Container();
+                if (standing)
+                    container.addChild(new Text(t.fg("muted", standing), 0, 0));
                 container.addChild(markdownOrPlain(answer || "(no answer)", t));
                 if (citations.length > 0) {
                     container.addChild(new Spacer(1));
@@ -69,6 +86,8 @@ export function makeAskYagniTool(opts) {
             const lines = answer.trim().split("\n");
             const out = lines.slice(0, ANSWER_PREVIEW_LINES).map((l) => t.fg("toolOutput", l));
             const meta = [];
+            if (standing)
+                meta.push(standing);
             if (citations.length > 0)
                 meta.push(citationCount(citations.length));
             if (lines.length > ANSWER_PREVIEW_LINES || citations.length > 0)
@@ -95,6 +114,7 @@ export function makeAskYagniTool(opts) {
                     question: params.question,
                     context: params.context,
                     cwd: ctx?.cwd,
+                    ...(opts.getRepo?.() ? { repo: opts.getRepo() } : {}),
                     ...(repoDocs.length > 0 ? { repoDocs } : {}),
                 }),
             }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
@@ -102,9 +122,29 @@ export function makeAskYagniTool(opts) {
                 throw new Error(await friendlyFetchError("ask_yagni", res));
             }
             const data = (await res.json());
+            // Run 7 flywheel: a no-position answer carries the record-the-assumption
+            // instruction. It reaches the model VERBATIM inside the tool result, but
+            // only up to the per-session cap — past it a busy run stops being told
+            // to bank more asserted rows.
+            let text = data.answer;
+            const suggestion = data.recordSuggestion?.instruction;
+            if (suggestion && data.standing === "no_position") {
+                const state = opts.flywheel;
+                if (!state || canSurfaceSuggestion(state)) {
+                    // Attribution correlates to the QUESTION the suggestion asked
+                    // about, so only the record_decision that answers it inherits the
+                    // dedupe flag.
+                    if (state)
+                        noteSuggestionSurfaced(state, data.recordSuggestion?.question ?? params.question);
+                    text = `${text}\n\n${suggestion}`;
+                }
+            }
             return {
-                content: [{ type: "text", text: data.answer }],
-                details: { citations: data.citations ?? [] },
+                content: [{ type: "text", text }],
+                details: {
+                    citations: data.citations ?? [],
+                    ...(data.standing ? { standing: data.standing } : {}),
+                },
             };
         },
     };

package/dist/extension/branding.d.ts

@@ -30,6 +30,14 @@ export declare const YAGNI_IDENTITY: string;
  * exist.
  */
 export declare const DRIVER_DELEGATION_PARAGRAPH: string;
+/**
+ * The ultra-mode delegation directive (/ultra): the user has opted into
+ * aggressive multi-agent orchestration, so the driver is told to structure
+ * meaningful work as a diamond — split, fan out workers, fan out refuting
+ * checkers, synthesize — instead of delegating only when convenient.
+ * DRIVER-ONLY for the same reason as {@link DRIVER_DELEGATION_PARAGRAPH}.
+ */
+export declare const ULTRA_DELEGATION_PARAGRAPH: string;
 /**
  * The identity used for the interactive DRIVER session ONLY: {@link
  * YAGNI_IDENTITY} plus {@link DRIVER_DELEGATION_PARAGRAPH}. The caller (index.ts)
@@ -37,7 +45,9 @@ export declare const DRIVER_DELEGATION_PARAGRAPH: string;
  * effective `x-yagni-caller` attribution (config.ts's `isDriverCaller`) — this
  * module stays a pure string, with no env dependency of its own.
  */
-export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation: fan codebase mapping, wide searches, and mechanical multi-file work out to subagents (they run on cheaper tiers). Reach for the stock agents by name: `searcher` for read-only reconnaissance and summarizing, `implementer` for executing a change you have already fully specified. Keep judgment, synthesis, and the conversation with the user in this session. Do not spawn a subagent for work you can finish in a couple of tool calls.";
+export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation: fan codebase mapping, wide searches, and mechanical multi-file work out to subagents (they run on cheaper tiers). Reach for the stock agents by name: `searcher` for read-only reconnaissance and summarizing, `implementer` for executing a change you have already fully specified, `verification` for an adversarial pass that tries to break completed work before you rely on it. Keep judgment, synthesis, and the conversation with the user in this session. Do not spawn a subagent for work you can finish in a couple of tool calls.";
+/** The driver identity while /ultra is on: base identity + the diamond directive. */
+export declare const YAGNI_IDENTITY_ULTRA = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation (ultra mode): the user has switched this session to ultra mode \u2014 aggressive multi-agent orchestration. Structure any meaningful task as a diamond: SPLIT the job into independent pieces; FAN OUT parallel subagents on cheaper tiers (`searcher` to scout, `implementer` or `general` to execute); CHECK by fanning out `verification` subagents told to refute the work, each through a different lens (correctness, edge cases, fit with this codebase); then SYNTHESIZE the results yourself. Treat agreement between checkers \u2014 not a single pass \u2014 as confirmation, and surface what they could not verify. Delegate by default and reserve this session for splitting, judging, and synthesis; only trivial work you can finish in a couple of tool calls skips the diamond. Subagents cannot touch your todo_write checklist, so keep it current yourself: update it when you split the job and again as each fanned-out piece lands, not only at the end.";
 export declare const PI_IDENTITY_RE: RegExp;
 /**
  * Env switch that bypasses the system-prompt rewrite entirely, so pi's

package/dist/extension/branding.js

@@ -42,10 +42,31 @@ export const YAGNI_IDENTITY = "You are YAGNI Code, an autonomous terminal coding
 export const DRIVER_DELEGATION_PARAGRAPH = "Delegation: fan codebase mapping, wide searches, and mechanical multi-file " +
     "work out to subagents (they run on cheaper tiers). Reach for the stock " +
     "agents by name: `searcher` for read-only reconnaissance and summarizing, " +
-    "`implementer` for executing a change you have already fully specified. " +
-    "Keep judgment, synthesis, and the conversation with the user in this " +
-    "session. Do not spawn a subagent for work you can finish in a couple of " +
-    "tool calls.";
+    "`implementer` for executing a change you have already fully specified, " +
+    "`verification` for an adversarial pass that tries to break completed work " +
+    "before you rely on it. Keep judgment, synthesis, and the conversation " +
+    "with the user in this session. Do not spawn a subagent for work you can " +
+    "finish in a couple of tool calls.";
+/**
+ * The ultra-mode delegation directive (/ultra): the user has opted into
+ * aggressive multi-agent orchestration, so the driver is told to structure
+ * meaningful work as a diamond — split, fan out workers, fan out refuting
+ * checkers, synthesize — instead of delegating only when convenient.
+ * DRIVER-ONLY for the same reason as {@link DRIVER_DELEGATION_PARAGRAPH}.
+ */
+export const ULTRA_DELEGATION_PARAGRAPH = "Delegation (ultra mode): the user has switched this session to ultra mode " +
+    "— aggressive multi-agent orchestration. Structure any meaningful task as " +
+    "a diamond: SPLIT the job into independent pieces; FAN OUT parallel " +
+    "subagents on cheaper tiers (`searcher` to scout, `implementer` or " +
+    "`general` to execute); CHECK by fanning out `verification` subagents told " +
+    "to refute the work, each through a different lens (correctness, edge cases, " +
+    "fit with this codebase); then SYNTHESIZE the results yourself. Treat " +
+    "agreement between checkers — not a single pass — as confirmation, and " +
+    "surface what they could not verify. Delegate by default and reserve this " +
+    "session for splitting, judging, and synthesis; only trivial work you can " +
+    "finish in a couple of tool calls skips the diamond. Subagents cannot touch " +
+    "your todo_write checklist, so keep it current yourself: update it when you " +
+    "split the job and again as each fanned-out piece lands, not only at the end.";
 /**
  * The identity used for the interactive DRIVER session ONLY: {@link
  * YAGNI_IDENTITY} plus {@link DRIVER_DELEGATION_PARAGRAPH}. The caller (index.ts)
@@ -54,6 +75,14 @@ export const DRIVER_DELEGATION_PARAGRAPH = "Delegation: fan codebase mapping, wi
  * module stays a pure string, with no env dependency of its own.
  */
 export const YAGNI_IDENTITY_DRIVER = `${YAGNI_IDENTITY}\n\n${DRIVER_DELEGATION_PARAGRAPH}`;
+/** The driver identity while /ultra is on: base identity + the diamond directive. */
+export const YAGNI_IDENTITY_ULTRA = `${YAGNI_IDENTITY}\n\n${ULTRA_DELEGATION_PARAGRAPH}`;
+/**
+ * Every identity variant this module can install, longest-composite-first, so
+ * the re-brand swap below never leaves a shorter variant's orphaned delegation
+ * paragraph behind (driver/ultra both start with the base identity).
+ */
+const KNOWN_IDENTITIES = [YAGNI_IDENTITY_ULTRA, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY];
 // pi 0.84.1's exact identity sentence (dist/core/system-prompt.js). Exported as
 // the identity anchor the CLI's pi-contract tripwire test reads back from pi's
 // built system prompt, so a pi bump that reworded the opener (silently defeating
@@ -112,15 +141,26 @@ export function brandSystemPrompt(original, opts = {}) {
     let s = original;
     // 1. Drop pi's self-referential documentation block.
     s = s.replace(PI_DOCS_BLOCK_RE, "");
-    // 2. Own the identity.
+    // 2. Own the identity. A previously-branded prompt may open with a DIFFERENT
+    // variant than the one now requested (/ultra toggles the driver between the
+    // delegation and diamond paragraphs mid-session) — swap it in place rather
+    // than prepending a second identity block.
     if (PI_IDENTITY_RE.test(s)) {
         s = s.replace(PI_IDENTITY_RE, identity);
     }
     else if (PI_IDENTITY_LOOSE_RE.test(s)) {
         s = s.replace(PI_IDENTITY_LOOSE_RE, identity);
     }
-    else if (!s.trimStart().startsWith(identity)) {
-        s = `${identity}\n\n${s}`;
+    else {
+        const trimmed = s.trimStart();
+        const lead = s.slice(0, s.length - trimmed.length);
+        const existing = KNOWN_IDENTITIES.find((k) => trimmed.startsWith(k));
+        if (existing && existing !== identity) {
+            s = `${lead}${identity}${trimmed.slice(existing.length)}`;
+        }
+        else if (!existing && !trimmed.startsWith(identity)) {
+            s = `${identity}\n\n${s}`;
+        }
     }
     // 3. Safety net for residual brand tokens (never inside user content).
     s = scrubOutsideProjectContext(s);

package/dist/extension/config.d.ts

@@ -113,6 +113,12 @@ export interface ContextBrief {
         decisions: number;
         corrections: number;
     };
+    /**
+     * Active decisions scoped to the repo named on the request (additive, Run
+     * 7; absent without `?repo=`, on older backends, and on a count failure).
+     * The opt-in mining beat fires ONLY on an explicit 0.
+     */
+    repoDecisionCount?: number;
 }
 /**
  * Attribution headers for the model proxy (YAG-471). On the SERVER side these
@@ -192,6 +198,12 @@ export interface FetchContextBriefOptions {
     fetchImpl?: typeof fetch;
     /** Env seam for the telemetry headers; defaults to process.env. */
     env?: NodeJS.ProcessEnv;
+    /**
+     * The session repo (`owner/name`), when resolvable. Rides as `?repo=` so
+     * the response can carry `repoDecisionCount` for the mining beat — no
+     * second round-trip at boot.
+     */
+    repo?: string;
 }
 /**
  * Fetch the workspace company brief at startup.

package/dist/extension/config.js

@@ -208,7 +208,8 @@ export function sessionTelemetryHeaders(env = process.env) {
  */
 export async function fetchContextBrief(opts) {
     try {
-        const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/context`, {
+        const query = opts.repo ? `?repo=${encodeURIComponent(opts.repo)}` : "";
+        const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/context${query}`, {
             method: "GET",
             headers: {
                 authorization: `Bearer ${opts.getToken() ?? ""}`,

package/dist/extension/execPolicy.d.ts

@@ -35,7 +35,18 @@
  * bundler), and external dependencies aren't resolvable from the bundled path.
  */
 export type TokenEntry = string | {
-    op: "pipe" | "and" | "or" | "semi" | "redirect" | "substitution";
+    op: "pipe" | "and" | "or" | "semi" | "substitution";
+} | {
+    op: "redirect";
+    direction: "out";
+    fd: "stdout" | "stderr";
+    target: string;
+    append: boolean;
+} | {
+    op: "redirect";
+    direction: "in";
+} | {
+    op: "background";
 };
 /**
  * Parse a shell command string into tokens and control operators.
@@ -48,6 +59,11 @@ export type TokenEntry = string | {
  * - `#` comments (start-of-word to end-of-line, outside quotes)
  * - Shell constructs we flag as unanalyzable: $(), backticks (INCLUDING
  *   inside double quotes — bash executes those), >, <, background &
+ * - Redirect metadata: stdout/stderr redirects carry fd + target so that
+ *   safe redirects (2>/dev/null, 2>&1) can be distinguished from unsafe ones
+ *   (> file.txt). Stdin redirects (<, <<) carry no metadata — they always
+ *   floor. Background & emits a distinct `background` op (not `semi`) so
+ *   hasUnhandledConstructs can always catch it.
  *
  * Does NOT handle: variable expansion, glob patterns, heredocs beyond the
  * redirect flag, nested subshells beyond depth tracking. Commands using