@yagni-app/code-staging 0.3.4-staging.1152.1 → 0.3.4-staging.1155.1

package/dist/extension/branding.d.ts

@@ -59,6 +59,32 @@ export declare const YAGNI_IDENTITY_DRIVER = "You are YAGNI Code, an autonomous
  * 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

@@ -95,6 +95,42 @@ export const TICKET_IMAGE_RULE = "When you read or fetch a ticket from any track
     "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}`;
 /**
@@ -213,6 +249,19 @@ export function brandSystemPrompt(original, opts = {}) {
     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/index.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";
 }
@@ -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

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-staging",
-  "version": "0.3.4-staging.1152.1",
+  "version": "0.3.4-staging.1155.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -39,5 +39,5 @@
     "smol-toml": "^1.8.0",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "ea341c6982c31f29875f8bcf38d158d255bd156e"
+  "yagniSourceSha": "17bd689a1ff1bc6e8d9fc0d420b2d4e580a781dd"
 }