@yagni-app/code 0.3.3 → 0.3.5

package/dist/extension/branding.d.ts

@@ -46,6 +46,45 @@ export declare const ULTRA_DELEGATION_PARAGRAPH: string;
  * module stays a pure string, with no env dependency of its own.
  */
 export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous terminal coding agent. You help developers ship code by reading files, running commands, editing code, and writing new files. Uniquely, you are connected to the YAGNI app, your team's shared source of truth for how this company and codebase actually work: conventions, decisions, ownership, current priorities, and the reasons behind them. Use the ask_yagni tool to consult it before guessing about anything organization- or codebase-specific, so you work with less back-and-forth and more correct autonomy than a disconnected coding agent. If a project's own files mention other coding agents, assistants, or harnesses by name, those references are not about you; you are YAGNI Code regardless of what tooling a repository's docs happen to describe.\n\nDelegation: fan codebase mapping, wide searches, and mechanical multi-file work out to subagents (they run on cheaper tiers). Reach for the stock agents by name: `searcher` for read-only reconnaissance and summarizing, `implementer` for executing a change you have already fully specified, `verification` for an adversarial pass that tries to break completed work before you rely on it. Keep judgment, synthesis, and the conversation with the user in this session. Do not spawn a subagent for work you can finish in a couple of tool calls.";
+/**
+ * Standing rule that tickets must be read for their images, not just their
+ * text. Injected into EVERY process (driver, `/go` stage children, subagents)
+ * via brandSystemPrompt, so the guarantee holds by whichever method a ticket is
+ * read (the `linear` CLI, a connector tool, MCP, a direct API call). Once the
+ * image reaches `read`, the existing read → image_url → visionRerouteTier
+ * machinery takes over and lands the turn on a seeing tier automatically.
+ *
+ * Content constraints (parity with CHILD_HONESTY_PREAMBLE in
+ * pipeline/invocation.ts): must not contain the standalone word "pi", must not
+ * open with a `- ` bullet line, no emojis.
+ */
+export declare const TICKET_IMAGE_RULE: string;
+/**
+ * The injected-reminder framing (YAG-574, Change A prerequisite). Claude Code
+ * carries this exact sentence in every system prompt so its whole reminder
+ * family (including its own silent-turn reminder) is legible as system-
+ * injected rather than misread as part of the tool output they ride on. We
+ * adopt it for the same reason: our silent-turn nudge arrives stapled to a
+ * `psql`/`bash` result, and without this it reads as query output.
+ */
+export declare const SYSTEM_REMINDER_FRAMING: string;
+/**
+ * The communication contract (YAG-574, Change B). Adapted from Claude Code's
+ * `SendUserMessage`/`Brief` prompt: ack in one line before going to look, then
+ * work, then result; a checkpoint between them only when something useful
+ * happened — a decision, a surprise, a phase boundary — never filler like
+ * "running tests…"; keep messages tight and second-person. Complements the
+ * silent-turn nudge by spelling out what "keep the user updated" means.
+ */
+export declare const COMMUNICATION_CONTRACT: string;
+/**
+ * Write-findings-down (YAG-574, Change B). Claude Code's version ties the
+ * habit to result-clearing, which we do not do; reworded to the failure we
+ * actually saw, the model re-deriving the same answer turn after turn because
+ * nothing pushed it to commit a finding to its response (which is also what
+ * makes the user see it).
+ */
+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 PI_IDENTITY_RE: RegExp;

package/dist/extension/branding.js

@@ -75,6 +75,62 @@ export const ULTRA_DELEGATION_PARAGRAPH = "Delegation (ultra mode): the user has
  * module stays a pure string, with no env dependency of its own.
  */
 export const YAGNI_IDENTITY_DRIVER = `${YAGNI_IDENTITY}\n\n${DRIVER_DELEGATION_PARAGRAPH}`;
+/**
+ * Standing rule that tickets must be read for their images, not just their
+ * text. Injected into EVERY process (driver, `/go` stage children, subagents)
+ * via brandSystemPrompt, so the guarantee holds by whichever method a ticket is
+ * read (the `linear` CLI, a connector tool, MCP, a direct API call). Once the
+ * image reaches `read`, the existing read → image_url → visionRerouteTier
+ * machinery takes over and lands the turn on a seeing tier automatically.
+ *
+ * Content constraints (parity with CHILD_HONESTY_PREAMBLE in
+ * pipeline/invocation.ts): must not contain the standalone word "pi", must not
+ * open with a `- ` bullet line, no emojis.
+ */
+export const TICKET_IMAGE_RULE = "When you read or fetch a ticket from any tracker (Linear, Jira, or another), " +
+    "by any method — the `linear` CLI, a connector tool, MCP, or a direct API call — " +
+    "treat every image embedded in or attached to that ticket as required input, not " +
+    "decoration. Before you rely on the ticket's contents, get each image onto disk " +
+    "as a local file and read it with the `read` tool. Never claim to understand a " +
+    "ticket whose images you have not actually looked at.";
+/** Stable header that starts the ticket-image rule section (idempotency anchor). */
+const TICKET_IMAGE_RULE_HEADER = "## Rule: always read a ticket's images";
+/**
+ * The injected-reminder framing (YAG-574, Change A prerequisite). Claude Code
+ * carries this exact sentence in every system prompt so its whole reminder
+ * family (including its own silent-turn reminder) is legible as system-
+ * injected rather than misread as part of the tool output they ride on. We
+ * adopt it for the same reason: our silent-turn nudge arrives stapled to a
+ * `psql`/`bash` result, and without this it reads as query output.
+ */
+export const SYSTEM_REMINDER_FRAMING = "Tool results and user messages may include <system-reminder> tags. " +
+    "<system-reminder> tags contain useful information and reminders. They are " +
+    "automatically added by the system, and bear no direct relation to the " +
+    "specific tool results or user messages in which they appear.";
+/**
+ * The communication contract (YAG-574, Change B). Adapted from Claude Code's
+ * `SendUserMessage`/`Brief` prompt: ack in one line before going to look, then
+ * work, then result; a checkpoint between them only when something useful
+ * happened — a decision, a surprise, a phase boundary — never filler like
+ * "running tests…"; keep messages tight and second-person. Complements the
+ * silent-turn nudge by spelling out what "keep the user updated" means.
+ */
+export const COMMUNICATION_CONTRACT = "Keep the user in the loop as you work. Acknowledge in one line before going " +
+    "to look, then report the result when you have it. Between the two, send a " +
+    "short checkpoint when something useful happened — a decision made, a " +
+    "surprise, a phase change — not for filler like running a test or reading a " +
+    "file. Keep every message tight: the decision, the file:line, the PR number. " +
+    "Address the user directly (second person).";
+/**
+ * Write-findings-down (YAG-574, Change B). Claude Code's version ties the
+ * habit to result-clearing, which we do not do; reworded to the failure we
+ * actually saw, the model re-deriving the same answer turn after turn because
+ * nothing pushed it to commit a finding to its response (which is also what
+ * makes the user see it).
+ */
+export const WRITE_FINDINGS_DOWN = "When working with tool results, write down any important information you " +
+    "might need later in your response, so you do not re-derive it turn after " +
+    "turn.";
 /** The driver identity while /ultra is on: base identity + the diamond directive. */
 export const YAGNI_IDENTITY_ULTRA = `${YAGNI_IDENTITY}\n\n${ULTRA_DELEGATION_PARAGRAPH}`;
 /**
@@ -186,6 +242,26 @@ export function brandSystemPrompt(original, opts = {}) {
     if (rules && rulesHeader && !s.includes(rulesHeader)) {
         s = `${s}\n\n${rules}`;
     }
+    // 5b. Ticket-image rule — a standing directive placed AFTER the user's rules
+    // (so a long, noisy rules block cannot bury it) but BEFORE the closing
+    // reminder (which stays the most-recent instruction). The idempotency guard
+    // keys on the stable section header, mirroring the rules guard above.
+    if (!s.includes(TICKET_IMAGE_RULE_HEADER)) {
+        s = `${s}\n\n${TICKET_IMAGE_RULE_HEADER}\n${TICKET_IMAGE_RULE}`;
+    }
+    // 5c. YAG-574: the injected-reminder framing (which makes the silent-turn
+    // nudge legible) and the two communication lines (Change B). Appended after
+    // everything user-provided but before the closing reminder, each guarded by
+    // its own stable anchor so re-branding never duplicates them.
+    if (!s.includes(SYSTEM_REMINDER_FRAMING)) {
+        s = `${s}\n\n${SYSTEM_REMINDER_FRAMING}`;
+    }
+    if (!s.includes(COMMUNICATION_CONTRACT)) {
+        s = `${s}\n\n${COMMUNICATION_CONTRACT}`;
+    }
+    if (!s.includes(WRITE_FINDINGS_DOWN)) {
+        s = `${s}\n\n${WRITE_FINDINGS_DOWN}`;
+    }
     // 6. Closing reinforcement. Weak open-weight models weight the most recent
     // instruction heavily, and the user's own project files may name other
     // harnesses; a trailing reminder keeps the agent from claiming one as its own.

package/dist/extension/cmux/index.d.ts

@@ -1,3 +1,19 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export declare function registerCmuxBridge(pi: ExtensionAPI): void;
+import { type SessionState } from "./state.js";
+import { type SummarizeTitleResult } from "../sessionTitle/summarize.js";
+/** Injectable seams so the bridge's state machine is testable without a child. */
+export interface CmuxBridgeDeps {
+    summarize?: (prompt: string, deps?: {
+        cwd?: string;
+    }) => Promise<SummarizeTitleResult>;
+}
+export declare function registerCmuxBridge(pi: ExtensionAPI, deps?: CmuxBridgeDeps): void;
+/**
+ * The naming half of `publishCompletion`, extracted so the placeholder→final
+ * guard is directly testable without a child process. Once a session's title
+ * has been upgraded (or the upgrade was attempted), a later settle does nothing.
+ */
+export declare function upgradeTitleOnce(state: SessionState, summarize: (prompt: string, deps?: {
+    cwd?: string;
+}) => Promise<SummarizeTitleResult>, setTitle: ((title: string) => void) | undefined, onFail: (reason: string) => void, cwd: string): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/extension/cmux/index.js

@@ -3,7 +3,9 @@ import { join } from "node:path";
 import { CmuxDispatcher } from "./dispatcher.js";
 import { stateFor, snapshotContext, beginTurn, currentTurnId, finishTurn, settleTurn, lastAssistantMessage, firstString, objectValue, warn, } from "./state.js";
 import { sendHook, ensureResumeBinding, clearResumeBinding, releaseSessionRuntime, } from "./hooks.js";
-import { renameWorkspaceFromPrompt } from "./naming.js";
+import { isDriverCaller } from "../config.js";
+import { sessionTitle } from "../sessionTitle/title.js";
+import { summarizeTitle } from "../sessionTitle/summarize.js";
 /** Remove a stale cmux-installed extension so hooks don't double-fire. */
 function removeStaleManagedExtension() {
     const agentDir = process.env.PI_CODING_AGENT_DIR || process.env.YAGNI_CODING_AGENT_DIR;
@@ -24,11 +26,17 @@ function removeStaleManagedExtension() {
     }
     catch { }
 }
-export function registerCmuxBridge(pi) {
+export function registerCmuxBridge(pi, deps = {}) {
     if (!process.env.CMUX_SURFACE_ID)
         return;
     if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
         return;
+    // A child process (guardian consult, advisor, /go stage, subagent) has no
+    // direct user — reporting its internals to cmux would overwrite the driver
+    // session's card with e.g. the Guardian consult prompt/verdict.
+    if (!isDriverCaller())
+        return;
+    const summarize = deps.summarize ?? summarizeTitle;
     const dispatcher = new CmuxDispatcher();
     const sessionStates = new Map();
     const lifecycleTails = new Map();
@@ -74,6 +82,18 @@ export function registerCmuxBridge(pi) {
         if (typeof event.prompt === "string" && event.prompt.trim()) {
             st.lastPrompt = event.prompt.trim();
         }
+        // Set the terminal title to the heuristic session title immediately at the
+        // first prompt (mirroring Claude's derive-then-upgrade: the tab is named
+        // from the prompt, not the model reply). cmux freezes auto-titling on its
+        // own once the user sets a manual name (customTitle), so we never clobber it.
+        // The optional LLM upgrade happens later on agent_settled.
+        if (!st.nameState && typeof event.prompt === "string" && event.prompt.trim()) {
+            const placeholder = sessionTitle(event.prompt.trim());
+            if (placeholder) {
+                st.nameState = "placeholder";
+                context.setTitle?.(placeholder);
+            }
+        }
         enqueueLifecycleTask(sessionId, context, () => sendHook(dispatcher, "prompt-submit", context, { prompt: event.prompt, turn_id: turnId }));
     });
     pi.on("agent_end", (event, ctx) => {
@@ -104,7 +124,7 @@ export function registerCmuxBridge(pi) {
             return;
         const completion = settleTurn(sessionStates, sessionId);
         if (completion) {
-            enqueueLifecycleTask(sessionId, context, () => publishCompletion(dispatcher, sessionStates, context, sessionId, completion));
+            enqueueLifecycleTask(sessionId, context, () => publishCompletion(dispatcher, sessionStates, context, sessionId, completion, summarize));
         }
     });
     pi.on("session_shutdown", async (event, ctx) => {
@@ -133,7 +153,27 @@ export function registerCmuxBridge(pi) {
         });
     });
 }
-async function publishCompletion(dispatcher, sessionStates, context, sessionId, completion) {
+/**
+ * The naming half of `publishCompletion`, extracted so the placeholder→final
+ * guard is directly testable without a child process. Once a session's title
+ * has been upgraded (or the upgrade was attempted), a later settle does nothing.
+ */
+export async function upgradeTitleOnce(state, summarize, setTitle, onFail, cwd) {
+    if (state.nameState !== "placeholder")
+        return;
+    state.nameState = "final";
+    const prompt = state.lastPrompt;
+    if (!prompt)
+        return;
+    const result = await summarize(prompt, { cwd });
+    if (result.ok) {
+        setTitle?.(result.title);
+    }
+    else {
+        onFail(result.reason);
+    }
+}
+async function publishCompletion(dispatcher, sessionStates, context, sessionId, completion, summarize) {
     const stopPayload = {
         last_assistant_message: completion.lastAssistantMessage,
         turn_id: completion.turnId,
@@ -147,9 +187,8 @@ async function publishCompletion(dispatcher, sessionStates, context, sessionId,
         stopPayload.cmux_notification_routed = true;
     await sendHook(dispatcher, "stop", context, stopPayload);
     const state = stateFor(sessionStates, sessionId);
-    if (!state.hasNamed) {
-        renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId);
-        state.hasNamed = true;
-    }
+    // Upgrade the heuristic placeholder to an LLM-summarized title, once (see
+    // upgradeTitleOnce). A failed summary keeps the placeholder in place.
+    await upgradeTitleOnce(state, summarize, context.setTitle, (reason) => warn(context, "title summary failed; keeping heuristic title", { session_id: sessionId, reason }), context.cwd);
 }
 //# sourceMappingURL=index.js.map

package/dist/extension/cmux/state.d.ts

@@ -4,18 +4,22 @@ export interface PendingCompletion {
     notificationType: string;
     turnId: string;
 }
+/** The naming lifecycle of a session's cmux workspace title. */
+export type NameState = "unnamed" | "placeholder" | "final";
 export interface SessionState {
     nextTurn: number;
     activeTurnId?: string;
     pendingCompletion?: PendingCompletion;
     stopped: boolean;
     lastPrompt?: string;
-    hasNamed?: boolean;
+    nameState?: NameState;
 }
 export interface PiExtensionContextSnapshot {
     readonly sessionId: string | null;
     readonly cwd: string;
     readonly notifyWarning?: () => void;
+    /** Set the terminal tab/window title (pi's OSC 0), mirroring Claude's title channel. */
+    readonly setTitle?: (title: string) => void;
 }
 export declare function firstString(...values: unknown[]): string | null;
 export declare function objectValue(value: unknown, keys: string[]): unknown;

package/dist/extension/cmux/state.js

@@ -1,3 +1,6 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { codeStateHome } from "../stateHome.js";
 export function firstString(...values) {
     for (const value of values) {
         if (typeof value === "string" && value.trim().length > 0)
@@ -67,14 +70,18 @@ export function snapshotContext(ctx) {
         return { sessionId: null, cwd: process.cwd() };
     }
     let notifyWarning;
+    let setTitle;
     try {
         const ui = ctx.ui;
         if (typeof ui?.notify === "function") {
             notifyWarning = () => ui.notify?.("cmux integration warning — check the terminal for details", "warning");
         }
+        if (typeof ui?.setTitle === "function") {
+            setTitle = (title) => ui.setTitle?.(title);
+        }
     }
     catch { }
-    return { sessionId: sessionIdFrom(ctx), cwd: cwdFrom(ctx), notifyWarning };
+    return { sessionId: sessionIdFrom(ctx), cwd: cwdFrom(ctx), notifyWarning, setTitle };
 }
 export function stateFor(sessionStates, sessionId) {
     let state = sessionStates.get(sessionId);
@@ -126,11 +133,18 @@ export function settleTurn(sessionStates, sessionId) {
 }
 export function warn(ctx, message, details = {}, notifyUser = false) {
     const payload = { source: "yagni-cmux-bridge", level: "warning", message, ...details };
+    // The TUI is in raw mode: writing to stdout/stderr corrupts the terminal (the
+    // JSON was landing at the prompt cursor). Route warnings/errors to a rotating
+    // local log instead — never to the terminal.
     try {
-        console.warn(JSON.stringify(payload));
+        if (!process.env.NODE_TEST_CONTEXT) {
+            const path = join(codeStateHome(null), "logs", "cmux-bridge.log");
+            mkdirSync(dirname(path), { recursive: true });
+            appendFileSync(path, JSON.stringify({ ts: new Date().toISOString(), ...payload }) + "\n", "utf8");
+        }
     }
     catch {
-        console.warn(`[yagni-cmux-bridge] ${message}`);
+        /* logging must never throw into the editor */
     }
     if (notifyUser) {
         try {

package/dist/extension/config.d.ts

@@ -90,6 +90,14 @@ export interface CatalogResult {
      * "off" (fail toward not sending).
      */
     guardianStorage: GuardianStorageTier;
+    /**
+     * Backend-owned per-request Guardian wall ceiling (YAG-562). The client
+     * derives its whole-consult deadline from this instead of a hardcoded abort.
+     * Absent on older backends → the extension falls back to its default.
+     */
+    guardianTimeoutMs?: number;
+    /** Number of attempts the backend makes (primary + one failover). */
+    guardianMaxAttempts?: number;
 }
 /**
  * Fetch the YAGNI model catalog at startup.

package/dist/extension/config.js

@@ -91,6 +91,12 @@ export async function fetchCatalog(opts) {
         guardianStorage: data.guardianStorage === "raw" || data.guardianStorage === "hash"
             ? data.guardianStorage
             : "off",
+        ...(typeof data.guardianTimeoutMs === "number" && Number.isFinite(data.guardianTimeoutMs) && data.guardianTimeoutMs > 0
+            ? { guardianTimeoutMs: data.guardianTimeoutMs }
+            : {}),
+        ...(typeof data.guardianMaxAttempts === "number" && Number.isSafeInteger(data.guardianMaxAttempts) && data.guardianMaxAttempts >= 1
+            ? { guardianMaxAttempts: data.guardianMaxAttempts }
+            : {}),
     };
 }
 /** Shape-check for a caller label: mirrors the model proxy's own validation regex. */

package/dist/extension/index.d.ts

@@ -121,7 +121,7 @@ export { makeAskYagniTool } from "./askYagniTool.js";
 export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
-export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, } from "./permission/guardian.js";
+export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs, } from "./permission/guardian.js";
 export type { GuardianOutcome, GuardianVerdict, GuardianState, GuardianStateHandle, GuardianLimits, ReviewResult, ReviewCommandDeps, } from "./permission/guardian.js";
 export type { Citation, MakeAskYagniToolOptions } from "./askYagniTool.js";
 export { makeReviewBusinessMatchTool } from "./reviewTool.js";

package/dist/extension/index.js

@@ -5,7 +5,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
 import { appendGrant, loadGrants, resolveRepoKey, storagePrefix } from "./permission/approvedPrefixes.js";
 import { redactCommand } from "./redact.js";
-import { formatGuardianSubtotal, GUARDIAN_MODEL_TIER, makeGuardianState, resolveGuardianLimits, reviewCommand } from "./permission/guardian.js";
+import { formatGuardianSubtotal, GUARDIAN_MODEL_TIER, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs } from "./permission/guardian.js";
 import { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 import { makeAskYagniTool } from "./askYagniTool.js";
 import { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
@@ -45,6 +45,7 @@ import { buildYagniProvider } from "./provider.js";
 import { registerChipEditor } from "./chipEditor.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
+import { registerSilentTurnReminder } from "./silentTurnReminder.js";
 function isEvalMode(env = process.env) {
     return env.YAGNI_CODE_EVAL_MODE === "1";
 }
@@ -135,7 +136,7 @@ export async function registerYagni(pi, deps = {}) {
     // after_provider_response event does NOT fire on a 401 (the OpenAI SDK throws
     // before onResponse is reached), so message_end is the only seam.
     let lastAuthRecovery = null;
-    const { models: fullCatalog, guardianEnabled: workspaceGuardianEnabled, guardianStorage: guardianStorageTier, } = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    const { models: fullCatalog, guardianEnabled: workspaceGuardianEnabled, guardianStorage: guardianStorageTier, guardianTimeoutMs: guardianTimeoutAdvertisedMs, guardianMaxAttempts: guardianMaxAttemptsAdvertised, } = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
     // Lock the interactive session to the `advanced` tier only. The backend
     // catalog returns all tiers, but only `advanced` is registered with the
     // `yagni` provider, so /model and Ctrl+P show a single entry. Child
@@ -191,6 +192,11 @@ export async function registerYagni(pi, deps = {}) {
     // 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
+    // measured behavior is not perturbed.
+    registerSilentTurnReminder(pi, { isDriver: isDriverCaller(env), evalMode, env: deps.env });
     // Image paste with [Image #N] chips: replaces the editor on
     // session_start (TUI mode) so pasting a screenshot drops a chip instead of a
     // temp path, and registers the input transform that turns chips into image
@@ -272,6 +278,16 @@ export async function registerYagni(pi, deps = {}) {
         !workspaceGuardianEnabled;
     const guardianTier = env.YAGNI_GUARDIAN_TIER ?? GUARDIAN_MODEL_TIER;
     const guardianLimits = resolveGuardianLimits(env);
+    // YAG-562: the backend owns the Guardian timeout and retries once. The client
+    // derives its whole-consult deadline from the catalog's advertised wall
+    // ceiling + attempt count (plus a boot/tool overhead margin) rather than
+    // hard-aborting at 15s and preempting the backend's retry. Absent an
+    // advertisement (older backend) this keeps the default.
+    const guardianTimeoutMs = deriveGuardianTimeoutMs(guardianLimits, {
+        ...(guardianTimeoutAdvertisedMs !== undefined ? { timeoutMs: guardianTimeoutAdvertisedMs } : {}),
+        ...(guardianMaxAttemptsAdvertised !== undefined ? { maxAttempts: guardianMaxAttemptsAdvertised } : {}),
+    });
+    guardianLimits.timeoutMs = guardianTimeoutMs;
     // YAG-510: guardian.log stays the sanitized local debug sink (hash-only,
     // never the command). The remote guardian-events stream below is the
     // separate, opt-in, per-workspace analytics sink; the two are independent.
@@ -887,7 +903,7 @@ export { makeAskYagniTool } from "./askYagniTool.js";
 export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
-export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, } from "./permission/guardian.js";
+export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs, } from "./permission/guardian.js";
 export { makeReviewBusinessMatchTool } from "./reviewTool.js";
 export { makeRecordEngineeringContextTool } from "./recordContextTool.js";
 export { makeRecordDecisionTool } from "./recordDecisionTool.js";

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

@@ -45,13 +45,32 @@ export interface GuardianLimits {
     timeoutMs: number;
 }
 export declare const DEFAULT_GUARDIAN_LIMITS: GuardianLimits;
+/**
+ * Client-side safety margin on top of the backend's advertised wall ceiling
+ * (YAG-562). The backend now owns the real timeout (first-output + wall) and
+ * retries once, so the client must NOT pre-empt it; it derives its own
+ * deadline from the catalog's `guardianTimeoutMs * attempts` plus this margin
+ * for child boot + read-tool round-trips + teardown, and treats that bound as
+ * a last-resort floor, not the normal path.
+ */
+export declare const GUARDIAN_CLIENT_OVERHEAD_MS = 10000;
 /**
  * Resolve Guardian limits from the environment. `YAGNI_GUARDIAN_MAX_REVIEWS`
  * overrides the sliding-window review cap; anything non-numeric or < 1 falls
  * back to the default (a bad value must never zero out the cap and lock the
- * session).
+ * session). `YAGNI_GUARDIAN_TIMEOUT_MS` overrides the consult deadline for a
+ * single developer (previously documented but unwired).
  */
 export declare function resolveGuardianLimits(env?: Record<string, string | undefined>): GuardianLimits;
+/**
+ * Derive the client's whole-consult deadline from the backend's advertised
+ * wall ceiling and attempt count (YAG-562). Falls back to the resolved limit
+ * when the catalog omitted the fields (older backend).
+ */
+export declare function deriveGuardianTimeoutMs(base: GuardianLimits, advertised: {
+    timeoutMs?: number;
+    maxAttempts?: number;
+}): number;
 /** The model tier the Guardian runs on. Configurable via YAGNI_GUARDIAN_TIER. */
 export declare const GUARDIAN_MODEL_TIER = "efficient";
 /** Read-only tools — the Guardian can read files for context but cannot write or execute. */

package/dist/extension/permission/guardian.js

@@ -33,17 +33,41 @@ export const DEFAULT_GUARDIAN_LIMITS = {
     maxConsecutiveDenials: 3,
     timeoutMs: 15_000,
 };
+/**
+ * Client-side safety margin on top of the backend's advertised wall ceiling
+ * (YAG-562). The backend now owns the real timeout (first-output + wall) and
+ * retries once, so the client must NOT pre-empt it; it derives its own
+ * deadline from the catalog's `guardianTimeoutMs * attempts` plus this margin
+ * for child boot + read-tool round-trips + teardown, and treats that bound as
+ * a last-resort floor, not the normal path.
+ */
+export const GUARDIAN_CLIENT_OVERHEAD_MS = 10_000;
 /**
  * Resolve Guardian limits from the environment. `YAGNI_GUARDIAN_MAX_REVIEWS`
  * overrides the sliding-window review cap; anything non-numeric or < 1 falls
  * back to the default (a bad value must never zero out the cap and lock the
- * session).
+ * session). `YAGNI_GUARDIAN_TIMEOUT_MS` overrides the consult deadline for a
+ * single developer (previously documented but unwired).
  */
 export function resolveGuardianLimits(env = process.env) {
-    const raw = env.YAGNI_GUARDIAN_MAX_REVIEWS?.trim();
-    const parsed = raw ? Number.parseInt(raw, 10) : NaN;
-    const maxReviews = Number.isFinite(parsed) && parsed >= 1 ? parsed : DEFAULT_GUARDIAN_LIMITS.maxReviews;
-    return { ...DEFAULT_GUARDIAN_LIMITS, maxReviews };
+    const rawReviews = env.YAGNI_GUARDIAN_MAX_REVIEWS?.trim();
+    const parsedReviews = rawReviews ? Number.parseInt(rawReviews, 10) : NaN;
+    const maxReviews = Number.isFinite(parsedReviews) && parsedReviews >= 1 ? parsedReviews : DEFAULT_GUARDIAN_LIMITS.maxReviews;
+    const rawTimeout = env.YAGNI_GUARDIAN_TIMEOUT_MS?.trim();
+    const parsedTimeout = rawTimeout ? Number.parseInt(rawTimeout, 10) : NaN;
+    const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout >= 1 ? parsedTimeout : DEFAULT_GUARDIAN_LIMITS.timeoutMs;
+    return { ...DEFAULT_GUARDIAN_LIMITS, maxReviews, timeoutMs };
+}
+/**
+ * Derive the client's whole-consult deadline from the backend's advertised
+ * wall ceiling and attempt count (YAG-562). Falls back to the resolved limit
+ * when the catalog omitted the fields (older backend).
+ */
+export function deriveGuardianTimeoutMs(base, advertised) {
+    if (advertised.timeoutMs !== undefined && advertised.maxAttempts !== undefined) {
+        return advertised.timeoutMs * advertised.maxAttempts + GUARDIAN_CLIENT_OVERHEAD_MS;
+    }
+    return base.timeoutMs;
 }
 /** The model tier the Guardian runs on. Configurable via YAGNI_GUARDIAN_TIER. */
 export const GUARDIAN_MODEL_TIER = "efficient";
@@ -190,7 +214,19 @@ export async function reviewCommand(command, deps) {
         if (deps.signal?.aborted) {
             return { verdict: null, error: "aborted", cost };
         }
+        // The backend now owns the timeout (YAG-562) and streams a terminal error
+        // frame when the consult fails; a result with a `stopReason: "error"` or an
+        // `errorMessage` is a real backend failure, NOT the silent-empty shape. Map
+        // it to a concrete error so the gate shows "review timed out" / "service
+        // unavailable" instead of the misleading "no response". A timeout-shaped
+        // message (stream_idle_timeout / "timed out") is distinguished so the gate
+        // can add its timeout-specific note.
         if (!output) {
+            if (result.stopReason === "error" || result.errorMessage) {
+                const msg = (result.errorMessage ?? "").toLowerCase();
+                const isTimeout = /stream_idle_timeout|timed out|idle|wall|timeout/i.test(msg);
+                return { verdict: null, error: isTimeout ? "timeout" : "network", cost };
+            }
             return { verdict: null, error: "empty", cost };
         }
         const verdict = parseVerdict(output);

package/dist/extension/pipeline/personas.js

@@ -184,6 +184,14 @@ Output ONLY a JSON object with this exact shape:
 {"outcome":"allow"|"ask"|"deny","riskLevel":"low"|"medium"|"high"|"critical","rationale":"see rationale rules"}
 
 Do not output anything else after the JSON. No markdown fences, only the JSON object.`;
+const TITLE_BODY = `You produce a session title from a user's prompt. Output ONLY a concise, sentence-case title of 3-7 words that captures the main topic or goal. Capitalize only the first word and proper nouns. Do not include a ticket code in the title text itself (the caller prepends it). No markdown, no prose, no quotes — just the title on one line.
+
+Good:
+Fix the login page
+Add OAuth authentication
+
+Bad (too vague): Code changes
+Bad (too long): Investigate and fix the login button not responding on mobile devices`;
 /** Persona body keyed by the agent name referenced in `stages.ts`. */
 export const PERSONA_BODIES = {
     scout: SCOUT_BODY,
@@ -192,6 +200,7 @@ export const PERSONA_BODIES = {
     reviewer: REVIEWER_BODY,
     advisor: ADVISOR_BODY,
     guardian: GUARDIAN_BODY,
+    title: TITLE_BODY,
     orchestrator: [ORCHESTRATOR_BODY, PARTITION_CONTRACT].join("\n\n"),
     synthesizer: SYNTHESIZER_BODY,
 };

package/dist/extension/sessionTitle/summarize.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The I/O half of session titling: summarize a prompt into a title via a
+ * locked-down efficient-tier child (same `runStage` seam the Guardian and
+ * advisor use). Fully optional — any failure returns undefined so the caller
+ * falls back to the heuristic title without ever blocking a turn.
+ */
+import { runStage as defaultRunStage } from "../pipeline/runner.js";
+import type { PipelineStage } from "../pipeline/types.js";
+/** The model tier the title child runs on (read-only, like the Guardian). */
+export declare const TITLE_MODEL_TIER = "efficient";
+/** The read-only tools the title child may use (only `read`, for context). */
+export declare const TITLE_TOOLS: string[];
+/** Default wall-clock timeout for the title consult (matches Guardian). */
+export declare const DEFAULT_TITLE_TIMEOUT_MS = 15000;
+/**
+ * The synthetic stage a title consult runs as. Borrows the `plan` StageId (same
+ * pattern as the advisor/guardian) so it doesn't ripple into /go feed/reducers.
+ * The agent name selects the `title` persona from PERSONA_BODIES.
+ */
+export declare function titleStage(modelTier?: string): PipelineStage;
+export interface SummarizeTitleDeps {
+    runStage?: typeof defaultRunStage;
+    timeoutMs?: number;
+    cwd?: string;
+}
+/** The outcome of a title consult: a prefixed title, or a failure reason. */
+export type SummarizeTitleResult = {
+    ok: true;
+    title: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Summarize a prompt into a title. Returns `{ title }` on success, or
+ * `{ reason }` on any failure (timeout, abort, non-zero exit, empty or unusable
+ * output) — the caller falls back to the heuristic and logs the reason.
+ */
+export declare function summarizeTitle(prompt: string, deps?: SummarizeTitleDeps): Promise<SummarizeTitleResult>;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/extension/sessionTitle/summarize.js

@@ -0,0 +1,63 @@
+/**
+ * The I/O half of session titling: summarize a prompt into a title via a
+ * locked-down efficient-tier child (same `runStage` seam the Guardian and
+ * advisor use). Fully optional — any failure returns undefined so the caller
+ * falls back to the heuristic title without ever blocking a turn.
+ */
+import { runStage as defaultRunStage } from "../pipeline/runner.js";
+import { parseSummarizedTitle } from "./title.js";
+/** The model tier the title child runs on (read-only, like the Guardian). */
+export const TITLE_MODEL_TIER = "efficient";
+/** The read-only tools the title child may use (only `read`, for context). */
+export const TITLE_TOOLS = ["read"];
+/** Default wall-clock timeout for the title consult (matches Guardian). */
+export const DEFAULT_TITLE_TIMEOUT_MS = 15_000;
+/**
+ * The synthetic stage a title consult runs as. Borrows the `plan` StageId (same
+ * pattern as the advisor/guardian) so it doesn't ripple into /go feed/reducers.
+ * The agent name selects the `title` persona from PERSONA_BODIES.
+ */
+export function titleStage(modelTier = TITLE_MODEL_TIER) {
+    return {
+        id: "plan",
+        agent: "title",
+        model: modelTier,
+        tools: TITLE_TOOLS,
+        taskTemplate: "{ticket}",
+    };
+}
+/**
+ * Summarize a prompt into a title. Returns `{ title }` on success, or
+ * `{ reason }` on any failure (timeout, abort, non-zero exit, empty or unusable
+ * output) — the caller falls back to the heuristic and logs the reason.
+ */
+export async function summarizeTitle(prompt, deps = {}) {
+    const runStage = deps.runStage ?? defaultRunStage;
+    const timeoutMs = deps.timeoutMs ?? DEFAULT_TITLE_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    try {
+        const result = await runStage(titleStage(), { ticket: `Summarize this session into a short title:\n\n${prompt}` }, {
+            cwd: deps.cwd ?? process.cwd(),
+            signal: controller.signal,
+            callerLabel: "title",
+        });
+        if (result.exitCode !== 0) {
+            const stderr = result.stderr?.trim().slice(0, 200);
+            return { ok: false, reason: stderr ? `exit=${result.exitCode} ${stderr}` : `exit=${result.exitCode}` };
+        }
+        const title = parseSummarizedTitle(prompt, result.finalOutput);
+        if (title)
+            return { ok: true, title };
+        return { ok: false, reason: `empty_output output=${JSON.stringify(result.finalOutput.slice(0, 200))}` };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { ok: false, reason: `threw ${msg.slice(0, 200)}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=summarize.js.map

package/dist/extension/sessionTitle/title.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pure session-title derivation — the reusable half of naming an agent session.
+ * No cmux, no workspace, no I/O: just "given a prompt, what's a good title".
+ *
+ * cmux is the current (and only) consumer, but this module is deliberately
+ * cmux-free so a future consumer (terminal title, a resume hint, the Feed) can
+ * reuse it without importing cmux vocabulary.
+ */
+/** Extract a ticket code from a prompt, or null when none is present. */
+export declare function ticketCode(prompt: string): string | null;
+/** The heuristic fallback title: the first 8 words, capped at 60 chars. */
+export declare function titleFromPrompt(prompt: string): string | undefined;
+/**
+ * Compose a session title from a prompt, prepending the ticket code when one is
+ * present. The code is stripped from the derived body so it doesn't appear
+ * twice ("YAG-532: work on YAG-532 …").
+ */
+export declare function sessionTitle(prompt: string, body?: string): string | undefined;
+/**
+ * Normalize a model-produced title into the same shape `sessionTitle` emits.
+ * Returns undefined when the model's output is empty, whitespace, or otherwise
+ * unusable — the caller then falls back to the heuristic.
+ */
+export declare function parseSummarizedTitle(prompt: string, raw: string): string | undefined;
+/** The maximum chars `parseSummarizedTitle` may return (the same cap). */
+export declare const SESSION_TITLE_MAX_LEN = 60;
+//# sourceMappingURL=title.d.ts.map

package/dist/extension/sessionTitle/title.js

@@ -0,0 +1,57 @@
+/**
+ * Pure session-title derivation — the reusable half of naming an agent session.
+ * No cmux, no workspace, no I/O: just "given a prompt, what's a good title".
+ *
+ * cmux is the current (and only) consumer, but this module is deliberately
+ * cmux-free so a future consumer (terminal title, a resume hint, the Feed) can
+ * reuse it without importing cmux vocabulary.
+ */
+/** The ticket-code shape ("YAG-532", "PROJ-123"), matching the backend's IDENTIFIER_RE. */
+const TICKET_ID_RE = /\b[A-Z][A-Z0-9]*-\d+\b/i;
+const MAX_TITLE_LEN = 60;
+/** Extract a ticket code from a prompt, or null when none is present. */
+export function ticketCode(prompt) {
+    return prompt.match(TICKET_ID_RE)?.[0]?.toUpperCase() ?? null;
+}
+/** The heuristic fallback title: the first 8 words, capped at 60 chars. */
+export function titleFromPrompt(prompt) {
+    const words = prompt.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return undefined;
+    return words.slice(0, 8).join(" ").slice(0, MAX_TITLE_LEN) || undefined;
+}
+/**
+ * Compose a session title from a prompt, prepending the ticket code when one is
+ * present. The code is stripped from the derived body so it doesn't appear
+ * twice ("YAG-532: work on YAG-532 …").
+ */
+export function sessionTitle(prompt, body) {
+    const code = ticketCode(prompt);
+    // Derive the body from the prompt with the ticket code removed (unless the
+    // caller supplied an already-summarized body, in which case prefer it).
+    const effectiveBody = body ?? titleFromPrompt(code ? prompt.replace(TICKET_ID_RE, "") : prompt);
+    if (!code)
+        return effectiveBody;
+    if (!effectiveBody)
+        return code;
+    return `${code}: ${effectiveBody}`.slice(0, MAX_TITLE_LEN);
+}
+/**
+ * Normalize a model-produced title into the same shape `sessionTitle` emits.
+ * Returns undefined when the model's output is empty, whitespace, or otherwise
+ * unusable — the caller then falls back to the heuristic.
+ */
+export function parseSummarizedTitle(prompt, raw) {
+    const cleaned = raw.trim().replace(/\s+/g, " ").replace(/^["']|["']$/g, "");
+    if (!cleaned)
+        return undefined;
+    // Strip any ticket-code token the model echoed back into its summary (the
+    // prompt carries the code, and models repeat it) so the composed title never
+    // doubles the prefix ("YAG-485: YAG-485 …"). Deterministic, not prompt hygiene.
+    const code = ticketCode(prompt);
+    const body = code ? cleaned.replace(TICKET_ID_RE, "").trim().replace(/\s+/g, " ") : cleaned;
+    return sessionTitle(prompt, body);
+}
+/** The maximum chars `parseSummarizedTitle` may return (the same cap). */
+export const SESSION_TITLE_MAX_LEN = MAX_TITLE_LEN;
+//# sourceMappingURL=title.js.map

package/dist/extension/silentTurnReminder.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Silent-turn reminder — the harness fix for YAG-574.
+ *
+ * The failure behind that ticket was a termination failure, not a discovery
+ * one: the model had assembled the full answer in thinking, re-derived it 15
+ * times, and never converted "I have an answer" into "the turn ends." Nothing
+ * in the harness nudges it across that boundary when it goes quiet.
+ *
+ * This module is that nudge. It counts assistant turns and wall-clock time
+ * since the model last *spoke* (a non-empty visible text block, or a call to a
+ * user-facing tool), and when that silence passes a configurable threshold it
+ * appends a one-line reminder to the next tool result — the same
+ * result-modification seam the todos staleness reminder and ambient recall
+ * already ride, so it reaches the model mid-run without spending a turn.
+ *
+ * Structure mirrors Claude Code's `silent_turn_reminder` (the problem is real
+ * and already solved upstream): same trigger semantics, same single-fixed-
+ * sentence escalation, same "suppress on the turn after a user message" rule.
+ * Two deliberate deviations, both justified on the ticket:
+ *  - trigger is wall-clock (90s default), not turn-count, because turn-count
+ *    thresholds are tuned to a ~5s turn and ours drifted to ~34s;
+ *  - no per-stretch nudge cap, because the cap is the exact thing that silences
+ *    the mechanism during the silence it exists for.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/**
+ * Default silence trigger, in milliseconds. Calibrated (see the ticket's
+ * trigger table) to nudge at roughly Claude Code's on-observed density while
+ * still covering the broken session's 25-minute dead zone.
+ */
+export declare const DEFAULT_SILENT_INTERVAL_MS = 90000;
+/**
+ * Minimum assistant turns of silence before a reminder is eligible. Guards a
+ * single long tool call from counting as "the user is being ignored" when the
+ * model simply spent a while on one tool.
+ */
+export declare const MIN_SILENT_TURNS = 2;
+/**
+ * Tools that count as "speaking to the user." Claude Code's whitelist maps to
+ * `AskUserQuestion`, `SendUserMessage`, `Brief`, `ExitPlanMode`,
+ * `SendUserFile`; ours are the three tools that surface something directly to
+ * the human this session serves. A call to one of these is a substantive
+ * utterance even when the assistant emitted no visible text block.
+ */
+export declare const USER_FACING_TOOLS: Set<string>;
+export declare const SILENT_REMINDER_ENV = "YAGNI_SILENT_TURN_REMINDER";
+export declare const SILENT_REMINDER_SECONDS_ENV = "YAGNI_SILENT_TURN_REMINDER_SECONDS";
+/** Disable the whole mechanism ("0"/"off"), or resolve the trigger override. */
+export declare function silentReminderDisabled(env?: NodeJS.ProcessEnv): boolean;
+/** Resolve the trigger interval: env seconds override wins, else the default. */
+export declare function resolveSilentIntervalMs(env?: NodeJS.ProcessEnv): number;
+/** The minimal slice of an assistant message the reminder logic cares about. */
+interface AssistantLike {
+    content?: Array<{
+        type?: string;
+        text?: string;
+        name?: string;
+    }>;
+}
+/**
+ * PURE: whether the assistant emitted any non-empty, visible text block this
+ * turn. `thinking` blocks deliberately do NOT count — 525k chars of thinking
+ * is still silence to the user.
+ */
+export declare function hasSubstantiveText(message: AssistantLike): boolean;
+/**
+ * PURE: whether the assistant "spoke" this turn — visible text, OR a call to a
+ * user-facing tool (which is itself an utterance to the user, even without a
+ * text block).
+ */
+export declare function didSpeak(message: AssistantLike): boolean;
+/**
+ * PURE: is a reminder due? The turn count must pass {@link MIN_SILENT_TURNS},
+ * the wall-clock silence must pass the configured interval, and the spacing
+ * between nudges must pass the same interval. `lastNudgeAt` is `null` before
+ * any nudge has fired (still eligible once the other gates pass).
+ */
+export declare function shouldRemind(input: {
+    msSinceSpoke: number;
+    turnsSinceSpoke: number;
+    msSinceLastNudge: number | null;
+    intervalMs: number;
+}): boolean;
+/**
+ * The injected payload. Claude Code's wording plus one clause for the failure
+ * we actually saw (the model holding an assembled answer and never giving it).
+ * Wrapped in `<system-reminder>` tags — the framing branding.ts teaches the
+ * model to parse as system-injected, not part of the tool output.
+ */
+export declare function formatSilentReminder(): string;
+export interface RegisterSilentTurnReminderDeps {
+    /** Only the interactive driver is nudged; children/subagents/advisor/no-op. */
+    isDriver?: boolean;
+    /** Eval mode (headless evals, scoping sessions) never nudges. */
+    evalMode?: boolean;
+    /** Env seam (defaults to process.env). */
+    env?: NodeJS.ProcessEnv;
+    /** Clock seam (defaults to Date.now). */
+    now?: () => number;
+}
+/**
+ * Wire the silent-turn reminder. No handlers are registered for non-driver
+ * processes, eval mode, or when disabled — so children, subagents, advisor
+ * consults, and headless evals are untouched, and the kill switch is a true
+ * no-op.
+ */
+export declare function registerSilentTurnReminder(pi: ExtensionAPI, deps?: RegisterSilentTurnReminderDeps): void;
+export {};
+//# sourceMappingURL=silentTurnReminder.d.ts.map

package/dist/extension/silentTurnReminder.js

@@ -0,0 +1,217 @@
+/**
+ * Silent-turn reminder — the harness fix for YAG-574.
+ *
+ * The failure behind that ticket was a termination failure, not a discovery
+ * one: the model had assembled the full answer in thinking, re-derived it 15
+ * times, and never converted "I have an answer" into "the turn ends." Nothing
+ * in the harness nudges it across that boundary when it goes quiet.
+ *
+ * This module is that nudge. It counts assistant turns and wall-clock time
+ * since the model last *spoke* (a non-empty visible text block, or a call to a
+ * user-facing tool), and when that silence passes a configurable threshold it
+ * appends a one-line reminder to the next tool result — the same
+ * result-modification seam the todos staleness reminder and ambient recall
+ * already ride, so it reaches the model mid-run without spending a turn.
+ *
+ * Structure mirrors Claude Code's `silent_turn_reminder` (the problem is real
+ * and already solved upstream): same trigger semantics, same single-fixed-
+ * sentence escalation, same "suppress on the turn after a user message" rule.
+ * Two deliberate deviations, both justified on the ticket:
+ *  - trigger is wall-clock (90s default), not turn-count, because turn-count
+ *    thresholds are tuned to a ~5s turn and ours drifted to ~34s;
+ *  - no per-stretch nudge cap, because the cap is the exact thing that silences
+ *    the mechanism during the silence it exists for.
+ */
+import { logTurnLifecycle } from "./turnLog.js";
+/**
+ * Default silence trigger, in milliseconds. Calibrated (see the ticket's
+ * trigger table) to nudge at roughly Claude Code's on-observed density while
+ * still covering the broken session's 25-minute dead zone.
+ */
+export const DEFAULT_SILENT_INTERVAL_MS = 90_000;
+/**
+ * Minimum assistant turns of silence before a reminder is eligible. Guards a
+ * single long tool call from counting as "the user is being ignored" when the
+ * model simply spent a while on one tool.
+ */
+export const MIN_SILENT_TURNS = 2;
+/**
+ * Tools that count as "speaking to the user." Claude Code's whitelist maps to
+ * `AskUserQuestion`, `SendUserMessage`, `Brief`, `ExitPlanMode`,
+ * `SendUserFile`; ours are the three tools that surface something directly to
+ * the human this session serves. A call to one of these is a substantive
+ * utterance even when the assistant emitted no visible text block.
+ */
+export const USER_FACING_TOOLS = new Set([
+    "todo_write",
+    "file_ticket",
+    "update_ticket_status",
+]);
+export const SILENT_REMINDER_ENV = "YAGNI_SILENT_TURN_REMINDER";
+export const SILENT_REMINDER_SECONDS_ENV = "YAGNI_SILENT_TURN_REMINDER_SECONDS";
+/** Disable the whole mechanism ("0"/"off"), or resolve the trigger override. */
+export function silentReminderDisabled(env = process.env) {
+    const v = env[SILENT_REMINDER_ENV];
+    return v === "0" || v?.toLowerCase() === "off";
+}
+/** Resolve the trigger interval: env seconds override wins, else the default. */
+export function resolveSilentIntervalMs(env = process.env) {
+    const raw = env[SILENT_REMINDER_SECONDS_ENV];
+    if (raw === undefined || raw.trim() === "")
+        return DEFAULT_SILENT_INTERVAL_MS;
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        return DEFAULT_SILENT_INTERVAL_MS;
+    return Math.round(seconds * 1000);
+}
+/**
+ * PURE: whether the assistant emitted any non-empty, visible text block this
+ * turn. `thinking` blocks deliberately do NOT count — 525k chars of thinking
+ * is still silence to the user.
+ */
+export function hasSubstantiveText(message) {
+    const content = message.content ?? [];
+    return content.some((c) => c.type === "text" && typeof c.text === "string" && c.text.trim().length > 0);
+}
+/**
+ * PURE: whether the assistant "spoke" this turn — visible text, OR a call to a
+ * user-facing tool (which is itself an utterance to the user, even without a
+ * text block).
+ */
+export function didSpeak(message) {
+    const content = message.content ?? [];
+    for (const c of content) {
+        if (c.type === "text" && typeof c.text === "string" && c.text.trim().length > 0) {
+            return true;
+        }
+        if (c.type === "toolCall" && typeof c.name === "string" && USER_FACING_TOOLS.has(c.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * PURE: is a reminder due? The turn count must pass {@link MIN_SILENT_TURNS},
+ * the wall-clock silence must pass the configured interval, and the spacing
+ * between nudges must pass the same interval. `lastNudgeAt` is `null` before
+ * any nudge has fired (still eligible once the other gates pass).
+ */
+export function shouldRemind(input) {
+    const { msSinceSpoke, turnsSinceSpoke, msSinceLastNudge, intervalMs } = input;
+    if (turnsSinceSpoke < MIN_SILENT_TURNS)
+        return false;
+    if (msSinceSpoke < intervalMs)
+        return false;
+    return msSinceLastNudge === null || msSinceLastNudge >= intervalMs;
+}
+/**
+ * The injected payload. Claude Code's wording plus one clause for the failure
+ * we actually saw (the model holding an assembled answer and never giving it).
+ * Wrapped in `<system-reminder>` tags — the framing branding.ts teaches the
+ * model to parse as system-injected, not part of the tool output.
+ */
+export function formatSilentReminder() {
+    return ("<system-reminder>\n" +
+        "The user hasn't heard from you in a while. As you continue, keep them updated " +
+        "when there's something to tell — a finding, a change of plan. If you already " +
+        "have an answer, give it now with your confidence and what's still open.\n" +
+        "</system-reminder>");
+}
+/**
+ * Wire the silent-turn reminder. No handlers are registered for non-driver
+ * processes, eval mode, or when disabled — so children, subagents, advisor
+ * consults, and headless evals are untouched, and the kill switch is a true
+ * no-op.
+ */
+export function registerSilentTurnReminder(pi, deps = {}) {
+    const env = deps.env ?? process.env;
+    if (deps.evalMode)
+        return;
+    if (deps.isDriver === false)
+        return;
+    if (silentReminderDisabled(env))
+        return;
+    const now = deps.now ?? (() => Date.now());
+    const intervalMs = resolveSilentIntervalMs(env);
+    let lastSpokeAt = now();
+    let turnsSinceSpoke = 0;
+    let nudgeCount = 0; // per-stretch ordinal, reset when the silence clock resets
+    let lastNudgeAt = null;
+    const reset = (at) => {
+        lastSpokeAt = at;
+        turnsSinceSpoke = 0;
+        nudgeCount = 0;
+    };
+    // One tick per finalized assistant message: did it speak (reset the clock),
+    // or not (extend the silence)? The observability counters are logged here so
+    // the recorded values are identical to the ones that drive the decision.
+    pi.on("message_end", async (event) => {
+        try {
+            const msg = event.message;
+            if (msg?.role !== "assistant")
+                return;
+            const spoke = didSpeak(msg);
+            if (spoke) {
+                reset(now());
+            }
+            else {
+                turnsSinceSpoke += 1;
+            }
+            logTurnLifecycle({
+                kind: "silent_turn",
+                secondsSinceSpoke: Math.round((now() - lastSpokeAt) / 1000),
+                turnsSinceSpoke,
+            });
+        }
+        catch {
+            // A reminder must never break a turn.
+        }
+    });
+    // Any user message resets the silence clock — the "suppressed on the turn
+    // right after a user message" rule, implemented as a clock reset.
+    pi.on("input", async () => {
+        try {
+            reset(now());
+        }
+        catch {
+            // Never break input handling.
+        }
+    });
+    // The nudge itself rides an existing tool result. Never appended to a
+    // user-facing tool's own result (a file_ticket/todo_write already IS
+    // speaking), and fail-soft: a reminder must never break a tool call.
+    pi.on("tool_result", async (event) => {
+        try {
+            if (event.isError)
+                return;
+            if (event.toolName === "todo_write" || event.toolName === "file_ticket" || event.toolName === "update_ticket_status") {
+                return;
+            }
+            if (!shouldRemind({
+                msSinceSpoke: now() - lastSpokeAt,
+                turnsSinceSpoke,
+                msSinceLastNudge: lastNudgeAt === null ? null : now() - lastNudgeAt,
+                intervalMs,
+            })) {
+                return;
+            }
+            nudgeCount += 1;
+            lastNudgeAt = now();
+            logTurnLifecycle({
+                kind: "silent_turn_nudge",
+                nudgesInStretch: nudgeCount,
+                secondsSinceSpoke: Math.round((now() - lastSpokeAt) / 1000),
+            });
+            return {
+                content: [
+                    ...event.content,
+                    { type: "text", text: `\n\n${formatSilentReminder()}` },
+                ],
+            };
+        }
+        catch {
+            return;
+        }
+    });
+}
+//# sourceMappingURL=silentTurnReminder.js.map

package/dist/extension/turnLog.d.ts

@@ -26,6 +26,20 @@ export type TurnLifecycleEvent = {
     stopReason?: string;
     /** Time since the matching turn_start, ms. */
     elapsedMs?: number;
+} | {
+    kind: "silent_turn";
+    sessionId?: string;
+    /** Whole seconds since the model last spoke (visible text or a user-facing tool). */
+    secondsSinceSpoke?: number;
+    /** Assistant turns since the model last spoke. */
+    turnsSinceSpoke?: number;
+} | {
+    kind: "silent_turn_nudge";
+    sessionId?: string;
+    /** 1-indexed fire count within the current silence stretch. */
+    nudgesInStretch?: number;
+    /** Whole seconds of silence at the moment the nudge fired. */
+    secondsSinceSpoke?: number;
 };
 /**
  * Append one sanitized lifecycle record. Fail-soft — a logging failure must

package/dist/extension/turnLog.js

@@ -64,9 +64,13 @@ export function logTurnLifecycle(ev) {
             ts: new Date().toISOString(),
             event: ev.kind,
             ...(ev.sessionId ? { sessionId: ev.sessionId } : {}),
-            ...(ev.turnIndex !== undefined ? { turnIndex: ev.turnIndex } : {}),
+            ...((ev.kind === "turn_start" || ev.kind === "turn_end") && ev.turnIndex !== undefined ? { turnIndex: ev.turnIndex } : {}),
             ...(ev.kind === "turn_end" && ev.stopReason !== undefined ? { stopReason: ev.stopReason } : {}),
             ...(ev.kind === "turn_end" && ev.elapsedMs !== undefined ? { elapsedMs: ev.elapsedMs } : {}),
+            ...(ev.kind === "silent_turn" && ev.secondsSinceSpoke !== undefined ? { secondsSinceSpoke: ev.secondsSinceSpoke } : {}),
+            ...(ev.kind === "silent_turn" && ev.turnsSinceSpoke !== undefined ? { turnsSinceSpoke: ev.turnsSinceSpoke } : {}),
+            ...(ev.kind === "silent_turn_nudge" && ev.nudgesInStretch !== undefined ? { nudgesInStretch: ev.nudgesInStretch } : {}),
+            ...(ev.kind === "silent_turn_nudge" && ev.secondsSinceSpoke !== undefined ? { secondsSinceSpoke: ev.secondsSinceSpoke } : {}),
         };
         const path = turnLogPath();
         mkdirSync(dirname(path), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "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)",
@@ -37,7 +37,7 @@
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@earendil-works/pi-tui": "0.84.1",
     "smol-toml": "^1.8.0",
-    "typebox": "^1.3.11"
+    "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "36ebf50cf01b962741558ccbf04485ef2231d1e1"
+  "yagniSourceSha": "0b9558cffa5fe5c8163a6911d2c5695180f336f2"
 }

package/dist/extension/cmux/naming.d.ts

@@ -1,5 +0,0 @@
-import type { CmuxDispatcher } from "./dispatcher.js";
-import { type PiExtensionContextSnapshot, type SessionState } from "./state.js";
-export declare function titleFromPrompt(prompt: string): string | undefined;
-export declare function renameWorkspaceFromPrompt(dispatcher: CmuxDispatcher, sessionStates: Map<string, SessionState>, context: PiExtensionContextSnapshot, sessionId: string): void;
-//# sourceMappingURL=naming.d.ts.map

package/dist/extension/cmux/naming.js

@@ -1,23 +0,0 @@
-import { firstString } from "./state.js";
-export function titleFromPrompt(prompt) {
-    const words = prompt.trim().split(/\s+/).filter(Boolean);
-    if (words.length === 0)
-        return undefined;
-    return words.slice(0, 8).join(" ").slice(0, 60) || undefined;
-}
-export function renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId) {
-    const prompt = sessionStates.get(sessionId)?.lastPrompt;
-    if (!prompt)
-        return;
-    const title = titleFromPrompt(prompt);
-    if (!title)
-        return;
-    // Use the workspace-scoped rename form: cmux workspace rename <ws> --title <title>
-    // (NOT rename-workspace --workspace ... --surface ... which misinterprets --surface
-    // as part of the title).
-    const workspaceId = firstString(process.env.CMUX_WORKSPACE_ID);
-    if (!workspaceId)
-        return;
-    void dispatcher.run(["workspace", "rename", workspaceId, "--title", title], context.cwd, undefined, context);
-}
-//# sourceMappingURL=naming.js.map