@yagni-app/code-staging 0.3.0-staging.1082.1 → 0.3.0-staging.1088.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 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,12 @@
  * 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 { runStage as defaultRunStage } from "./pipeline/runner.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,6 +74,24 @@ 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;
@@ -95,6 +116,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 +132,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 +189,7 @@ export function makeAskAdvisorTool(opts) {
                                 `Decide this one yourself.`,
                         },
                     ],
-                    details: { consults: state.consults, cost },
+                    details: { consults: state.consults, cost, tasks: [progress] },
                 };
             }
             return {
@@ -144,11 +199,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 +213,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 +237,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 +283,9 @@ export function registerAdviseCommand(pi, tool) {
                 notify(`/advise failed: ${message}`, "error");
                 await pi.sendUserMessage(`/advise failed: ${message}`);
             }
+            finally {
+                clearPanel();
+            }
         },
     });
 }

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.";
 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,29 @@ 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.";
 /**
  * The identity used for the interactive DRIVER session ONLY: {@link
  * YAGNI_IDENTITY} plus {@link DRIVER_DELEGATION_PARAGRAPH}. The caller (index.ts)
@@ -54,6 +73,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 +139,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/index.d.ts

@@ -122,7 +122,9 @@ export type { RecordDecisionParams } from "./recordDecisionTool.js";
 export { runInitPass, runTeamSetup, registerTeamSetupCommand, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
 export type { RunInitPassDeps, InitPassOutcome, RunTeamSetupDeps, TeamSetupOutcome, RepoIntake, RepoIntakeFs, EngineeringDraft, DraftTeam, } from "./initPass.js";
 export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
-export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, BRAND_NAME } from "./branding.js";
+export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA, BRAND_NAME } from "./branding.js";
+export { createUltraHolder, registerUltraCommand } from "./ultra.js";
+export type { UltraHolder } from "./ultra.js";
 export { attributionHeaders, isDriverCaller, fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl, sanitizeCallerSegment, } from "./config.js";
 export type { CatalogResult, FetchCatalogOptions, ModelEntry } from "./config.js";
 export { buildYagniProvider } from "./provider.js";
@@ -139,7 +141,7 @@ export type { VerifyCommand, VerifyOutcome } from "./pipeline/verify.js";
 export { blindStages, reportOnlyStages, makeGroundedVsBlindEval, formatComparisonReport } from "./pipeline/eval.js";
 export type { ComparisonReport, LaneFit, LaneOutcome } from "./pipeline/eval.js";
 export { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
-export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
+export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, MAX_PARALLEL_SUBAGENTS_ULTRA, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
 export type { SubagentDef, SubagentSource } from "./subagents.js";
 export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, todoSummary, TODO_TOOL_NAME, MAX_TODOS, } from "./todos.js";
 export type { TodoItem, TodoStatus, TodoTheme } from "./todos.js";

package/dist/extension/index.js

@@ -14,7 +14,7 @@ import { registerCmuxBridge } from "./cmux/index.js";
 import { makeRecordEngineeringContextTool } from "./recordContextTool.js";
 import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
-import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER } from "./branding.js";
+import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA } from "./branding.js";
 import { claudeRulesSection } from "./claudeRules.js";
 import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
@@ -29,6 +29,7 @@ import { registerGoCommand } from "./pipeline/goCommand.js";
 import { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
 import { DEFAULT_PERMISSION_POLICY, createModeHolder, registerPermissionGate } from "./permission.js";
 import { registerSubagents } from "./subagents.js";
+import { createUltraHolder, registerUltraCommand } from "./ultra.js";
 import { registerTodos } from "./todos.js";
 import { registerDecisionCommands } from "./decisions.js";
 import { makeDecisionCapture } from "./decisionCapture.js";
@@ -185,7 +186,12 @@ export async function registerYagni(pi, deps = {}) {
     // The general subagent tool: delegate self-contained tasks (optionally in
     // parallel) to fresh-context agents defined in .claude/agents / .pi/agents,
     // riding the /go pipeline's child runner. /agents lists what's available.
-    registerSubagents(pi);
+    // Ultra mode (/ultra) is an explicit orchestration dial: it swaps the
+    // driver's delegation identity for the diamond directive (see the
+    // before_agent_start handler below) and widens the tool's fan-out ceiling.
+    const ultraHolder = createUltraHolder();
+    registerSubagents(pi, { isUltra: () => ultraHolder.get() });
+    registerUltraCommand(pi, ultraHolder);
     // Shared fetch timeout for the small, interactive display-path reads below
     // (/cost's spend + headroom, and Task 8's per-run spend for /go's summary):
     // 5s, not the 10s other boot/grounding fetches use, because the user is
@@ -517,13 +523,19 @@ export async function registerYagni(pi, deps = {}) {
     // assembled prompt passes through byte-exact (no rewrite, no brief
     // injection, no rules section, no delegation identity).
     const noBranding = brandingDisabled(env);
-    const identity = isDriverCaller(env) ? YAGNI_IDENTITY_DRIVER : undefined;
+    // Resolved per turn (not once at activation): /ultra can flip the driver
+    // between the delegation and diamond identities mid-session.
+    const isDriver = isDriverCaller(env);
     pi.on("before_agent_start", (event) => noBranding
         ? undefined
         : {
             systemPrompt: brandSystemPrompt(event.systemPrompt, {
                 contextBrief,
-                identity,
+                identity: isDriver
+                    ? ultraHolder.get()
+                        ? YAGNI_IDENTITY_ULTRA
+                        : YAGNI_IDENTITY_DRIVER
+                    : undefined,
                 rulesSection,
             }),
         });
@@ -781,7 +793,9 @@ export { recordDecision } from "./recordDecisionTool.js";
 export { runInitPass, runTeamSetup, registerTeamSetupCommand, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
 // Onramp Door B (F2a): the one-time init-pass idempotency marker.
 export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
-export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, BRAND_NAME } from "./branding.js";
+export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA, BRAND_NAME } from "./branding.js";
+// Ultra mode (/ultra): the aggressive fan-out/verify/synthesize dial.
+export { createUltraHolder, registerUltraCommand } from "./ultra.js";
 export { attributionHeaders, isDriverCaller, fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl, sanitizeCallerSegment, } from "./config.js";
 export { buildYagniProvider } from "./provider.js";
 export { registerGoCommand } from "./pipeline/goCommand.js";
@@ -796,7 +810,7 @@ export { buildVerifyEnv, detectVerifyCommand, makeRunVerify, parseVerifyFailures
 export { blindStages, reportOnlyStages, makeGroundedVsBlindEval, formatComparisonReport } from "./pipeline/eval.js";
 export { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
 // The general subagent tool: Claude Code-format agent discovery + fan-out.
-export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
+export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, MAX_PARALLEL_SUBAGENTS_ULTRA, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
 // The session todo checklist: todo_write tool, widget renderer, /todos.
 export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, todoSummary, TODO_TOOL_NAME, MAX_TODOS, } from "./todos.js";
 // P3 + W4: the permission gate seam (decideGate is pure; policy injectable) plus

package/dist/extension/subagents.d.ts

@@ -20,11 +20,13 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { runStage } from "./pipeline/runner.js";
-import type { ModelTier, PipelineStage } from "./pipeline/types.js";
+import { type ModelTier, type PipelineStage } from "./pipeline/types.js";
 import { renderSubagentCall, renderSubagentResult } from "./subagentRender.js";
 export declare const SUBAGENT_TOOL_NAME = "subagent";
 export declare const GENERAL_AGENT_NAME = "general";
 export declare const MAX_PARALLEL_SUBAGENTS = 4;
+/** Wider fan-out ceiling while the session is in ultra mode (/ultra). */
+export declare const MAX_PARALLEL_SUBAGENTS_ULTRA = 8;
 /**
  * The default tool surface a subagent gets when its definition declares none:
  * the full working set plus grounded answers, mirroring what a Claude Code
@@ -92,6 +94,8 @@ export interface MakeSubagentToolDeps {
     runStageImpl?: typeof runStage;
     discover?: (deps: DiscoverDeps) => SubagentDef[];
     homeDir?: string;
+    /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
+    isUltra?: () => boolean;
 }
 export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
     name: string;
@@ -135,6 +139,8 @@ export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
 export interface RegisterSubagentsDeps {
     discover?: (deps: DiscoverDeps) => SubagentDef[];
     homeDir?: string;
+    /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
+    isUltra?: () => boolean;
 }
 /** Wire the subagent tool and the /agents listing command. */
 export declare function registerSubagents(pi: ExtensionAPI, deps?: RegisterSubagentsDeps): void;

package/dist/extension/subagents.js

@@ -23,7 +23,9 @@ import { delimiter, join } from "node:path";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { sanitizeCallerSegment } from "./config.js";
+import { withResilience } from "./pipeline/resilience.js";
 import { runStage } from "./pipeline/runner.js";
+import { DEFAULT_RESILIENCE_POLICY } from "./pipeline/types.js";
 import { applyChildEvent, finalizeTask, formatWorkingMessage, newTaskProgress, progressSummaryText, renderSubagentCall, renderSubagentResult, } from "./subagentRender.js";
 /**
  * YAG-471 attribution: the `x-yagni-caller` prefix for a subagent invocation.
@@ -34,6 +36,8 @@ const SUBAGENT_CALLER_PREFIX = "subagent:";
 export const SUBAGENT_TOOL_NAME = "subagent";
 export const GENERAL_AGENT_NAME = "general";
 export const MAX_PARALLEL_SUBAGENTS = 4;
+/** Wider fan-out ceiling while the session is in ultra mode (/ultra). */
+export const MAX_PARALLEL_SUBAGENTS_ULTRA = 8;
 /**
  * The default tool surface a subagent gets when its definition declares none:
  * the full working set plus grounded answers, mirroring what a Claude Code
@@ -123,6 +127,50 @@ const IMPLEMENTER_AGENT = {
     body: IMPLEMENTER_BODY,
     source: "builtin",
 };
+const VERIFICATION_BODY = `You are an adversarial verifier. Another agent
+produced work — a change, a plan, or a claim — and your job is to try to
+BREAK it, not to summarize it. Default to skepticism: hunt for the concrete
+failure scenario (the inputs, state, or sequence that makes it wrong). Bash
+is read-only here (\`git diff\`, \`git log\`, \`git show\`); do NOT modify files
+or run builds.
+
+If your task names a lens (correctness, edge cases, codebase fit, security,
+…), judge ONLY through that lens and leave the rest to your sibling
+verifiers.
+
+You are grounded in how THIS company works: call ask_yagni before inferring
+a convention, an ownership rule, or anything organization-specific.
+
+Your final message is your verdict back to the driving agent, which has NOT
+seen what you read. Format:
+## Verdict
+BROKEN or HOLDS, with one sentence why.
+## Findings
+Each real problem: file:line, the concrete failure scenario, severity. No
+style nits.
+## Not verified
+What you could not check, and why.
+
+A HOLDS after real digging is valuable; a rubber stamp is not. If you found
+nothing, say exactly what you tried to break and how.`;
+/** The diamond's reduce layer: refute-first review of completed work on the
+ * advanced tier (judgment is the whole job, so the premium is worth paying —
+ * the server clamps subagent children at advanced anyway). It has no
+ * edit/write tools; bash is included for `git diff`-style inspection and is
+ * restricted to read-only USE by the persona, the same prompt-level stance as
+ * /go's reviewer — not a technical guarantee. */
+const VERIFICATION_AGENT = {
+    name: "verification",
+    description: "Adversarial verification of completed work: tries to refute a change, " +
+        "plan, or claim and reports concrete failure scenarios. Does not edit " +
+        "files. Fan out 2-3 with different lenses (correctness, edge cases, " +
+        "codebase fit) for anything significant and treat agreement as " +
+        "confirmation.",
+    model: "advanced",
+    tools: ["read", "grep", "find", "ls", "bash", "ask_yagni"],
+    body: VERIFICATION_BODY,
+    source: "builtin",
+};
 // Concrete tiers a subagent can actually run on. `balanced` is deliberately NOT
 // a member here even though it is a member of `ModelTier`: a subagent needs
 // ONE model for its whole run, and balanced is a session-level routing policy,
@@ -210,7 +258,7 @@ function loadAgentsFromDir(dir, source) {
 export function discoverSubagents(deps) {
     const home = deps.homeDir ?? homedir();
     const layers = [
-        [GENERAL_AGENT, SEARCHER_AGENT, IMPLEMENTER_AGENT],
+        [GENERAL_AGENT, SEARCHER_AGENT, IMPLEMENTER_AGENT, VERIFICATION_AGENT],
         ...pluginAgentDirs(deps.env ?? process.env).map((dir) => loadAgentsFromDir(dir, "plugin")),
         loadAgentsFromDir(join(home, ".claude", "agents"), "user-claude"),
         loadAgentsFromDir(join(deps.cwd, ".pi", "agents"), "project-pi"),
@@ -261,11 +309,17 @@ const parameters = Type.Object({
         task: Type.String(),
         agent: Type.Optional(Type.String()),
     }), {
-        description: `Run several independent tasks in parallel (max ${MAX_PARALLEL_SUBAGENTS}). Use INSTEAD of task.`,
+        description: `Run several independent tasks in parallel (max ${MAX_PARALLEL_SUBAGENTS}; ${MAX_PARALLEL_SUBAGENTS_ULTRA} in ultra mode). Use INSTEAD of task.`,
     })),
 });
 export function makeSubagentTool(deps = {}) {
-    const run = deps.runStageImpl ?? runStage;
+    // The default runner rides the /go pipeline's resilience wrapper, so a chat
+    // subagent gets the same idle + wall-clock ceilings and transient-only retry
+    // as a /go stage child (previously a hung subagent hung the tool call until
+    // the user pressed Esc). The synthetic stage id is "implement", so the
+    // wrapper's write-gate already refuses to re-run a child that may have
+    // landed a partial edit.
+    const run = deps.runStageImpl ?? withResilience(runStage, DEFAULT_RESILIENCE_POLICY);
     const discover = deps.discover ?? discoverSubagents;
     return {
         name: SUBAGENT_TOOL_NAME,
@@ -293,8 +347,9 @@ export function makeSubagentTool(deps = {}) {
             if (requested.length === 0) {
                 return fail("Error: pass `task` (or a `tasks` array) describing what to do.");
             }
-            if (requested.length > MAX_PARALLEL_SUBAGENTS) {
-                return fail(`Error: at most ${MAX_PARALLEL_SUBAGENTS} parallel tasks per call.`);
+            const maxParallel = deps.isUltra?.() ? MAX_PARALLEL_SUBAGENTS_ULTRA : MAX_PARALLEL_SUBAGENTS;
+            if (requested.length > maxParallel) {
+                return fail(`Error: at most ${maxParallel} parallel tasks per call.`);
             }
             const cwd = ctx?.cwd ?? process.cwd();
             const agents = discover({ cwd, homeDir: deps.homeDir });

package/dist/extension/ultra.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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, read live per turn in index.ts) and widens the
+ * subagent tool's per-call fan-out ceiling (subagents.ts). 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,61 @@
+/**
+ * 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, read live per turn in index.ts) and widens the
+ * subagent tool's per-call fan-out ceiling (subagents.ts). 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.";
+/**
+ * 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.
+            }
+            notify(next ? ULTRA_ON_COPY : ULTRA_OFF_COPY, "info");
+        },
+    });
+}
+//# sourceMappingURL=ultra.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.3.0-staging.1082.1",
+  "version": "0.3.0-staging.1088.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -38,5 +38,5 @@
     "@earendil-works/pi-tui": "0.84.1",
     "typebox": "^1.3.11"
   },
-  "yagniSourceSha": "a1967e7624f741b033c68d83acd29b3a47262b7c"
+  "yagniSourceSha": "eebceee1a0d1673dd4b2755942aa027a89f18611"
 }