@yagni-app/code-staging 1.1.5-staging.1430.1 → 1.1.5-staging.1434.1

package/dist/extension/subagentRender.d.ts

@@ -8,10 +8,15 @@
  * 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
+ * `renderResult`). pi paints the call component above the result component
+ * for the life of the row, so the two split the work: the call header lists
+ * the tasks only while the arguments stream in, and hands off to the result
+ * rows the moment execution starts (the tool's first partial update fires at
+ * spawn). 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
+ * receipt (`✓ agent · N tool uses · Xk tokens · Ys`) over a dim task line;
+ * 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.
@@ -116,8 +121,28 @@ 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;
+/** The slice of pi's ToolRenderContext the call renderer reads. */
+interface CallContextSlice {
+    /** True from the moment pi invokes `execute` (tool-execution.ts re-renders the call on the flip). */
+    executionStarted?: boolean;
+    /**
+     * True from construction until a FINAL result lands. A row rebuilt from
+     * session history on resume never has `executionStarted` flipped (pi only
+     * marks it on the live tool_execution_start event) but does carry its final
+     * result, so this is the signal that keeps a replayed row from listing twice.
+     */
+    isPartial?: boolean;
+}
+/**
+ * Title painted the moment the call streams in. While the model is still
+ * writing the arguments this is the only preview of what is being delegated,
+ * so it lists every task. Once execution starts (or, on a replayed row, once
+ * the final result is present) the result renderer paints a row per task
+ * (live line, then receipt) directly beneath, so the header collapses to its
+ * title line — otherwise every agent was listed twice, once here and once in
+ * the result, for the whole life of the call.
+ */
+export declare function renderSubagentCall(args: SubagentCallArgs | undefined, theme: RenderTheme, context: CallContextSlice | undefined): 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

package/dist/extension/subagentRender.js

@@ -8,10 +8,15 @@
  * 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
+ * `renderResult`). pi paints the call component above the result component
+ * for the life of the row, so the two split the work: the call header lists
+ * the tasks only while the arguments stream in, and hands off to the result
+ * rows the moment execution starts (the tool's first partial update fires at
+ * spawn). 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
+ * receipt (`✓ agent · N tool uses · Xk tokens · Ys`) over a dim task line;
+ * 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.
@@ -226,6 +231,14 @@ export function receiptLine(p, theme) {
     }
     return `${theme.fg("success", "✓")} ${name} ${theme.fg("dim", `· ${parts.join(" · ")}`)}`;
 }
+/**
+ * The dim task line under a receipt. Once execution starts the call header
+ * no longer lists the tasks (see {@link renderSubagentCall}), so the receipt
+ * is the only place the reader can tell two same-named agents apart.
+ */
+function taskLine(p, theme) {
+    return theme.fg("dim", `  ${clip(p.task, 2 * TASK_PREVIEW_MAX)}`);
+}
 /** Aggregate receipt across parallel tasks. */
 function totalLine(tasks, theme) {
     const toolCalls = tasks.reduce((n, p) => n + p.toolCalls, 0);
@@ -262,19 +275,31 @@ export function formatWorkingMessage(tasks, now) {
     const label = running > 0 && running < tasks.length ? `${running}/${tasks.length} subagents` : `${tasks.length} subagents`;
     return `${label} · ${countToolUses(toolCalls)} · ${elapsed}`;
 }
-/** Title painted the moment the call streams in (before any execution output). */
-export function renderSubagentCall(args, theme, _context) {
+/**
+ * Title painted the moment the call streams in. While the model is still
+ * writing the arguments this is the only preview of what is being delegated,
+ * so it lists every task. Once execution starts (or, on a replayed row, once
+ * the final result is present) the result renderer paints a row per task
+ * (live line, then receipt) directly beneath, so the header collapses to its
+ * title line — otherwise every agent was listed twice, once here and once in
+ * the result, for the whole life of the call.
+ */
+export function renderSubagentCall(args, theme, context) {
     const title = theme.fg("toolTitle", theme.bold("subagent"));
     const a = args ?? {};
+    const resultOwnsRows = context?.executionStarted === true || context?.isPartial === false;
+    const listTasks = !resultOwnsRows;
     if (a.tasks && a.tasks.length > 0) {
         let text = `${title} ${theme.fg("accent", `${a.tasks.length} parallel tasks`)}`;
-        for (const t of a.tasks) {
-            text += `\n  ${theme.fg("accent", t.agent ?? "general")} ${theme.fg("dim", clip(t.task ?? "…", TASK_PREVIEW_MAX))}`;
+        if (listTasks) {
+            for (const t of a.tasks) {
+                text += `\n  ${theme.fg("accent", t.agent ?? "general")} ${theme.fg("dim", clip(t.task ?? "…", TASK_PREVIEW_MAX))}`;
+            }
         }
         return new Text(text, 0, 0);
     }
     let text = `${title} ${theme.fg("accent", a.agent ?? "general")}`;
-    if (a.task)
+    if (listTasks && a.task)
         text += `\n  ${theme.fg("dim", clip(a.task, 2 * TASK_PREVIEW_MAX))}`;
     return new Text(text, 0, 0);
 }
@@ -393,7 +418,7 @@ export function renderSubagentResult(result, options, theme, context) {
             if (p.status === "running")
                 lines.push(...runningLines(p, theme, now, frame));
             else
-                lines.push(receiptLine(p, theme));
+                lines.push(receiptLine(p, theme), taskLine(p, theme));
             if (options.expanded)
                 lines.push(...actionLogLines(p, theme, EXPANDED_ACTIONS_SHOWN));
         }
@@ -405,7 +430,7 @@ export function renderSubagentResult(result, options, theme, context) {
             if (i > 0)
                 container.addChild(new Spacer(1));
             container.addChild(new Text(receiptLine(p, theme), 0, 0));
-            container.addChild(new Text(theme.fg("dim", `  ${clip(p.task, 2 * TASK_PREVIEW_MAX)}`), 0, 0));
+            container.addChild(new Text(taskLine(p, theme), 0, 0));
             if (p.errorMessage)
                 container.addChild(new Text(theme.fg("error", `  ${clip(p.errorMessage, 200)}`), 0, 0));
             const log = actionLogLines(p, theme, EXPANDED_ACTIONS_SHOWN);
@@ -423,13 +448,13 @@ export function renderSubagentResult(result, options, theme, context) {
         }
         return container;
     }
-    // Collapsed, final: receipts + a short report preview per task.
+    // Collapsed, final: receipt + task + a short report preview per task.
     const lines = [];
     let truncated = false;
     for (const p of tasks) {
         if (lines.length > 0)
             lines.push("");
-        lines.push(receiptLine(p, theme));
+        lines.push(receiptLine(p, theme), taskLine(p, theme));
         if (p.errorMessage)
             lines.push(theme.fg("error", `  ${clip(p.errorMessage, 160)}`));
         const report = (p.report ?? "").trim();

package/dist/extension/subagents.d.ts

@@ -132,11 +132,26 @@ export interface MakeSubagentToolDeps {
     childUsage?: ChildUsageHandle;
 }
 /**
- * The subagent lane's resilience policy: the /go defaults, except a wall-
- * clock exhaustion is NOT retried (a 20-minute burn means the task is too
- * big — fail honestly instead of re-burning it per attempt; idle stalls stay
- * retryable). Exported so a test can pin the composed policy the production
- * path actually runs (every unit test injects runStageImpl instead).
+ * The subagent lane's wall-clock ceiling: two hours per child.
+ *
+ * The /go stage default (20 minutes) is sized for one pipeline step; a chat
+ * subagent is routinely handed a whole review, and at 20 minutes the runner
+ * killed three parallel reviewers mid-report and threw their findings away
+ * as "PARTIAL output". The wall clock is not the stall guard — the idle timer
+ * (4 minutes, deferred while a tool is in flight) is what catches a hung
+ * child — it only bounds a runaway that keeps emitting events, so it can be
+ * generous. Two hours is above what a child's context window sustains in
+ * practice, so it is effectively "let the task finish" while still bounding
+ * spend at roughly $20 per child on the mix that burned $2 in 20 minutes.
+ */
+export declare const SUBAGENT_WALL_TIMEOUT_MS: number;
+/**
+ * The subagent lane's resilience policy: the /go defaults, except the wall
+ * clock is the lane's own ({@link SUBAGENT_WALL_TIMEOUT_MS}) and a wall-clock
+ * exhaustion is NOT retried (a two-hour burn means the task is too big — fail
+ * honestly instead of re-burning it per attempt; idle stalls stay retryable).
+ * Exported so a test can pin the composed policy the production path actually
+ * runs (every unit test injects runStageImpl instead).
  */
 export declare function subagentRunPolicy(): ResiliencePolicy;
 /**

package/dist/extension/subagents.js

@@ -463,14 +463,29 @@ const parameters = Type.Object({
     })),
 });
 /**
- * The subagent lane's resilience policy: the /go defaults, except a wall-
- * clock exhaustion is NOT retried (a 20-minute burn means the task is too
- * big — fail honestly instead of re-burning it per attempt; idle stalls stay
- * retryable). Exported so a test can pin the composed policy the production
- * path actually runs (every unit test injects runStageImpl instead).
+ * The subagent lane's wall-clock ceiling: two hours per child.
+ *
+ * The /go stage default (20 minutes) is sized for one pipeline step; a chat
+ * subagent is routinely handed a whole review, and at 20 minutes the runner
+ * killed three parallel reviewers mid-report and threw their findings away
+ * as "PARTIAL output". The wall clock is not the stall guard — the idle timer
+ * (4 minutes, deferred while a tool is in flight) is what catches a hung
+ * child — it only bounds a runaway that keeps emitting events, so it can be
+ * generous. Two hours is above what a child's context window sustains in
+ * practice, so it is effectively "let the task finish" while still bounding
+ * spend at roughly $20 per child on the mix that burned $2 in 20 minutes.
+ */
+export const SUBAGENT_WALL_TIMEOUT_MS = 2 * 60 * 60_000;
+/**
+ * The subagent lane's resilience policy: the /go defaults, except the wall
+ * clock is the lane's own ({@link SUBAGENT_WALL_TIMEOUT_MS}) and a wall-clock
+ * exhaustion is NOT retried (a two-hour burn means the task is too big — fail
+ * honestly instead of re-burning it per attempt; idle stalls stay retryable).
+ * Exported so a test can pin the composed policy the production path actually
+ * runs (every unit test injects runStageImpl instead).
  */
 export function subagentRunPolicy() {
-    return { ...DEFAULT_RESILIENCE_POLICY, retryWallTimeout: false };
+    return { ...DEFAULT_RESILIENCE_POLICY, wallTimeoutMs: SUBAGENT_WALL_TIMEOUT_MS, retryWallTimeout: false };
 }
 /**
  * The per-attempt telemetry adapter: one content-free error-sink row per
@@ -499,13 +514,14 @@ export function subagentTelemetry(env) {
 }
 export function makeSubagentTool(deps = {}) {
     // 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). Two subagent-specific knobs ride the wrapper:
-    // retryWallTimeout=false (a 20-minute burn means the task is too big — fail
-    // honestly instead of re-burning it per attempt) and per-attempt telemetry
-    // into the error sink (a subagent failure previously left NO trace outside
-    // the tool result text). The write-gate keys on the resolved agent's tools,
+    // subagent gets the same idle ceiling and transient-only retry as a /go
+    // stage child (previously a hung subagent hung the tool call until the user
+    // pressed Esc). Three subagent-specific knobs ride the wrapper: the lane's
+    // own two-hour wall clock (SUBAGENT_WALL_TIMEOUT_MS), retryWallTimeout=false
+    // (a wall burn means the task is too big — fail honestly instead of
+    // re-burning it per attempt) and per-attempt telemetry into the error sink
+    // (a subagent failure previously left NO trace outside the tool result
+    // text). The write-gate keys on the resolved agent's tools,
     // passed per task below — the synthetic stage id is "implement" and would
     // otherwise block retry of a read-only verifier forever.
     const run = deps.runStageImpl ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.5-staging.1430.1",
+  "version": "1.1.5-staging.1434.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)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "7bf0c4f8abf9d498530dbe1eace8dfe901a3ad11"
+  "yagniSourceSha": "04f866e8c724b482892ee608ca484ae2779c55ba"
 }