@yagni-app/code 0.3.4 → 1.0.0

package/dist/extension/mineBeat.js

@@ -20,6 +20,7 @@
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import { dirname, join } from "node:path";
+import { logEvent } from "./errorSink.js";
 import { METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
 /**
  * Client-side bounds on the mining corpus — mirror of the backend's
@@ -173,6 +174,12 @@ export async function maybeOfferMiningBeat(ctx, opts) {
         }, { fetchImpl: opts.fetchImpl, policy: METERED_POST_FETCH_POLICY });
         if (!res.ok) {
             // No marker: the offer stays available next session.
+            logEvent({
+                source: "mine-beat",
+                level: "error",
+                event: "mine_failed",
+                fields: { status: res.status },
+            });
             ctx.ui.notify("Seeding the decision ledger failed; YAGNI Code will offer again next session.", "error");
             return { offered: true, accepted: true };
         }
@@ -186,6 +193,12 @@ export async function maybeOfferMiningBeat(ctx, opts) {
         return { offered: true, accepted: true, banked };
     }
     catch {
+        logEvent({
+            source: "mine-beat",
+            level: "error",
+            event: "mine_failed",
+            fields: { kind: "network" },
+        });
         ctx.ui.notify("Seeding the decision ledger failed; YAGNI Code will offer again next session.", "error");
         return { offered: true, accepted: true };
     }

package/dist/extension/pipeline/goCommand.js

@@ -71,6 +71,7 @@ import { formatRunCostTable } from "./runCostTable.js";
 import { makeCombinedCheckpointStore, makeFileCheckpointStore, makePiJournalCheckpointStore, } from "./checkpoint.js";
 import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
 import { makeCrashReporter } from "../crashReport.js";
+import { logEvent } from "../errorSink.js";
 import { scrubSecrets } from "./scrubSecrets.js";
 import { isDesktopSurface } from "../surface.js";
 import { runFinish as defaultRunFinish, verifyTrailerValue, } from "./finish.js";
@@ -1104,6 +1105,7 @@ export function registerGoCommand(pi, deps = {}) {
                     // return results instead) — report it, fire-and-forget. The default
                     // reporter never rejects; the catch guards an injected one.
                     void reportCrash(err, "go", runCwd).catch(() => { });
+                    logEvent({ source: "go", level: "error", event: "go_failed", fields: { runId } });
                     // The stopReason travels to the backend run record; scrub it like
                     // every other captured text (a raw error can echo a connection
                     // string or key).

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/pipeline/runner.js

@@ -25,6 +25,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { trackChild } from "./childRegistry.js";
 import { finalOutputFrom, foldEvent, newEventAccumulator } from "./events.js";
+import { logEvent } from "../errorSink.js";
 import { buildStageInvocation, groundedChildArgv } from "./invocation.js";
 import { personaBody } from "./personas.js";
 import { clampTier, resolveTierCap } from "./tierCap.js";
@@ -311,6 +312,14 @@ export async function runStage(stage, ctx, deps) {
                     final_output: finalOut,
                 }, null, 2));
                 dbgLog("stage_end");
+                if (overlongLinesDropped > 0) {
+                    logEvent({
+                        source: "pipeline",
+                        level: "debug",
+                        event: "overlong_lines_dropped",
+                        fields: { stage: stage.id, dropped: overlongLinesDropped },
+                    });
+                }
             }
             catch { /* ignore */ }
         }

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,221 @@
+/**
+ * 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 rides the `context` event, which pi fires before each provider
+    // request (transformContext) on a throwaway copy of the message array. That
+    // makes it reach the model as the most recent message — and, unlike the old
+    // `tool_result` seam, it is never rendered to the user and never persisted
+    // to the session file. Appending (not replacing) preserves prior `context`
+    // handlers (e.g. gate.ts's mode-context filter), and fail-soft means a
+    // reminder must never break a turn.
+    pi.on("context", async (event) => {
+        try {
+            const messages = Array.isArray(event.messages) ? event.messages : [];
+            if (!shouldRemind({
+                msSinceSpoke: now() - lastSpokeAt,
+                turnsSinceSpoke,
+                msSinceLastNudge: lastNudgeAt === null ? null : now() - lastNudgeAt,
+                intervalMs,
+            })) {
+                return undefined;
+            }
+            nudgeCount += 1;
+            lastNudgeAt = now();
+            logTurnLifecycle({
+                kind: "silent_turn_nudge",
+                nudgesInStretch: nudgeCount,
+                secondsSinceSpoke: Math.round((now() - lastSpokeAt) / 1000),
+            });
+            return {
+                messages: [
+                    ...messages,
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: formatSilentReminder() }],
+                        timestamp: now(),
+                    },
+                ],
+            };
+        }
+        catch {
+            return undefined;
+        }
+    });
+}
+//# 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