@yagni-app/code 1.0.0 → 1.0.2

package/dist/extension/subagents.d.ts

@@ -19,6 +19,8 @@
  */
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import type { ChildUsageHandle } from "./childUsage.js";
+import type { WorkingLineHandle } from "./workingLine.js";
 import { runStage } from "./pipeline/runner.js";
 import { type ModelTier, type PipelineStage } from "./pipeline/types.js";
 import { renderSubagentCall, renderSubagentResult } from "./subagentRender.js";
@@ -96,6 +98,19 @@ export interface MakeSubagentToolDeps {
     homeDir?: string;
     /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
     isUltra?: () => boolean;
+    /**
+     * The session working-line manager (workingLine.ts). When present, live
+     * progress goes through it (so the elapsed/token suffix survives); absent,
+     * the tool falls back to setting ui.setWorkingMessage directly.
+     */
+    workingLine?: WorkingLineHandle;
+    /**
+     * Session child-usage accumulator (childUsage.ts). Each completed task's
+     * folded usage is recorded so the footer's session totals include the
+     * child spend the per-task receipt already prints. Absent = not wired
+     * (headless/eval harnesses): no recording, nothing else changes.
+     */
+    childUsage?: ChildUsageHandle;
 }
 export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
     name: string;
@@ -110,9 +125,10 @@ export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
             agent: Type.TOptional<Type.TString>;
         }>>>;
     }>;
+    renderShell: "self";
     renderCall: typeof renderSubagentCall;
     renderResult: typeof renderSubagentResult;
-    execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: (update: {
+    execute(toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: (update: {
         content: Array<{
             type: "text";
             text: string;
@@ -141,6 +157,10 @@ export interface RegisterSubagentsDeps {
     homeDir?: string;
     /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
     isUltra?: () => boolean;
+    /** Session working-line manager; see MakeSubagentToolDeps.workingLine. */
+    workingLine?: WorkingLineHandle;
+    /** Session child-usage accumulator; see MakeSubagentToolDeps.childUsage. */
+    childUsage?: ChildUsageHandle;
 }
 /** Wire the subagent tool and the /agents listing command. */
 export declare function registerSubagents(pi: ExtensionAPI, deps?: RegisterSubagentsDeps): void;

package/dist/extension/subagents.js

@@ -33,6 +33,17 @@ import { applyChildEvent, finalizeTask, formatWorkingMessage, newTaskProgress, p
  * within the model proxy's 64-char caller-label limit.
  */
 const SUBAGENT_CALLER_PREFIX = "subagent:";
+/**
+ * Dedupe key for one task's childUsage record. Neither `startedAt` (parallel
+ * tasks on the same agent are minted in the same `resolved.map` pass and can
+ * share a millisecond) nor the per-invocation index (every invocation starts
+ * at 0) is unique alone; the pair is, because one tool call's task set is
+ * minted exactly once. A re-fired finalize for the same record lands on the
+ * same key, so the accumulator's (source, key) dedupe makes it a no-op.
+ */
+function progressKey(toolCallId, p, index) {
+    return `${toolCallId}/${index}/${p.agent}@${p.startedAt}`;
+}
 export const SUBAGENT_TOOL_NAME = "subagent";
 export const GENERAL_AGENT_NAME = "general";
 export const MAX_PARALLEL_SUBAGENTS = 4;
@@ -74,7 +85,7 @@ You are grounded in how THIS company works: call ask_yagni before inferring a co
 
 Never fabricate file paths, contents, or findings. If you cannot find something, say so.
 
-Your final message is your report back to the driving agent, which has NOT seen what you read or did. Make it compressed and complete: what you did, what you found, exact file paths and key excerpts, and anything the driver must know before continuing.`;
+Complete the task fully — do not gold-plate, but do not leave it half-done. Your final message is your report back to the driving agent, which has NOT seen what you read or did: make it a concise report of what was done and the key findings, since the caller relays it to the user and it only needs the essentials. Cover what you did, what you found, exact file paths and key excerpts, and anything the driver must know before continuing.`;
 const GENERAL_AGENT = {
     name: GENERAL_AGENT_NAME,
     description: "General-purpose agent for research, multi-file changes, and self-contained tasks.",
@@ -94,6 +105,8 @@ one you actually read with a tool. If you cannot find something, say "not
 found" — a plausible-sounding invention is worse than no answer because the
 driving agent trusts your report.
 
+Complete the task fully — do not gold-plate, but do not leave it half-done.
+
 Your final message is your report back to the driving agent, which has NOT
 seen what you read. Make it compressed and complete: exact file paths, the
 key excerpts, and a one-paragraph map of how the pieces relate. Say what you
@@ -122,6 +135,8 @@ convention, an ownership rule, or anything organization-specific.
 Never fabricate file paths or results. Report what you actually did and what
 you actually found.
 
+Complete the task fully — do not gold-plate, but do not leave it half-done.
+
 Your final message is your report back to the driving agent, which has NOT
 seen what you did. List every file you touched, what changed in each, the
 commands you ran with their outcomes, and anything you deliberately left
@@ -154,6 +169,8 @@ a convention, an ownership rule, or anything organization-specific.
 Never fabricate file paths or findings. If you could not verify something,
 say exactly what you tried and why you could not.
 
+Complete the task fully — do not gold-plate, but do not leave it half-done.
+
 Your final message is your verdict back to the driving agent, which has NOT
 seen what you read. Format:
 ## Verdict
@@ -344,9 +361,11 @@ export function makeSubagentTool(deps = {}) {
             "(list them with /agents); omit `agent` for the general-purpose one.",
         promptSnippet: "subagent: delegate a self-contained task (or parallel tasks) to a fresh-context agent; returns its report.",
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall: renderSubagentCall,
         renderResult: renderSubagentResult,
-        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
             const fail = (text) => ({
                 content: [{ type: "text", text }],
                 details: {},
@@ -391,9 +410,12 @@ export function makeSubagentTool(deps = {}) {
                     },
                 });
                 const working = formatWorkingMessage(progresses, now);
-                if (ui && working !== lastWorking) {
+                if (working !== lastWorking) {
                     lastWorking = working;
-                    ui.setWorkingMessage?.(working);
+                    if (deps.workingLine)
+                        deps.workingLine.setActivity(working);
+                    else
+                        ui?.setWorkingMessage?.(working);
                 }
             };
             emit();
@@ -417,13 +439,20 @@ export function makeSubagentTool(deps = {}) {
                         },
                     });
                     finalizeTask(progress, result, Date.now());
+                    // Record the child's spend into the session accumulator so the
+                    // footer totals include it (dedupe key: this progress record's
+                    // identity — per invocation, so parallel tasks never collide).
+                    deps.childUsage?.record("subagent", progressKey(toolCallId, progress, index), result.usage);
                     emit();
                     return { agent: def.name, task, result };
                 }));
             }
             finally {
                 // Restore the default "Working…" text whether we resolved or threw.
-                ui?.setWorkingMessage?.();
+                if (deps.workingLine)
+                    deps.workingLine.setActivity(undefined);
+                else
+                    ui?.setWorkingMessage?.();
             }
             const allFailed = outcomes.every((o) => o.result.exitCode !== 0);
             const sections = outcomes.map((o) => {

package/dist/extension/todos.d.ts

@@ -105,6 +105,7 @@ export declare function makeTodoTool(get: () => TodoItem[], set: (todos: TodoIte
     label: string;
     description: string;
     promptSnippet: string;
+    promptGuidelines: string[];
     parameters: Type.TObject<{
         todos: Type.TArray<Type.TObject<{
             text: Type.TString;

package/dist/extension/todos.js

@@ -204,6 +204,21 @@ export function makeTodoTool(get, set) {
             "in_progress at a time, mark items completed the moment they are done, and add newly " +
             "discovered steps as pending. Use it for any task with three or more steps, updating as you go.",
         promptSnippet: "todo_write: keep a user-visible checklist for multi-step work (full-list replacement).",
+        promptGuidelines: [
+            "Use todo_write proactively when a task needs 3 or more distinct steps, requires careful " +
+                "planning, or the user gives you a list of things (numbered or comma-separated).",
+            "Capture new instructions as todos the moment you receive them, and mark a step in_progress " +
+                "BEFORE you start working on it.",
+            "When in doubt, use it — a visible checklist answers \"is it stuck?\" without the user having " +
+                "to interrupt.",
+            "Skip it when there is only one straightforward task, the work is trivial, or the request is " +
+                "purely conversational or informational — in those cases just do the task directly.",
+            "Pass the FULL list every call; it replaces the previous one. Keep exactly ONE item in_progress " +
+                "at a time.",
+            "Mark a step completed the moment it is done (do not batch completions), and add newly " +
+                "discovered steps as pending. Only mark a step completed when it is fully done — if tests " +
+                "fail or work is partial, leave it in_progress and add a new step for the blocker.",
+        ],
         parameters,
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const normalized = normalizeTodos(params.todos);

package/dist/extension/toolRuns.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Run model for the condensed tool transcript (Claude Code-style).
+ *
+ * A "run" is a maximal stretch of consecutive QUIET tool rows (reads, searches,
+ * listings, successful shell commands, scratchpad edits) uninterrupted by an
+ * assistant/user message or a visible row (errors, project writes/edits, image
+ * reads). Collapsed, every row in a completed run renders zero lines except the
+ * run's tail, which paints one summary line: "Read 2 files, ran 2 shell
+ * commands". Expanded (ctrl+o) bypasses this model entirely.
+ *
+ * The tracker is built purely from render calls (idempotent upserts keyed by
+ * toolCallId, in first-render order, which matches display order both live and
+ * on session replay). Message boundaries arrive via {@link ToolRunTracker.markBreak}
+ * from live `message_start` events only — after a resume, runs that were
+ * separated by prose may merge into one summary. That is a deliberate trade:
+ * render-derived state is the only state that survives replay.
+ *
+ * Everything here is PURE (no pi imports) so tests run against plain objects;
+ * the pi wiring lives in condensedTools.ts.
+ */
+/** Aggregation category of one tool row. */
+export type RowKind = "read" | "shell" | "search" | "list" | "write" | "edit";
+/** Facts about one tool row; `quiet` is derived, never stored. */
+export interface ToolRow {
+    id: string;
+    kind: RowKind;
+    /** The row's target path lives under the session scratchpad dir. */
+    scratchpad: boolean;
+    /** The tool call errored (visible regardless of kind). */
+    error: boolean;
+    /** The result carries inline images (a read screenshot must stay visible). */
+    images: boolean;
+    /** The result is final (not partial/streaming). */
+    final: boolean;
+    /** Added lines (scratchpad edits surface as "+N" in the summary). */
+    added: number;
+    /** An assistant/user message landed between the previous row and this one. */
+    breakBefore: boolean;
+    /** Repaint hook for this row's component (captured from the render context). */
+    invalidate?: () => void;
+    /** A deferred repaint is already queued for this row. */
+    invalidatePending?: boolean;
+}
+export type ToolRowPatch = Partial<Pick<ToolRow, "kind" | "scratchpad" | "error" | "images" | "final" | "added" | "invalidate">>;
+/** Aggregation kind for a built-in tool name (undefined for non-built-ins). */
+export declare function kindForTool(toolName: string): RowKind | undefined;
+/**
+ * Whether a row folds into a run summary. Reads, searches, listings, and
+ * successful shell commands always do; writes/edits only when they target the
+ * scratchpad (project mutations must stay visible). Errors and image-bearing
+ * results are always visible.
+ */
+export declare function isQuiet(row: Pick<ToolRow, "kind" | "scratchpad" | "error" | "images">): boolean;
+/**
+ * One summary line for a completed run, phrases in first-occurrence order:
+ * "Read 2 files, ran 2 shell commands, made 1 scratchpad edit +20".
+ */
+export declare function summarizeRun(rows: readonly Pick<ToolRow, "kind" | "scratchpad" | "added">[]): string;
+/**
+ * Ordered row registry. Upserts are idempotent and diff-aware: only a change
+ * invalidates the affected run's tail (the one component whose output depends
+ * on neighbors), so repaints converge instead of looping.
+ */
+export declare class ToolRunTracker {
+    private rows;
+    private indexById;
+    private breakPending;
+    /** Record an assistant/user message boundary; the next new row starts a fresh run. */
+    markBreak(): void;
+    get(id: string): ToolRow | undefined;
+    upsert(id: string, patch: ToolRowPatch): ToolRow;
+    /**
+     * The one summary line for `id`, present only when `id` is the tail of a
+     * fully-final quiet run. Every other member of the run gets undefined.
+     */
+    summaryFor(id: string): string | undefined;
+    /** The contiguous quiet run containing `row` (just `[row]` when visible). */
+    private runOf;
+    private invalidateTailOf;
+    /**
+     * Defer a row's repaint to a microtask, deduped per row. Upserts run INSIDE
+     * pi's synchronous `updateDisplay` pass (renderers call them), and the
+     * component's `invalidate()` re-enters `updateDisplay` immediately — a
+     * synchronous call from a renderer would rebuild the container while the
+     * outer frame is still appending to it, stacking duplicate children.
+     * Deferring means every repaint runs as its own clean top-level pass; it
+     * still cannot loop, because the diff-aware upsert only schedules on an
+     * actual change.
+     */
+    private scheduleInvalidate;
+}
+//# sourceMappingURL=toolRuns.d.ts.map

package/dist/extension/toolRuns.js

@@ -0,0 +1,201 @@
+/**
+ * Run model for the condensed tool transcript (Claude Code-style).
+ *
+ * A "run" is a maximal stretch of consecutive QUIET tool rows (reads, searches,
+ * listings, successful shell commands, scratchpad edits) uninterrupted by an
+ * assistant/user message or a visible row (errors, project writes/edits, image
+ * reads). Collapsed, every row in a completed run renders zero lines except the
+ * run's tail, which paints one summary line: "Read 2 files, ran 2 shell
+ * commands". Expanded (ctrl+o) bypasses this model entirely.
+ *
+ * The tracker is built purely from render calls (idempotent upserts keyed by
+ * toolCallId, in first-render order, which matches display order both live and
+ * on session replay). Message boundaries arrive via {@link ToolRunTracker.markBreak}
+ * from live `message_start` events only — after a resume, runs that were
+ * separated by prose may merge into one summary. That is a deliberate trade:
+ * render-derived state is the only state that survives replay.
+ *
+ * Everything here is PURE (no pi imports) so tests run against plain objects;
+ * the pi wiring lives in condensedTools.ts.
+ */
+const KIND_BY_TOOL = {
+    read: "read",
+    bash: "shell",
+    grep: "search",
+    find: "list",
+    ls: "list",
+    write: "write",
+    edit: "edit",
+};
+/** Aggregation kind for a built-in tool name (undefined for non-built-ins). */
+export function kindForTool(toolName) {
+    return KIND_BY_TOOL[toolName];
+}
+/**
+ * Whether a row folds into a run summary. Reads, searches, listings, and
+ * successful shell commands always do; writes/edits only when they target the
+ * scratchpad (project mutations must stay visible). Errors and image-bearing
+ * results are always visible.
+ */
+export function isQuiet(row) {
+    if (row.error || row.images)
+        return false;
+    if (row.kind === "write" || row.kind === "edit")
+        return row.scratchpad;
+    return true;
+}
+function plural(n, singular, pluralForm = `${singular}s`) {
+    return n === 1 ? singular : pluralForm;
+}
+/**
+ * One summary line for a completed run, phrases in first-occurrence order:
+ * "Read 2 files, ran 2 shell commands, made 1 scratchpad edit +20".
+ */
+export function summarizeRun(rows) {
+    const order = [];
+    const counts = new Map();
+    for (const row of rows) {
+        const category = row.kind === "write" || row.kind === "edit" ? "scratch" : row.kind;
+        let entry = counts.get(category);
+        if (!entry) {
+            entry = { n: 0, added: 0 };
+            counts.set(category, entry);
+            order.push(category);
+        }
+        entry.n += 1;
+        entry.added += row.added;
+    }
+    const phrases = order.map((category) => {
+        const { n, added } = counts.get(category);
+        switch (category) {
+            case "read":
+                return `read ${n} ${plural(n, "file")}`;
+            case "shell":
+                return `ran ${n} shell ${plural(n, "command")}`;
+            case "search":
+                return `searched for ${n} ${plural(n, "pattern")}`;
+            case "list":
+                return `listed ${n} ${plural(n, "path")}`;
+            default:
+                return `made ${n} scratchpad ${plural(n, "edit")}${added > 0 ? ` +${added}` : ""}`;
+        }
+    });
+    const line = phrases.join(", ");
+    return line.charAt(0).toUpperCase() + line.slice(1);
+}
+/**
+ * Ordered row registry. Upserts are idempotent and diff-aware: only a change
+ * invalidates the affected run's tail (the one component whose output depends
+ * on neighbors), so repaints converge instead of looping.
+ */
+export class ToolRunTracker {
+    rows = [];
+    indexById = new Map();
+    breakPending = true;
+    /** Record an assistant/user message boundary; the next new row starts a fresh run. */
+    markBreak() {
+        this.breakPending = true;
+    }
+    get(id) {
+        const i = this.indexById.get(id);
+        return i === undefined ? undefined : this.rows[i];
+    }
+    upsert(id, patch) {
+        const existingIndex = this.indexById.get(id);
+        if (existingIndex === undefined) {
+            const row = {
+                id,
+                kind: patch.kind ?? "shell",
+                scratchpad: patch.scratchpad ?? false,
+                error: patch.error ?? false,
+                images: patch.images ?? false,
+                final: patch.final ?? false,
+                added: patch.added ?? 0,
+                breakBefore: this.breakPending,
+                ...(patch.invalidate ? { invalidate: patch.invalidate } : {}),
+            };
+            this.breakPending = false;
+            this.indexById.set(id, this.rows.length);
+            this.rows.push(row);
+            // The previous row may have been its run's tail (painting a summary);
+            // now that the run extends past it, repaint it as a hidden member.
+            // (invalidateTailOf(prev) would be wrong here: prev's run now includes
+            // this new row, so its tail is the row currently painting, not prev.)
+            const prev = this.rows[this.rows.length - 2];
+            if (prev && isQuiet(prev) && !row.breakBefore)
+                this.scheduleInvalidate(prev);
+            return row;
+        }
+        const row = this.rows[existingIndex];
+        if (patch.invalidate)
+            row.invalidate = patch.invalidate;
+        let changed = false;
+        for (const key of ["kind", "scratchpad", "error", "images", "final", "added"]) {
+            const next = patch[key];
+            if (next !== undefined && row[key] !== next) {
+                row[key] = next;
+                changed = true;
+            }
+        }
+        if (changed)
+            this.invalidateTailOf(row);
+        return row;
+    }
+    /**
+     * The one summary line for `id`, present only when `id` is the tail of a
+     * fully-final quiet run. Every other member of the run gets undefined.
+     */
+    summaryFor(id) {
+        const row = this.get(id);
+        if (!row || !isQuiet(row) || !row.final)
+            return undefined;
+        const run = this.runOf(row);
+        if (run[run.length - 1] !== row)
+            return undefined;
+        if (run.some((r) => !r.final))
+            return undefined;
+        return summarizeRun(run);
+    }
+    /** The contiguous quiet run containing `row` (just `[row]` when visible). */
+    runOf(row) {
+        if (!isQuiet(row))
+            return [row];
+        const i = this.indexById.get(row.id);
+        let start = i;
+        while (start > 0 && !this.rows[start].breakBefore && isQuiet(this.rows[start - 1]))
+            start--;
+        let end = i;
+        while (end < this.rows.length - 1 &&
+            !this.rows[end + 1].breakBefore &&
+            isQuiet(this.rows[end + 1])) {
+            end++;
+        }
+        return this.rows.slice(start, end + 1);
+    }
+    invalidateTailOf(row) {
+        const run = this.runOf(row);
+        const tail = run[run.length - 1];
+        if (tail)
+            this.scheduleInvalidate(tail);
+    }
+    /**
+     * Defer a row's repaint to a microtask, deduped per row. Upserts run INSIDE
+     * pi's synchronous `updateDisplay` pass (renderers call them), and the
+     * component's `invalidate()` re-enters `updateDisplay` immediately — a
+     * synchronous call from a renderer would rebuild the container while the
+     * outer frame is still appending to it, stacking duplicate children.
+     * Deferring means every repaint runs as its own clean top-level pass; it
+     * still cannot loop, because the diff-aware upsert only schedules on an
+     * actual change.
+     */
+    scheduleInvalidate(row) {
+        if (row.invalidatePending)
+            return;
+        row.invalidatePending = true;
+        queueMicrotask(() => {
+            row.invalidatePending = false;
+            row.invalidate?.();
+        });
+    }
+}
+//# sourceMappingURL=toolRuns.js.map

package/dist/extension/webFetchTool.js

@@ -44,6 +44,8 @@ export function makeWebFetchTool(opts) {
             "Use web_fetch to read a URL's content instead of bash + curl when you need a page or a summary of it.",
         ],
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall(args, theme) {
             const t = theme;
             const url = clipLine(args?.url ?? "…", 80);

package/dist/extension/workingLine.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** What subagents/advisor publish instead of calling setWorkingMessage. */
+export interface WorkingLineHandle {
+    setActivity(text?: string): void;
+}
+/** A no-op handle for callers wired without a manager (tests, children). */
+export declare const NULL_WORKING_LINE: WorkingLineHandle;
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export declare const WORKING_VERBS: readonly string[];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export declare const WORKING_INDICATOR_FRAMES: string[];
+export interface ComposeWorkingOpts {
+    /** Override head from a running subagent/advisor (verb used when absent). */
+    activity?: string | undefined;
+    verb: string;
+    elapsedMs: number;
+    outputTokens: number;
+}
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export declare function composeWorkingMessage(opts: ComposeWorkingOpts): string;
+export interface RegisterWorkingLineDeps {
+    now?: () => number;
+    pickVerb?: (verbs: readonly string[]) => string;
+    /** Refresh cadence for the elapsed clock. */
+    tickMs?: number;
+}
+export declare function registerWorkingLine(pi: ExtensionAPI, deps?: RegisterWorkingLineDeps): WorkingLineHandle;
+//# sourceMappingURL=workingLine.d.ts.map

package/dist/extension/workingLine.js

@@ -0,0 +1,116 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import { usageFromMessage } from "./costHud.js";
+import { formatDuration, formatTokens } from "./subagentRender.js";
+/** A no-op handle for callers wired without a manager (tests, children). */
+export const NULL_WORKING_LINE = { setActivity: () => { } };
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export const WORKING_VERBS = [
+    "Working",
+    "Thinking",
+    "Exploring",
+    "Tracing",
+    "Shaping",
+    "Wiring",
+    "Weighing",
+    "Sketching",
+    "Assembling",
+    "Distilling",
+    "Untangling",
+    "Polishing",
+];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export const WORKING_INDICATOR_FRAMES = ["·", "✢", "✳", "✶", "✳", "✢"];
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export function composeWorkingMessage(opts) {
+    const head = opts.activity ?? `${opts.verb}…`;
+    const stats = [
+        formatDuration(opts.elapsedMs),
+        opts.outputTokens > 0 ? `↓ ${formatTokens(opts.outputTokens)} tokens` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return `${head} (${stats})`;
+}
+export function registerWorkingLine(pi, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const pickVerb = deps.pickVerb ?? ((verbs) => verbs[Math.floor(Math.random() * verbs.length)]);
+    const tickMs = deps.tickMs ?? 1_000;
+    let ui;
+    let timer;
+    let startedAt;
+    let outputTokens = 0;
+    let verb = WORKING_VERBS[0];
+    let activity;
+    const refresh = () => {
+        if (!ui || startedAt === undefined)
+            return;
+        try {
+            ui.setWorkingMessage?.(composeWorkingMessage({ activity, verb, elapsedMs: now() - startedAt, outputTokens }));
+        }
+        catch {
+            // The status line must never break a turn.
+        }
+    };
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        startedAt = undefined;
+        activity = undefined;
+        try {
+            ui?.setWorkingMessage?.();
+        }
+        catch {
+            // Restoring the default label is best-effort.
+        }
+    };
+    pi.on("agent_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        ui = ctx.ui;
+        startedAt = now();
+        outputTokens = 0;
+        activity = undefined;
+        verb = pickVerb(WORKING_VERBS);
+        refresh();
+        if (timer)
+            clearInterval(timer);
+        timer = setInterval(refresh, tickMs);
+        timer.unref?.();
+    });
+    pi.on("agent_end", () => stop());
+    pi.on("message_end", (event) => {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return;
+        outputTokens += usageFromMessage(message).output;
+        refresh();
+    });
+    return {
+        setActivity(text) {
+            activity = text;
+            refresh();
+        },
+    };
+}
+//# sourceMappingURL=workingLine.js.map