@yagni-app/code-staging 1.1.1-staging.1347.1 → 1.1.1-staging.1352.1

package/dist/extension/branding.d.ts

@@ -99,7 +99,7 @@ export declare const COMMUNICATION_CONTRACT: string;
  */
 export declare const WRITE_FINDINGS_DOWN: string;
 /** 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 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 TodoWrite 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

@@ -65,7 +65,7 @@ export const ULTRA_DELEGATION_PARAGRAPH = "Delegation (ultra mode): the user has
     "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 " +
+    "your TodoWrite 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

package/dist/extension/index.js

@@ -208,11 +208,18 @@ export async function registerYagni(pi, deps = {}) {
     // no-position record suggestions reach the model) and record_decision
     // (flywheel-attributed records send dedupe: true). Run 7.
     const flywheelState = makeFlywheelState();
+    // The session todo checklist: TodoWrite tool (Claude-parity surface), the
+    // above-editor widget, and /todos. Branch-replayed, so forks and resumes
+    // show the list as it stood at that point. Registered BEFORE the working
+    // line so the board's in_progress activeForm can drive the spinner verb.
+    const todosHandle = registerTodos(pi);
     // The composed streaming status line ("Shaping… (12m 54s · ↓ 47.5k tokens)").
     // Registered before the subagent/advisor tools: they publish their live
     // progress through this handle so the elapsed/token suffix survives their
-    // overrides. TUI-gated internally (agent_start checks ctx.mode).
-    const workingLine = registerWorkingLine(pi);
+    // overrides. The verb mirrors the todo board's live step when one is
+    // in_progress (Claude's currentTodo?.activeForm pattern). TUI-gated
+    // internally (agent_start checks ctx.mode).
+    const workingLine = registerWorkingLine(pi, { todoVerb: todosHandle.activeVerb });
     pi.registerTool(makeAskYagniTool({ ...toolOpts, flywheel: flywheelState, getRepo: () => sessionRepo }));
     // WebFetch (YAG-578): read an arbitrary URL as clean markdown + a
     // standard-tier extraction, replacing the bash + curl + python dance.
@@ -253,10 +260,6 @@ export async function registerYagni(pi, deps = {}) {
         // ask_yagni answers the same question next time instead of interrupting a human.
         pi.registerTool(makeRecordDecisionTool({ ...toolOpts, flywheel: flywheelState }));
     }
-    // The visible checklist for multi-step work: the todo_write tool, its
-    // above-editor widget, and /todos. Branch-replayed, so forks and resumes
-    // show the list as it stood at that point.
-    registerTodos(pi);
     // YAG-574: the silent-turn reminder, driver-only. A child/subagent/advisor
     // process has no direct user to answer, so it is never nudged (same gating
     // as the delegation identity in branding.ts); eval mode is untouched so its
@@ -1480,7 +1483,7 @@ export { blindStages, reportOnlyStages, makeGroundedVsBlindEval, formatCompariso
 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, MAX_PARALLEL_SUBAGENTS_ULTRA, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
-// The session todo checklist: todo_write tool, widget renderer, /todos.
+// The session todo checklist: TodoWrite tool, widget renderer, /todos.
 export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, formatTodoReminder, shouldRemindTodos, todoSummary, TODO_TOOL_NAME, TODO_REMINDER_TURNS, MAX_TODOS, } from "./todos.js";
 // P3 + W4: the permission gate seam (decideGate is pure; policy injectable) plus
 // the session bless-with-remember capture hook.

package/dist/extension/permission/gate.d.ts

@@ -309,7 +309,7 @@ export interface RegisterPermissionDeps {
 export declare const MODE_CONTEXT_TYPE = "yagni-mode-context";
 /** Legacy alias — the original plan-mode tag, kept for backward compat. */
 export declare const PLAN_CONTEXT_TYPE = "yagni-mode-context";
-export declare const PLAN_CONTEXT_MESSAGE = "[PLAN MODE ACTIVE]\nYou are in plan mode: explore and design, change nothing.\n- Read-only bash commands (ls, grep, git status, gh pr view, etc.) run freely to help you explore.\n- Ambiguous bash commands are reviewed by the Guardian; if non-mutating they run, if potentially mutating you will be asked.\n- write, edit, file_ticket, and update_ticket_status are held by the permission gate; do not attempt them.\n- Read, search, and ask_yagni freely to ground the plan in how this company works.\n- Produce a concrete numbered plan of the steps you would take, with the files involved.\n- End by asking the user to review the plan; they run /mode auto (or /mode review) to execute it.\n- Once executing, track the plan's steps with todo_write.";
+export declare const PLAN_CONTEXT_MESSAGE = "[PLAN MODE ACTIVE]\nYou are in plan mode: explore and design, change nothing.\n- Read-only bash commands (ls, grep, git status, gh pr view, etc.) run freely to help you explore.\n- Ambiguous bash commands are reviewed by the Guardian; if non-mutating they run, if potentially mutating you will be asked.\n- write, edit, file_ticket, and update_ticket_status are held by the permission gate; do not attempt them.\n- Read, search, and ask_yagni freely to ground the plan in how this company works.\n- Produce a concrete numbered plan of the steps you would take, with the files involved.\n- End by asking the user to review the plan; they run /mode auto (or /mode review) to execute it.\n- Once executing, track the plan's steps with TodoWrite.";
 /** Build the mode-awareness context message for the current permission mode. */
 export declare function buildModeContextMessage(mode: PermissionMode): string;
 /**

package/dist/extension/permission/gate.js

@@ -215,7 +215,7 @@ You are in plan mode: explore and design, change nothing.
 - Read, search, and ask_yagni freely to ground the plan in how this company works.
 - Produce a concrete numbered plan of the steps you would take, with the files involved.
 - End by asking the user to review the plan; they run /mode auto (or /mode review) to execute it.
-- Once executing, track the plan's steps with todo_write.`;
+- Once executing, track the plan's steps with TodoWrite.`;
 const AUTO_CONTEXT_MESSAGE = `${AUTO_MARKER}
 You are in auto mode. Coding commands run directly.
 - Proactively verify your work: run tests, lint, and typecheck after changes.

package/dist/extension/silentTurnReminder.js

@@ -43,6 +43,7 @@ export const MIN_SILENT_TURNS = 2;
  * utterance even when the assistant emitted no visible text block.
  */
 export const USER_FACING_TOOLS = new Set([
+    "TodoWrite",
     "todo_write",
     "file_ticket",
     "update_ticket_status",

package/dist/extension/todos.d.ts

@@ -1,25 +1,48 @@
 /**
  * The session todo list — the visible checklist for multi-step work.
  *
- * A `todo_write` tool the model calls with the FULL list every time (replace,
+ * A `TodoWrite` tool the model calls with the FULL list every time (replace,
  * not patch: replacement is idempotent under retries and always renders a
  * coherent board), a persistent above-editor widget while steps remain open,
  * and a `/todos` command to pull the list on demand.
  *
+ * The model-facing surface (name, item schema, description, result echo)
+ * matches Claude Code's shipped TodoWrite v1 exactly: the tick-immediately /
+ * don't-batch habits are trained behavior attached to that shape, and the
+ * custom `todo_write` surface was getting weak attachment (lists created at
+ * round start, entire rounds ground through unticked, one batch
+ * complete-at-end — the frozen-board report). Claude's TodoV2 per-task tools
+ * are a feature-flagged experiment there and are deliberately NOT adopted.
+ *
+ * The UI mirrors Claude Code too: TodoWrite leaves ZERO transcript rows
+ * (their renderToolUseMessage() => null; here, zero-line renderCall /
+ * renderResult renderers under renderShell "self" — pi removes the row
+ * entirely), and the board lives in the above-editor widget. The widget
+ * borrows Claude's TaskList details: the "N tasks (X done, Y in progress,
+ * Z open)" header, ✔/◼/◻ glyphs with a bold active row, activeForm as the
+ * live verb, and prioritized truncation (recently-completed tasks linger
+ * ~30s so a fresh tick is still visible, then older completions fall behind
+ * open work) with a "… +N in progress, M completed" overflow summary. One
+ * deliberate deviation: the list is always pinned above the editor, not
+ * behind Claude's ctrl+t toggle.
+ *
  * State follows pi's branching model the same way the session does: the
- * canonical list is the LAST `todo_write` tool result on the current branch,
+ * canonical list is the LAST todo tool result on the current branch,
  * reconstructed on session_start/session_tree, so forking or rewinding a
  * session automatically shows the list as it stood at that point. The
  * in-memory copy is just a cache of that.
  */
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-export declare const TODO_TOOL_NAME = "todo_write";
+export declare const TODO_TOOL_NAME = "TodoWrite";
+/** The pre-parity tool name. Recorded sessions carry it in tool results. */
+export declare const TODO_LEGACY_TOOL_NAME = "todo_write";
 export declare const MAX_TODOS = 50;
 export declare const MAX_TODO_TEXT = 300;
 /**
  * Staleness-reminder throttle (both counters must trip): a reminder is
- * eligible only after this many assistant turns since the last todo_write AND
+ * eligible only after this many assistant turns since the last TodoWrite AND
  * this many since the last reminder. The two-counter shape (staleness gate +
  * anti-spam gate) mirrors what Claude Code ships for its own todo tool; the
  * driver model routinely stops updating the board mid-grind (the frozen
@@ -27,6 +50,11 @@ export declare const MAX_TODO_TEXT = 300;
  * survive a long run.
  */
 export declare const TODO_REMINDER_TURNS = 10;
+/**
+ * How long a freshly-completed task lingers at the top of the widget before
+ * dropping behind open work — Claude Code's TaskList RECENT_COMPLETED_TTL.
+ */
+export declare const TODO_COMPLETED_LINGER_MS = 30000;
 /**
  * The desktop's structured state record rides its own widget key, like the
  * `/go` run state: one JSON line the app parses and renders itself, never
@@ -37,12 +65,17 @@ export declare const TODO_REMINDER_TURNS = 10;
 export declare const TODO_STATE_KEY = "yagni-todos:state";
 export type TodoStatus = "pending" | "in_progress" | "completed";
 export interface TodoItem {
-    text: string;
+    /** Imperative form: what needs to be done ("Run tests"). */
+    content: string;
+    /** Present continuous form, shown while in_progress ("Running tests"). */
+    activeForm: string;
     status: TodoStatus;
 }
 /**
  * Validate a full replacement list. Strict: this is model input rendered
  * straight into the terminal. An empty list is valid (it clears the board).
+ * Accepts both the current shape ({content, activeForm}) and the legacy
+ * {text} shape so old sessions replay cleanly.
  */
 export declare function normalizeTodos(raw: unknown): {
     ok: true;
@@ -58,17 +91,46 @@ export declare function todoSummary(todos: TodoItem[]): {
 };
 /** Plain-text checklist (tool results, /todos in headless contexts). */
 export declare function formatTodoList(todos: TodoItem[]): string;
+/** One count for the whole board — header and overflow always agree. */
+export declare function todoCounts(todos: TodoItem[]): {
+    total: number;
+    done: number;
+    inProgress: number;
+    open: number;
+};
+/** Claude Code's widget header: `3 tasks (1 done, 1 in progress, 6 open)`. */
+export declare function formatTodoHeader(todos: TodoItem[]): string;
+/**
+ * The every-write result echo — Claude Code's exact reinforcer. The tick
+ * habit decays over a long run; this lands on every TodoWrite result
+ * (including the create-at-start write, right before the model enters its
+ * grind) so the board stays current in the model's attention.
+ */
+export declare const TODO_RESULT_ECHO: string;
 /** The slice of pi's Theme the widget styles with (matches the feed's pattern). */
 export interface TodoTheme {
     fg(color: string, s: string): string;
+    bold?(s: string): string;
     strikethrough?(s: string): string;
 }
+/**
+ * Claude Code's task truncation priority: recently-completed first (a fresh
+ * tick lingers {@link TODO_COMPLETED_LINGER_MS} so the user sees it land),
+ * then in_progress, then pending, then older completed — everything else
+ * falls behind the cap and is summarized.
+ */
+export declare function prioritizeTodos(todos: TodoItem[], completedAt: (content: string) => number | undefined, nowMs: number): TodoItem[];
+/** Claude Code's overflow summary: `… +2 in progress, 3 completed`. */
+export declare function formatTodoOverflow(hidden: TodoItem[]): string | null;
 /**
  * The above-editor checklist. Empty (paint nothing) when there is no list or
- * every step is completed — a finished board should leave the screen. Capped
+ * every step is completed — a finished board should leave the screen. Rows
+ * past the cap are truncated with Claude's prioritization + overflow summary
  * so header + items + overflow stays under pi's 10-line widget truncation.
+ * The in-progress row shows the active form in bold (the live "what am I
+ * doing" signal); pending and completed rows show the imperative content.
  */
-export declare function renderTodoWidget(todos: TodoItem[], theme: TodoTheme): string[];
+export declare function renderTodoWidget(todos: TodoItem[], theme: TodoTheme, completedAtCache?: Map<string, number>, nowMs?: number): string[];
 /** The desktop state record: exactly one JSON line under TODO_STATE_KEY. */
 export declare function todoStateLine(todos: TodoItem[]): string;
 /**
@@ -85,22 +147,23 @@ export declare function shouldRemindTodos(input: {
  * PURE: the hedged reminder block appended to a tool result when the board has
  * gone stale. Carries the CURRENT list so the model can reconcile without a
  * read, and explicitly licenses ignoring it, so an accurate board costs one
- * glance rather than a spurious todo_write.
+ * glance rather than a spurious TodoWrite.
  */
 export declare function formatTodoReminder(todos: TodoItem[]): string;
-/** Replay the branch: the last todo_write result is the canonical list. */
+/** Replay the branch: the last todo-tool result is the canonical list. */
 export declare function reconstructTodos(entries: unknown[]): TodoItem[];
 type TodoParams = {
     todos: Array<{
-        text: string;
+        content: string;
+        activeForm: string;
         status: string;
     }>;
 };
 /**
- * Build the todo_write tool definition around a shared store. Separated from
+ * Build the TodoWrite tool definition around a shared store. Separated from
  * registration so tests can drive execute directly.
  */
-export declare function makeTodoTool(get: () => TodoItem[], set: (todos: TodoItem[]) => void): {
+export declare function makeTodoTool(get: () => TodoItem[], set: (todos: TodoItem[]) => void, completedAt?: Map<string, number>): {
     name: string;
     label: string;
     description: string;
@@ -108,10 +171,21 @@ export declare function makeTodoTool(get: () => TodoItem[], set: (todos: TodoIte
     promptGuidelines: string[];
     parameters: Type.TObject<{
         todos: Type.TArray<Type.TObject<{
-            text: Type.TString;
+            content: Type.TString;
+            activeForm: Type.TString;
             status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"in_progress">, Type.TLiteral<"completed">]>;
         }>>;
     }>;
+    renderShell: "self";
+    renderCall: () => Component;
+    renderResult: (result: {
+        content?: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }, options: {
+        isError?: boolean;
+    }, theme: TodoTheme) => Component;
     execute(_toolCallId: string, params: TodoParams, _signal?: AbortSignal, _onUpdate?: unknown, ctx?: ExtensionContext): Promise<{
         content: {
             type: "text";
@@ -132,7 +206,15 @@ export declare function makeTodoTool(get: () => TodoItem[], set: (todos: TodoIte
         isError?: undefined;
     }>;
 };
-/** Wire the tool, the branch-replay events, the staleness reminder, and /todos. */
-export declare function registerTodos(pi: ExtensionAPI): void;
+/**
+ * Wire the tool, the branch-replay events, the staleness reminder, the
+ * widget refresh loop, and /todos.
+ */
+/** What registerTodos hands back: the live spinner-verb override. */
+export interface TodosHandle {
+    /** The in_progress item's activeForm, or undefined with no active step. */
+    activeVerb(): string | undefined;
+}
+export declare function registerTodos(pi: ExtensionAPI): TodosHandle;
 export {};
 //# sourceMappingURL=todos.d.ts.map

package/dist/extension/todos.js

@@ -1,25 +1,49 @@
 /**
  * The session todo list — the visible checklist for multi-step work.
  *
- * A `todo_write` tool the model calls with the FULL list every time (replace,
+ * A `TodoWrite` tool the model calls with the FULL list every time (replace,
  * not patch: replacement is idempotent under retries and always renders a
  * coherent board), a persistent above-editor widget while steps remain open,
  * and a `/todos` command to pull the list on demand.
  *
+ * The model-facing surface (name, item schema, description, result echo)
+ * matches Claude Code's shipped TodoWrite v1 exactly: the tick-immediately /
+ * don't-batch habits are trained behavior attached to that shape, and the
+ * custom `todo_write` surface was getting weak attachment (lists created at
+ * round start, entire rounds ground through unticked, one batch
+ * complete-at-end — the frozen-board report). Claude's TodoV2 per-task tools
+ * are a feature-flagged experiment there and are deliberately NOT adopted.
+ *
+ * The UI mirrors Claude Code too: TodoWrite leaves ZERO transcript rows
+ * (their renderToolUseMessage() => null; here, zero-line renderCall /
+ * renderResult renderers under renderShell "self" — pi removes the row
+ * entirely), and the board lives in the above-editor widget. The widget
+ * borrows Claude's TaskList details: the "N tasks (X done, Y in progress,
+ * Z open)" header, ✔/◼/◻ glyphs with a bold active row, activeForm as the
+ * live verb, and prioritized truncation (recently-completed tasks linger
+ * ~30s so a fresh tick is still visible, then older completions fall behind
+ * open work) with a "… +N in progress, M completed" overflow summary. One
+ * deliberate deviation: the list is always pinned above the editor, not
+ * behind Claude's ctrl+t toggle.
+ *
  * State follows pi's branching model the same way the session does: the
- * canonical list is the LAST `todo_write` tool result on the current branch,
+ * canonical list is the LAST todo tool result on the current branch,
  * reconstructed on session_start/session_tree, so forking or rewinding a
  * session automatically shows the list as it stood at that point. The
  * in-memory copy is just a cache of that.
  */
+import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { logEvent } from "./errorSink.js";
 import { isDesktopSurface } from "./surface.js";
-export const TODO_TOOL_NAME = "todo_write";
+export const TODO_TOOL_NAME = "TodoWrite";
+/** The pre-parity tool name. Recorded sessions carry it in tool results. */
+export const TODO_LEGACY_TOOL_NAME = "todo_write";
 export const MAX_TODOS = 50;
 export const MAX_TODO_TEXT = 300;
 /**
  * Staleness-reminder throttle (both counters must trip): a reminder is
- * eligible only after this many assistant turns since the last todo_write AND
+ * eligible only after this many assistant turns since the last TodoWrite AND
  * this many since the last reminder. The two-counter shape (staleness gate +
  * anti-spam gate) mirrors what Claude Code ships for its own todo tool; the
  * driver model routinely stops updating the board mid-grind (the frozen
@@ -27,6 +51,11 @@ export const MAX_TODO_TEXT = 300;
  * survive a long run.
  */
 export const TODO_REMINDER_TURNS = 10;
+/**
+ * How long a freshly-completed task lingers at the top of the widget before
+ * dropping behind open work — Claude Code's TaskList RECENT_COMPLETED_TTL.
+ */
+export const TODO_COMPLETED_LINGER_MS = 30_000;
 const WIDGET_KEY = "yagni-todos";
 /**
  * The desktop's structured state record rides its own widget key, like the
@@ -38,10 +67,32 @@ const WIDGET_KEY = "yagni-todos";
 export const TODO_STATE_KEY = "yagni-todos:state";
 /** Header + items + overflow line must stay under pi's 10-line widget cap. */
 const MAX_WIDGET_ITEMS = 7;
+/** The current desktop record version ({@link todoStateLine}). */
+const TODO_STATE_VERSION = 2;
 const STATUSES = ["pending", "in_progress", "completed"];
+function coerceItem(raw) {
+    const { content, activeForm, text, status } = raw;
+    // Legacy `text` items (pre-parity tool calls and recorded sessions) map
+    // onto the new shape; the active form falls back to the content.
+    const contentText = typeof content === "string" && content.trim().length > 0 ? content : text;
+    if (typeof contentText !== "string" || contentText.trim().length === 0) {
+        return { error: "each todo needs non-empty content" };
+    }
+    if (typeof status !== "string" || !STATUSES.includes(status)) {
+        return { error: `status must be one of ${STATUSES.join(", ")}` };
+    }
+    const active = typeof activeForm === "string" && activeForm.trim().length > 0 ? activeForm : contentText;
+    return {
+        content: contentText.trim().slice(0, MAX_TODO_TEXT),
+        activeForm: active.trim().slice(0, MAX_TODO_TEXT),
+        status: status,
+    };
+}
 /**
  * Validate a full replacement list. Strict: this is model input rendered
  * straight into the terminal. An empty list is valid (it clears the board).
+ * Accepts both the current shape ({content, activeForm}) and the legacy
+ * {text} shape so old sessions replay cleanly.
  */
 export function normalizeTodos(raw) {
     if (!Array.isArray(raw))
@@ -52,14 +103,10 @@ export function normalizeTodos(raw) {
     for (const item of raw) {
         if (!item || typeof item !== "object")
             return { ok: false, error: "each todo must be an object" };
-        const { text, status } = item;
-        if (typeof text !== "string" || text.trim().length === 0) {
-            return { ok: false, error: "each todo needs non-empty text" };
-        }
-        if (typeof status !== "string" || !STATUSES.includes(status)) {
-            return { ok: false, error: `status must be one of ${STATUSES.join(", ")}` };
-        }
-        todos.push({ text: text.trim().slice(0, MAX_TODO_TEXT), status: status });
+        const coerced = coerceItem(item);
+        if ("error" in coerced)
+            return { ok: false, error: coerced.error };
+        todos.push(coerced);
     }
     return { ok: true, todos };
 }
@@ -67,7 +114,7 @@ export function todoSummary(todos) {
     return {
         done: todos.filter((t) => t.status === "completed").length,
         total: todos.length,
-        active: todos.find((t) => t.status === "in_progress")?.text ?? null,
+        active: todos.find((t) => t.status === "in_progress")?.activeForm ?? null,
     };
 }
 const GLYPH = { pending: "[ ]", in_progress: "[>]", completed: "[x]" };
@@ -76,40 +123,102 @@ export function formatTodoList(todos) {
     if (todos.length === 0)
         return "No todos.";
     const { done, total } = todoSummary(todos);
-    const lines = todos.map((t) => `${GLYPH[t.status]} ${t.text}`);
+    const lines = todos.map((t) => `${GLYPH[t.status]} ${t.content}`);
     return [`${done}/${total} done`, ...lines].join("\n");
 }
+/** One count for the whole board — header and overflow always agree. */
+export function todoCounts(todos) {
+    const done = todos.filter((t) => t.status === "completed").length;
+    const inProgress = todos.filter((t) => t.status === "in_progress").length;
+    return { total: todos.length, done, inProgress, open: todos.length - done - inProgress };
+}
+/** Claude Code's widget header: `3 tasks (1 done, 1 in progress, 6 open)`. */
+export function formatTodoHeader(todos) {
+    const { total, done, inProgress, open } = todoCounts(todos);
+    const parts = [`${done} done`, ...(inProgress > 0 ? [`${inProgress} in progress`] : []), `${open} open`];
+    return `${total} tasks (${parts.join(", ")})`;
+}
+/**
+ * The every-write result echo — Claude Code's exact reinforcer. The tick
+ * habit decays over a long run; this lands on every TodoWrite result
+ * (including the create-at-start write, right before the model enters its
+ * grind) so the board stays current in the model's attention.
+ */
+export const TODO_RESULT_ECHO = "Todos have been modified successfully. Ensure that you continue to use the " +
+    "todo list to track your progress. Please proceed with the current tasks if applicable";
+/**
+ * Claude Code's task truncation priority: recently-completed first (a fresh
+ * tick lingers {@link TODO_COMPLETED_LINGER_MS} so the user sees it land),
+ * then in_progress, then pending, then older completed — everything else
+ * falls behind the cap and is summarized.
+ */
+export function prioritizeTodos(todos, completedAt, nowMs) {
+    const recent = [];
+    const older = [];
+    for (const t of todos) {
+        if (t.status !== "completed")
+            continue;
+        const at = completedAt(t.content);
+        if (at !== undefined && nowMs - at < TODO_COMPLETED_LINGER_MS)
+            recent.push(t);
+        else
+            older.push(t);
+    }
+    return [
+        ...recent,
+        ...todos.filter((t) => t.status === "in_progress"),
+        ...todos.filter((t) => t.status === "pending"),
+        ...older,
+    ];
+}
+/** Claude Code's overflow summary: `… +2 in progress, 3 completed`. */
+export function formatTodoOverflow(hidden) {
+    if (hidden.length === 0)
+        return null;
+    const { inProgress, open, done } = todoCounts(hidden);
+    const parts = [
+        ...(inProgress > 0 ? [`${inProgress} in progress`] : []),
+        ...(open > 0 ? [`${open} open`] : []),
+        ...(done > 0 ? [`${done} completed`] : []),
+    ];
+    return parts.length > 0 ? `… +${parts.join(", ")}` : null;
+}
 /**
  * The above-editor checklist. Empty (paint nothing) when there is no list or
- * every step is completed — a finished board should leave the screen. Capped
+ * every step is completed — a finished board should leave the screen. Rows
+ * past the cap are truncated with Claude's prioritization + overflow summary
  * so header + items + overflow stays under pi's 10-line widget truncation.
+ * The in-progress row shows the active form in bold (the live "what am I
+ * doing" signal); pending and completed rows show the imperative content.
  */
-export function renderTodoWidget(todos, theme) {
-    const { done, total } = todoSummary(todos);
+export function renderTodoWidget(todos, theme, completedAtCache = new Map(), nowMs = Date.now()) {
+    const { total, done } = todoCounts(todos);
     if (total === 0 || done === total)
         return [];
-    const lines = [theme.fg("muted", `Todos ${done}/${total}`)];
-    const visible = todos.slice(0, MAX_WIDGET_ITEMS);
+    const lines = [theme.fg("muted", formatTodoHeader(todos))];
+    const ordered = prioritizeTodos(todos, (content) => completedAtCache.get(content), nowMs);
+    const visible = ordered.slice(0, MAX_WIDGET_ITEMS);
     for (const todo of visible) {
         if (todo.status === "completed") {
-            const text = theme.strikethrough ? theme.strikethrough(todo.text) : todo.text;
-            lines.push(`${theme.fg("success", "☑ ")}${theme.fg("dim", text)}`);
+            const text = theme.strikethrough ? theme.strikethrough(todo.content) : todo.content;
+            lines.push(`${theme.fg("success", "✔ ")}${theme.fg("dim", text)}`);
         }
         else if (todo.status === "in_progress") {
-            lines.push(`${theme.fg("accent", "▶ ")}${theme.fg("text", todo.text)}`);
+            const active = theme.bold ? theme.bold(`${todo.activeForm}…`) : `${todo.activeForm}…`;
+            lines.push(`${theme.fg("accent", "◼ ")}${theme.fg("text", active)}`);
         }
         else {
-            lines.push(`${theme.fg("dim", "☐ ")}${theme.fg("muted", todo.text)}`);
+            lines.push(`${theme.fg("dim", "◻ ")}${theme.fg("muted", todo.content)}`);
         }
     }
-    if (todos.length > visible.length) {
-        lines.push(theme.fg("dim", `…and ${todos.length - visible.length} more`));
-    }
+    const overflow = formatTodoOverflow(ordered.slice(MAX_WIDGET_ITEMS));
+    if (overflow)
+        lines.push(theme.fg("dim", overflow));
     return lines;
 }
 /** The desktop state record: exactly one JSON line under TODO_STATE_KEY. */
 export function todoStateLine(todos) {
-    return JSON.stringify({ v: 1, todos });
+    return JSON.stringify({ v: TODO_STATE_VERSION, todos });
 }
 /**
  * PURE: is a staleness reminder due? Only when the board has open work (an
@@ -129,16 +238,16 @@ export function shouldRemindTodos(input) {
  * PURE: the hedged reminder block appended to a tool result when the board has
  * gone stale. Carries the CURRENT list so the model can reconcile without a
  * read, and explicitly licenses ignoring it, so an accurate board costs one
- * glance rather than a spurious todo_write.
+ * glance rather than a spurious TodoWrite.
  */
 export function formatTodoReminder(todos) {
-    return ("⟦YAGNI todos⟧ The todo_write checklist has not been updated for a while. " +
+    return ("⟦YAGNI todos⟧ The TodoWrite checklist has not been updated for a while. " +
         "If the work has moved on, bring it current now: mark finished steps completed, " +
         "set the step you are on to in_progress, and add newly discovered steps. " +
         "If the list is already accurate, ignore this.\n" +
         formatTodoList(todos));
 }
-/** Replay the branch: the last todo_write result is the canonical list. */
+/** Replay the branch: the last todo-tool result is the canonical list. */
 export function reconstructTodos(entries) {
     let todos = [];
     for (const entry of entries) {
@@ -146,7 +255,9 @@ export function reconstructTodos(entries) {
         if (e?.type !== "message")
             continue;
         const msg = e.message;
-        if (msg?.role !== "toolResult" || msg.toolName !== TODO_TOOL_NAME)
+        if (msg?.role !== "toolResult")
+            continue;
+        if (msg.toolName !== TODO_TOOL_NAME && msg.toolName !== TODO_LEGACY_TOOL_NAME)
             continue;
         const details = msg.details;
         const normalized = normalizeTodos(details?.todos);
@@ -157,7 +268,10 @@ export function reconstructTodos(entries) {
 }
 const parameters = Type.Object({
     todos: Type.Array(Type.Object({
-        text: Type.String({ description: "The step, short and imperative." }),
+        content: Type.String({ description: "The step, short and imperative (e.g. \"Run tests\")." }),
+        activeForm: Type.String({
+            description: "Present continuous form shown while in progress (e.g. \"Running tests\").",
+        }),
         status: Type.Union([
             Type.Literal("pending"),
             Type.Literal("in_progress"),
@@ -165,7 +279,31 @@ const parameters = Type.Object({
         ]),
     }), { description: "The FULL list; it replaces the previous one." }),
 });
-function paintWidget(ctx, todos) {
+/**
+ * The zero-line renderer pair that removes TodoWrite's transcript row
+ * entirely (collapsed AND ctrl+o expanded) — Claude Code's
+ * renderToolUseMessage() => null. The tool still executes and its result
+ * still reaches the model; only the visible row is gone.
+ */
+function todoRenderers() {
+    return {
+        renderCall: () => new Container(),
+        // Success stays invisible (Claude's renderToolUseMessage() => null); a
+        // REJECTED write paints exactly one dim line so the user sees why the
+        // board did not change — the model still gets the full error result.
+        renderResult: (result, options, theme) => {
+            if (!options.isError)
+                return new Container();
+            const message = result.content
+                ?.find((c) => c.type === "text" && typeof c.text === "string")?.text
+                ?.split("\n")
+                .find((l) => l.length > 0);
+            const line = message ? `TodoWrite rejected: ${message}` : "TodoWrite rejected";
+            return new Text(theme.fg("error", line), 0, 0);
+        },
+    };
+}
+function paintWidget(ctx, todos, completedAt) {
     if (!ctx?.hasUI)
         return;
     try {
@@ -180,11 +318,11 @@ function paintWidget(ctx, todos) {
             return;
         }
         const theme = ctx.ui.theme;
-        const lines = renderTodoWidget(todos, theme);
+        const lines = renderTodoWidget(todos, theme, completedAt);
         ctx.ui.setWidget?.(WIDGET_KEY, lines.length > 0 ? lines : undefined, {
             placement: "aboveEditor",
         });
-        const { done, total } = todoSummary(todos);
+        const { total, done } = todoCounts(todos);
         ctx.ui.setStatus?.(WIDGET_KEY, total > 0 && done < total ? `todos ${done}/${total}` : undefined);
     }
     catch {
@@ -192,34 +330,40 @@ function paintWidget(ctx, todos) {
     }
 }
 /**
- * Build the todo_write tool definition around a shared store. Separated from
+ * Build the TodoWrite tool definition around a shared store. Separated from
  * registration so tests can drive execute directly.
  */
-export function makeTodoTool(get, set) {
+export function makeTodoTool(get, set, completedAt) {
+    const { renderCall, renderResult } = todoRenderers();
     return {
         name: TODO_TOOL_NAME,
         label: "Todos",
-        description: "Track your plan for multi-step work as a checklist the user can see. " +
-            "Pass the FULL list every time — it replaces the previous list. Keep exactly one item " +
-            "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).",
+        // Claude Code's shipped description, verbatim.
+        description: "Update the todo list for the current session. To be used proactively and often to track " +
+            "progress and pending tasks. Make sure that at least one task is in_progress at all times. " +
+            "Always provide both content (imperative) and activeForm (present continuous) for each task.",
+        promptSnippet: "TodoWrite: 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 " +
+            "Use TodoWrite 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.",
+                "BEFORE you start working on it. Ideally only one task is in_progress at a time.",
             "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.",
+                "at a time, and remove tasks that are no longer relevant from the list entirely.",
+            "Update task status in real time as you work: mark a step completed the MOMENT it is done " +
+                "(do not batch completions), and add newly discovered follow-up steps as pending.",
+            "Only mark a step completed when it is FULLY accomplished — if tests fail, work is partial, or " +
+                "you hit a blocker, leave it in_progress and add a new step for what must be resolved.",
         ],
         parameters,
+        // Claude Code's renderToolUseMessage() => null: no transcript row at all.
+        renderShell: "self",
+        renderCall,
+        renderResult,
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const normalized = normalizeTodos(params.todos);
             if (!normalized.ok) {
@@ -230,15 +374,14 @@ export function makeTodoTool(get, set) {
                 };
             }
             set(normalized.todos);
-            paintWidget(ctx, normalized.todos);
+            paintWidget(ctx, normalized.todos, completedAt);
             return {
-                content: [{ type: "text", text: formatTodoList(normalized.todos) }],
+                content: [{ type: "text", text: `${formatTodoList(normalized.todos)}\n\n${TODO_RESULT_ECHO}` }],
                 details: { todos: normalized.todos },
             };
         },
     };
 }
-/** Wire the tool, the branch-replay events, the staleness reminder, and /todos. */
 export function registerTodos(pi) {
     let todos = [];
     // Staleness-reminder counters (see TODO_REMINDER_TURNS). Session-local like
@@ -246,13 +389,49 @@ export function registerTodos(pi) {
     // opens with an instantly-due reminder.
     let turnsSinceWrite = 0;
     let turnsSinceReminder = 0;
+    // Completion timestamps for the widget's recently-completed priority
+    // (Claude's RECENT_COMPLETED_TTL linger): a fresh tick stays at the top of
+    // the board for ~30s, then drops behind open work. Entries only ever leave
+    // when their item leaves the board — an age-based eviction would re-stamp a
+    // still-completed item as fresh on the next observe loop (the !has guard
+    // passes), re-floating it every few minutes. prioritizeTodos already treats
+    // an aged-out stamp as "older"; the cache never needs a sweeper.
+    const completedAt = new Map();
+    const observe = (next, now = Date.now()) => {
+        const seen = new Set(next.map((t) => t.content));
+        for (const [content] of completedAt) {
+            if (!seen.has(content))
+                completedAt.delete(content);
+        }
+        for (const t of next) {
+            if (t.status === "completed" && !completedAt.has(t.content))
+                completedAt.set(t.content, now);
+        }
+    };
     const reconstruct = (ctx) => {
         try {
             todos = reconstructTodos(ctx.sessionManager.getBranch());
         }
-        catch {
+        catch (err) {
+            // A replay failure must never break session start, but silently wiping
+            // the board hides a broken session file — leave a diagnostic trail.
+            logEvent({
+                source: "todos",
+                level: "warn",
+                event: "reconstruct_failed",
+                fields: { error: err instanceof Error ? err.message : String(err) },
+            });
             todos = [];
         }
+        // Seed the linger cache so a resumed/forked board orders deterministically:
+        // completed items from history rank as "older" (outside the linger
+        // window), exactly like a live item whose tick has aged out.
+        completedAt.clear();
+        for (const t of todos) {
+            if (t.status === "completed") {
+                completedAt.set(t.content, Date.now() - TODO_COMPLETED_LINGER_MS - 1);
+            }
+        }
         turnsSinceWrite = 0;
         turnsSinceReminder = 0;
         paintWidget(ctx, todos);
@@ -260,7 +439,7 @@ export function registerTodos(pi) {
     pi.on("session_start", async (_event, ctx) => reconstruct(ctx));
     pi.on("session_tree", async (_event, ctx) => reconstruct(ctx));
     // Turn counting: one tick per finalized assistant message, the same "turn"
-    // the model experiences between opportunities to call todo_write.
+    // the model experiences between opportunities to call TodoWrite.
     pi.on("message_end", async (event) => {
         if (event.message?.role === "assistant") {
             turnsSinceWrite += 1;
@@ -269,11 +448,11 @@ export function registerTodos(pi) {
     });
     // The reminder rides an existing tool result (the same result-modification
     // seam ambient recall uses), so it reaches the model mid-run without
-    // spending a turn. Never appended to todo_write's own result, and fail-soft:
-    // a reminder must never break a tool call.
+    // spending a turn. Never appended to the todo tool's own result, and
+    // fail-soft: a reminder must never break a tool call.
     pi.on("tool_result", async (event) => {
         try {
-            if (event.toolName === TODO_TOOL_NAME)
+            if (event.toolName === TODO_TOOL_NAME || event.toolName === TODO_LEGACY_TOOL_NAME)
                 return;
             if (!shouldRemindTodos({ todos, turnsSinceWrite, turnsSinceReminder }))
                 return;
@@ -291,8 +470,9 @@ export function registerTodos(pi) {
     });
     pi.registerTool(makeTodoTool(() => todos, (next) => {
         todos = next;
+        observe(next);
         turnsSinceWrite = 0;
-    }));
+    }, completedAt));
     pi.registerCommand("todos", {
         description: "Show the agent's current task list for this session.",
         handler: async (_args, ctx) => {
@@ -303,5 +483,8 @@ export function registerTodos(pi) {
                 : formatTodoList(todos), "info");
         },
     });
+    return {
+        activeVerb: () => todos.find((t) => t.status === "in_progress")?.activeForm,
+    };
 }
 //# sourceMappingURL=todos.js.map

package/dist/extension/workingLine.d.ts

@@ -44,6 +44,13 @@ export interface RegisterWorkingLineDeps {
     pickVerb?: (verbs: readonly string[]) => string;
     /** Refresh cadence for the elapsed clock. */
     tickMs?: number;
+    /**
+     * Live override for the verb when no subagent/advisor activity text is
+     * set — the session todo board's in_progress activeForm ("Running tests"),
+     * Claude Code's `currentTodo?.activeForm ?? randomVerb` pattern. Called on
+     * every refresh so a mid-loop tick changes the line without re-wiring.
+     */
+    todoVerb?: () => string | undefined;
 }
 export declare function registerWorkingLine(pi: ExtensionAPI, deps?: RegisterWorkingLineDeps): WorkingLineHandle;
 //# sourceMappingURL=workingLine.d.ts.map

package/dist/extension/workingLine.js

@@ -65,7 +65,13 @@ export function registerWorkingLine(pi, deps = {}) {
         if (!ui || startedAt === undefined)
             return;
         try {
-            ui.setWorkingMessage?.(composeWorkingMessage({ activity, verb, elapsedMs: now() - startedAt, outputTokens }));
+            const verbOverride = activity === undefined ? deps.todoVerb?.() : undefined;
+            ui.setWorkingMessage?.(composeWorkingMessage({
+                activity,
+                verb: verbOverride ?? verb,
+                elapsedMs: now() - startedAt,
+                outputTokens,
+            }));
         }
         catch {
             // The status line must never break a turn.

package/dist/promptEnrichment.d.ts

@@ -36,5 +36,5 @@ export declare function promptEnrichmentDisabled(env: NodeJS.ProcessEnv): boolea
  * model, and the load-bearing instructions (ask_yagni contract, delegation)
  * live elsewhere in the prompt.
  */
-export declare const ENGINEERING_PRACTICE_SECTION = "Engineering practice:\n\nAnswering vs acting: distinguish what the user is asking for before responding. When the user asks you to analyze, investigate, find a root cause, study how something works, explore an approach, or asks a strategic or advisory question (\"should we...\", \"what's your read on...\", \"go/no-go on...\"), answer in prose \u2014 do not start coding or editing files. When the user asks you to implement, fix, or change something, use your tools to make the actual edits and run the actual commands \u2014 do not answer with a description of what you would do, or with code for the user to apply themselves.\n\nConventions:\n- Never assume a library is available, however well known. Before using one, confirm the project already depends on it (its package manifest, or imports in neighboring files).\n- When editing, read the surrounding code and its imports first; match the file's existing style, naming, and patterns rather than introducing your own.\n- When creating a new file or component, study an existing sibling first and follow its structure.\n- Never write code that logs or exposes secrets, keys, or credentials.\n\nVerification:\n- Consider what the code you are changing is supposed to do (from its name, location, and callers) before you change it.\n- Verify changes with the project's own tests when possible. Never assume a test framework or command \u2014 check the README, package scripts, or neighboring tests for the real one.\n- After completing a task, run the project's lint and typecheck commands if you know them; if you cannot find them, ask the user and suggest recording them in AGENTS.md for next time.\n\nVersion control:\n- No unsolicited commits: commit only when the user asked for one or the task at hand clearly calls for it.\n\nGit safety:\n- You may be in a dirty git worktree. Never revert existing changes you did not make unless explicitly asked \u2014 these were made by the user.\n- If there are unrelated changes in files you are touching, read and work with them rather than reverting.\n- If changes appear in unrelated files, ignore them and do not revert.\n- Do not amend a commit unless explicitly asked.\n- If you notice unexpected changes you did not make while working, stop immediately and ask the user.\n- Never use destructive git commands (git reset --hard, git checkout --) unless the user explicitly requests or approves them.\n\nTodo discipline:\n- Track multi-step work with todo_write: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.\n- Do not batch-complete items or create single-step plans. Skip planning for trivially small work (~25% of tasks).\n\nMode awareness:\n- In auto mode, proactively run tests, lint, and typecheck after your changes.\n- In review mode, propose verification steps but wait for approval before running them.\n- In plan mode, explore and design only \u2014 the gate holds all writes.\n\nCommunication:\n- Answer directly, without preamble or postamble (\"Here is what I will do next...\", \"Based on the information provided...\"). Match the length of your answer to the question.\n- After making edits, report the outcome briefly; do not restate the diff or explain the code you just wrote unless asked.\n- Do not add code comments that narrate what you changed or why the change is correct; comments are for future readers of the code.\n- Reference code as file_path:line_number so the user can jump to it.\n- Before running a non-trivial command that changes state, say in one line what it does and why.\n- Never guess or fabricate URLs. Only use URLs the user provided or that appear in local files.\n- No emojis unless the user asks for them.";
+export declare const ENGINEERING_PRACTICE_SECTION = "Engineering practice:\n\nAnswering vs acting: distinguish what the user is asking for before responding. When the user asks you to analyze, investigate, find a root cause, study how something works, explore an approach, or asks a strategic or advisory question (\"should we...\", \"what's your read on...\", \"go/no-go on...\"), answer in prose \u2014 do not start coding or editing files. When the user asks you to implement, fix, or change something, use your tools to make the actual edits and run the actual commands \u2014 do not answer with a description of what you would do, or with code for the user to apply themselves.\n\nConventions:\n- Never assume a library is available, however well known. Before using one, confirm the project already depends on it (its package manifest, or imports in neighboring files).\n- When editing, read the surrounding code and its imports first; match the file's existing style, naming, and patterns rather than introducing your own.\n- When creating a new file or component, study an existing sibling first and follow its structure.\n- Never write code that logs or exposes secrets, keys, or credentials.\n\nVerification:\n- Consider what the code you are changing is supposed to do (from its name, location, and callers) before you change it.\n- Verify changes with the project's own tests when possible. Never assume a test framework or command \u2014 check the README, package scripts, or neighboring tests for the real one.\n- After completing a task, run the project's lint and typecheck commands if you know them; if you cannot find them, ask the user and suggest recording them in AGENTS.md for next time.\n\nVersion control:\n- No unsolicited commits: commit only when the user asked for one or the task at hand clearly calls for it.\n\nGit safety:\n- You may be in a dirty git worktree. Never revert existing changes you did not make unless explicitly asked \u2014 these were made by the user.\n- If there are unrelated changes in files you are touching, read and work with them rather than reverting.\n- If changes appear in unrelated files, ignore them and do not revert.\n- Do not amend a commit unless explicitly asked.\n- If you notice unexpected changes you did not make while working, stop immediately and ask the user.\n- Never use destructive git commands (git reset --hard, git checkout --) unless the user explicitly requests or approves them.\n\nTodo discipline:\n- Track multi-step work with TodoWrite: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.\n- Do not batch-complete items or create single-step plans. Skip planning for trivially small work (~25% of tasks).\n\nMode awareness:\n- In auto mode, proactively run tests, lint, and typecheck after your changes.\n- In review mode, propose verification steps but wait for approval before running them.\n- In plan mode, explore and design only \u2014 the gate holds all writes.\n\nCommunication:\n- Answer directly, without preamble or postamble (\"Here is what I will do next...\", \"Based on the information provided...\"). Match the length of your answer to the question.\n- After making edits, report the outcome briefly; do not restate the diff or explain the code you just wrote unless asked.\n- Do not add code comments that narrate what you changed or why the change is correct; comments are for future readers of the code.\n- Reference code as file_path:line_number so the user can jump to it.\n- Before running a non-trivial command that changes state, say in one line what it does and why.\n- Never guess or fabricate URLs. Only use URLs the user provided or that appear in local files.\n- No emojis unless the user asks for them.";
 //# sourceMappingURL=promptEnrichment.d.ts.map

package/dist/promptEnrichment.js

@@ -66,7 +66,7 @@ Git safety:
 - Never use destructive git commands (git reset --hard, git checkout --) unless the user explicitly requests or approves them.
 
 Todo discipline:
-- Track multi-step work with todo_write: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.
+- Track multi-step work with TodoWrite: keep exactly one item in_progress at a time, mark items completed the moment they are done, and add newly discovered steps as pending.
 - Do not batch-complete items or create single-step plans. Skip planning for trivially small work (~25% of tasks).
 
 Mode awareness:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.1-staging.1347.1",
+  "version": "1.1.1-staging.1352.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": "54aa68c2232922e7b45ec4563c18fd2995dec236"
+  "yagniSourceSha": "1a93f050375804c9206e4660c812aebbb1ec338a"
 }