@code-yeongyu/senpi 2026.11.10-3 → 2026.11.11

package/dist/core/extensions/builtin/goal/lifecycle-helpers.js

@@ -6,7 +6,6 @@ import { isRecord } from "../../../work-custody-record.js";
 import { getLatestPhasesFromBranchEntries } from "../todotools/state.js";
 import { buildGoalContinuationSignature, evaluateGoalContinuation, hashAssistantText, } from "./continuation.js";
 import { CONTEXT_OVERFLOW_BLOCKED_REASON, CONTINUATION_CAP_BLOCKED_REASON, continuationCapRecoveryHint, LENGTH_EXHAUSTED_BLOCKED_REASON, NO_PROGRESS_BLOCKED_REASON, REPETITION_BLOCKED_REASON, } from "./continuation-recovery.js";
-import { buildContinuationPrompt } from "./prompt.js";
 import { recordContinuationDelivered, recordGoalContinuationStopped } from "./store.js";
 import { goalStoreRef } from "./store-ref.js";
 import { openTodoTaskContents } from "./todo-gate.js";
@@ -42,36 +41,15 @@ export async function admitAndQueueGoalContinuation(pi, ctx, goal, options) {
     if (options.input.currentSignature === undefined) {
         throw new Error("Cannot queue a goal continuation without a progress signature");
     }
-    const recordedGoal = await recordContinuationDelivered(goalStoreRef(ctx.sessionManager, ctx.cwd), options.input.currentSignature, goal.id, { countUnattended: options.input.path !== "monitorDelayed" });
+    const recordedGoal = await recordContinuationDelivered(goalStoreRef(ctx.sessionManager, ctx.cwd), options.input.currentSignature, goal.id, options.input.limitWait === true
+        ? { countUnattended: false, countStreak: false }
+        : { countUnattended: options.input.path !== "monitorDelayed" });
     if (recordedGoal === null)
         return null;
     options.markContinuationPending();
     queueHiddenGoalPrompt(pi, options.content(verdict));
     return recordedGoal;
 }
-/** Routes startup and resume continuations through the same verdict and delivery accounting as agent-end paths. */
-export async function queueGoalContinuation(pi, ctx, goal, options) {
-    const signature = buildCurrentGoalContinuationSignature(ctx, goal, lastAssistantTextFromEntries(ctx.sessionManager.getBranch()));
-    return admitAndQueueGoalContinuation(pi, ctx, goal, {
-        input: {
-            isIdle: ctx.isIdle(),
-            hasPendingMessages: ctx.hasPendingMessages(),
-            path: "sessionStart",
-            lastStopReason: undefined,
-            lastTurnWasMalformedToolUse: false,
-            consecutiveContinuations: goal.consecutiveContinuations ?? 0,
-            lastContinuationSignature: goal.lastContinuationSignature,
-            currentSignature: signature,
-            consecutiveLengthRecoveries: 0,
-            recentNormalizedOutputHashes: [],
-            toollessContinuationStreak: 0,
-            continuationPending: options.continuationPending,
-            lastTurnStuckOnContextOverflow: isLastTurnStuckOnContextOverflow(ctx, lastAssistantFromEntries(ctx.sessionManager.getBranch())),
-        },
-        content: () => buildContinuationPrompt(goal, { modelId: ctx.model?.id }),
-        markContinuationPending: options.markContinuationPending,
-    });
-}
 export function buildCurrentGoalContinuationSignature(ctx, goal, lastAssistantText) {
     const entries = ctx.sessionManager.getBranch();
     const openTodos = openTodoTaskContents(entries).length;
@@ -86,18 +64,6 @@ export function lastAssistantText(messages) {
     }
     return "";
 }
-function lastAssistantTextFromEntries(entries) {
-    const assistant = lastAssistantFromEntries(entries);
-    return assistant === undefined ? "" : textContent(assistant);
-}
-function lastAssistantFromEntries(entries) {
-    for (let index = entries.length - 1; index >= 0; index--) {
-        const entry = entries[index];
-        if (entry?.type === "message" && entry.message.role === "assistant")
-            return entry.message;
-    }
-    return undefined;
-}
 export function isLastTurnStuckOnContextOverflow(ctx, lastAssistant) {
     return lastAssistant !== undefined && isTurnStuckOnContextOverflow(lastAssistant, ctx.model?.contextWindow ?? 0);
 }

package/dist/core/extensions/builtin/goal/monitor-continuation.js

@@ -1,4 +1,5 @@
 import { deadlineStopPendingSinceLastTurn } from "../../../turn-deadline.js";
+import { subscribeProviderAccountEvents } from "../anthropic-subscription/account-events.js";
 import { isHumanInputMonitorNotification } from "../monitor-state-event.js";
 import { createGoalCacheWarmScheduleData, estimateCacheWarmMetrics, GOAL_CACHE_WARMUP_ENTRY_TYPE, GOAL_MONITOR_CONTINUATION_FALLBACK_DELAY_MS, resolveGoalBackstopMaxSecondsForCache, resolveGoalMonitorContinuationDelayMs, resolveGoalPromptCacheLifetime, } from "./cache-warm.js";
 import { subscribeGoalChannelState } from "./channel-state-subscriptions.js";
@@ -9,7 +10,7 @@ import { lastAssistantMessage } from "./last-assistant-message.js";
 import { admitAndQueueGoalContinuation, buildCurrentGoalContinuationSignature, isLastTurnStuckOnContextOverflow, lastAssistantText, } from "./lifecycle-helpers.js";
 import { findParkedGoalWait } from "./parked-wait.js";
 import { buildContinuationPrompt, buildGoalStallNotice, buildTruncationRecoveryPrompt } from "./prompt.js";
-import { exhaustedLadderResumeDelayMs, PROVIDER_RETRY_BASE_MS, providerRetryAt, providerRetryDelayMs, } from "./provider-retry.js";
+import { exhaustedLadderResumeDelayMs, GOAL_LIMIT_WAIT_WAKE_LIMIT, isLimitRefusal, limitWaitFloorMs, PROVIDER_RETRY_BASE_MS, providerRetryAt, providerRetryDelayMs, } from "./provider-retry.js";
 import { isStaleExtensionContextError } from "./stale-context.js";
 import { resetContinuationStreak } from "./store.js";
 import { goalStoreRef } from "./store-ref.js";
@@ -22,6 +23,8 @@ export const GOAL_CONTINUATION_SCHEDULED_EVENT = "goal_continuation_scheduled";
 export const GOAL_CONTINUATION_RESUMED_EVENT = "goal_continuation_resumed";
 export const GOAL_CONTINUATION_TIMER_STATE_EVENT = "goal_continuation_timer_state";
 export const GOAL_MONITOR_STALL_EVENT = "goal_monitor_continuation_stall";
+/** A limit outlasted GOAL_LIMIT_WAIT_WAKE_LIMIT re-checks: the goal waits for a sign-in, a block reset or input. */
+const GOAL_LIMIT_WAIT_PARKED_EVENT = "goal_limit_wait_parked";
 /** The one notice a provider-limit park shows: when the goal resumes, in local time and as the exact instant. */
 function providerPauseNotice(retryAt) {
     const local = new Date(retryAt).toLocaleString("en-US", {
@@ -68,12 +71,51 @@ export class MonitorAwareGoalContinuation {
     #pendingProviderRecovery;
     #providerRetryAttempts = 0;
     #providerRetryDelayMs;
+    /** The armed provider retry waits out a usage or rate limit, so its wake spends no continuation budget (senpi#4085). */
+    #limitWait = false;
+    #limitWakes = 0;
+    #limitParked = false;
     constructor(pi, isContinuationPending = () => false, markContinuationPending = () => { }, waitTicker) {
         this.#pi = pi;
         this.#isContinuationPending = isContinuationPending;
         this.#markContinuationPending = markContinuationPending;
         this.#waitTicker = waitTicker;
         this.#subscribeToChannelState();
+        // A login or an explicit block reset can end the wait early: re-check the provider now (senpi#4085).
+        this.#channelStateUnsubscribers.push(subscribeProviderAccountEvents((event) => {
+            if (event.type === "accounts_changed" && event.remedy !== undefined)
+                this.#wakeLimitWait();
+        }));
+    }
+    #wakeLimitWait() {
+        const goal = this.#goal;
+        const waiting = this.#scheduledContinuationKind === "providerRetry" || this.#limitParked;
+        if (!this.#limitWait || !waiting || goal === null)
+            return;
+        this.#limitWakes = 0;
+        this.#limitParked = false;
+        this.#cancelTimer();
+        this.#providerRetryDelayMs = 0;
+        this.#schedule(goal, "providerRetry");
+    }
+    /**
+     * Arms the next re-check of a limit wait, never sooner than the provider backoff. A limit that outlasts
+     * GOAL_LIMIT_WAIT_WAKE_LIMIT re-checks parks the goal, still active, until a sign-in, a block reset or input.
+     */
+    #armLimitWait(goal, delayMs) {
+        this.#limitWait = true;
+        this.#limitWakes += 1;
+        if (this.#limitWakes > GOAL_LIMIT_WAIT_WAKE_LIMIT) {
+            this.#limitParked = true;
+            this.#publish(GOAL_LIMIT_WAIT_PARKED_EVENT, { goalId: goal.id, wakes: GOAL_LIMIT_WAIT_WAKE_LIMIT });
+            if (this.#ctxHasUI()) {
+                this.#ctx?.ui.notify(`Goal paused: the provider kept refusing for a usage limit through ${GOAL_LIMIT_WAIT_WAKE_LIMIT} re-checks. It resumes after a sign-in, an account block reset, or your next message.`, "warning");
+            }
+            return false;
+        }
+        this.#providerRetryDelayMs = Math.max(delayMs, limitWaitFloorMs(this.#providerRetryAttempts));
+        this.#schedule(goal, "providerRetry");
+        return true;
     }
     start(ctx) {
         this.#cancelTimer();
@@ -91,6 +133,9 @@ export class MonitorAwareGoalContinuation {
         if (options.goal?.id !== this.#goal?.id)
             this.#resetContinuationState();
         this.#providerRetryAttempts = 0;
+        this.#limitWait = false;
+        this.#limitWakes = 0;
+        this.#limitParked = false;
         this.#ctx = options.ctx;
         this.#goal = options.goal;
         this.#lastAgentEndMessages = options.messages;
@@ -214,9 +259,18 @@ export class MonitorAwareGoalContinuation {
             return undefined;
         }
         this.#providerRetryAttempts += 1;
+        this.#limitWait = isLimitRefusal(pendingProvider.messages);
         const now = Date.now();
         const retryAt = providerRetryAt(pendingProvider.messages, now);
         const delayMs = providerRetryDelayMs(this.#providerRetryAttempts, retryAt, now);
+        if (this.#limitWait) {
+            this.#cancelTimer();
+            const armed = this.#armLimitWait(pendingProvider.goal, delayMs);
+            if (armed && retryAt !== undefined && this.#ctxHasUI(pendingProvider.ctx)) {
+                pendingProvider.ctx.ui.notify(providerPauseNotice(retryAt), "info");
+            }
+            return pendingProvider.goal;
+        }
         if (delayMs > 0) {
             this.#cancelTimer();
             this.#providerRetryDelayMs = delayMs;
@@ -230,17 +284,16 @@ export class MonitorAwareGoalContinuation {
     }
     /**
      * senpi#3709: every fallback rung failed, so a continuation now would hit the same limits. Park on
-     * the soonest reset the run named and resume once; with no known reset, stay parked until input.
+     * the soonest reset the run named; with no known reset, re-check on the provider backoff (senpi#4085).
      */
     #parkUntilLadderReset(resumeAt) {
         const goal = this.#goal;
         if (goal?.status !== "active")
             return undefined;
         this.#cancelTimer();
-        if (resumeAt === undefined)
-            return goal;
-        this.#providerRetryDelayMs = exhaustedLadderResumeDelayMs(resumeAt, Date.now());
-        this.#schedule(goal, "providerRetry");
+        this.#providerRetryAttempts += 1;
+        // No failure named a reset: re-check on the provider backoff (15 s doubling to 30 min) rather than wait for input.
+        this.#armLimitWait(goal, resumeAt === undefined ? 0 : exhaustedLadderResumeDelayMs(resumeAt, Date.now()));
         return goal;
     }
     syncGoal(goal) {
@@ -521,7 +574,10 @@ export class MonitorAwareGoalContinuation {
             this.#resetCacheWarmIteration();
     }
     async #admitAndQueue(ctx, goal, path, messages) {
-        const input = this.#buildVerdictInput(ctx, goal, path, messages);
+        const input = {
+            ...this.#buildVerdictInput(ctx, goal, path, messages),
+            ...(path === "providerRecovery" && this.#limitWait ? { limitWait: true } : {}),
+        };
         const verdict = evaluateGoalContinuation({ goal, ...input });
         const admittedGoal = await admitAndQueueGoalContinuation(this.#pi, ctx, goal, {
             input,
@@ -747,6 +803,9 @@ export class MonitorAwareGoalContinuation {
         this.#pendingSystemRecovery = undefined;
         this.#pendingProviderRecovery = undefined;
         this.#providerRetryAttempts = 0;
+        this.#limitWait = false;
+        this.#limitWakes = 0;
+        this.#limitParked = false;
         this.#consecutiveLengthRecoveries.clear();
         this.#recentNormalizedOutputHashes = [];
         this.#recentToolEffects = [];

package/dist/core/extensions/builtin/goal/provider-retry.d.ts

@@ -7,6 +7,15 @@ export declare const PROVIDER_RETRY_WAKE_CAP_MS: number;
  * pool guidance falls back to the earliest future ISO instant in the error only.
  */
 export declare function providerRetryAt(messages: readonly AgentMessage[], now: number): number | undefined;
+/** Re-checks of a limit that never clears before the goal parks until a sign-in, a block reset or input (senpi#4085). */
+export declare const GOAL_LIMIT_WAIT_WAKE_LIMIT = 48;
+/** The shortest wait before the `attempt`-th limit re-check: the provider backoff, 15 s doubling to 30 min. */
+export declare function limitWaitFloorMs(attempt: number): number;
+/**
+ * The turn ended on a provider refusing for a usage or rate limit, not on an outage (senpi#4085). An OpenAI-compatible
+ * adapter reports a bare 429 as a status-only diagnostic (`unknown` + 429); that status is still a limit.
+ */
+export declare function isLimitRefusal(messages: readonly AgentMessage[]): boolean;
 /**
  * How long to wait before the `attempt`-th consecutive provider-recovery
  * continuation (senpi#3264). A stated unblock time is the wake; otherwise the

package/dist/core/extensions/builtin/goal/provider-retry.js

@@ -31,6 +31,22 @@ export function providerRetryAt(messages, now) {
         .filter((at) => Number.isFinite(at) && at > now);
     return instants.length === 0 ? undefined : Math.min(...instants);
 }
+/** Re-checks of a limit that never clears before the goal parks until a sign-in, a block reset or input (senpi#4085). */
+export const GOAL_LIMIT_WAIT_WAKE_LIMIT = 48;
+/** The shortest wait before the `attempt`-th limit re-check: the provider backoff, 15 s doubling to 30 min. */
+export function limitWaitFloorMs(attempt) {
+    return Math.min(PROVIDER_RETRY_CAP_MS, PROVIDER_RETRY_BASE_MS * 2 ** (Math.max(1, attempt) - 1));
+}
+/**
+ * The turn ended on a provider refusing for a usage or rate limit, not on an outage (senpi#4085). An OpenAI-compatible
+ * adapter reports a bare 429 as a status-only diagnostic (`unknown` + 429); that status is still a limit.
+ */
+export function isLimitRefusal(messages) {
+    const diagnostic = lastAssistantMessage(messages)?.providerDiagnostic;
+    return (diagnostic?.category === "rate_limit" ||
+        diagnostic?.category === "quota" ||
+        (diagnostic?.category === "unknown" && diagnostic.httpStatus === 429));
+}
 /**
  * How long to wait before the `attempt`-th consecutive provider-recovery
  * continuation (senpi#3264). A stated unblock time is the wake; otherwise the

package/dist/core/extensions/builtin/goal/reload-reengagement.d.ts

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from "../../types.ts";
 import type { MonitorAwareGoalContinuation } from "./monitor-continuation.ts";
+import type { TrailingGoalContinuations } from "./session-start-continuation.ts";
 import type { Goal } from "./types.ts";
 export type ReloadReengagementOutcome = "skipped-inactive" | "backstop-rearmed" | "suppressed-flood" | "continuation-queued";
 /**
@@ -24,7 +25,7 @@ export declare function reengageGoalAfterReload(options: {
     readonly ctx: ExtensionContext;
     readonly goal: Goal;
     readonly monitor: MonitorAwareGoalContinuation;
-    readonly countTrailingContinuations: () => number;
-    readonly queueContinuation: () => Promise<void>;
+    readonly readTrailingContinuations: () => TrailingGoalContinuations;
+    readonly queueContinuation: (limitWait: boolean) => Promise<void>;
 }): Promise<ReloadReengagementOutcome>;
 //# sourceMappingURL=reload-reengagement.d.ts.map

package/dist/core/extensions/builtin/goal/reload-reengagement.js

@@ -30,12 +30,12 @@ export async function reengageGoalAfterReload(options) {
         monitor.rearmMonitorBackstop(goal);
         return "backstop-rearmed";
     }
-    const trailingContinuations = options.countTrailingContinuations();
-    if (trailingContinuations >= GOAL_CONTINUATION_CAP) {
-        ctx.ui.notify(`Goal auto-continuation suppressed for this resumed session (${trailingContinuations} historical continuations). Send a message to resume.`, "info");
+    const trailing = options.readTrailingContinuations();
+    if (trailing.counted >= GOAL_CONTINUATION_CAP) {
+        ctx.ui.notify(`Goal auto-continuation suppressed for this resumed session (${trailing.counted} historical continuations). Send a message to resume.`, "info");
         return "suppressed-flood";
     }
-    await options.queueContinuation();
+    await options.queueContinuation(trailing.waitingOutLimit);
     return "continuation-queued";
 }
 //# sourceMappingURL=reload-reengagement.js.map

package/dist/core/extensions/builtin/goal/session-start-continuation.d.ts

@@ -0,0 +1,28 @@
+import type { SessionEntry } from "../../../session-manager.ts";
+import type { ExtensionAPI, ExtensionContext } from "../../types.ts";
+import type { Goal } from "./types.ts";
+export type TrailingGoalContinuations = {
+    /** Continuations whose turn ran: the unattended loop the load-time flood guard bounds. */
+    readonly counted: number;
+    /** The newest continuation was refused for a usage or rate limit, so the goal was waiting that limit out. */
+    readonly waitingOutLimit: boolean;
+};
+export type SessionStartContinuationOptions = {
+    readonly continuationPending: boolean;
+    readonly markContinuationPending: () => void;
+    /** The session opened in the middle of a limit wait, so this wake re-checks that limit (senpi#4085). */
+    readonly limitWait?: boolean;
+};
+/**
+ * Reads the goal continuations queued since the most recent real user message in the branch (mirrors the
+ * todo-gate / todo-bridge backward branch read). A real user message is the only reset: the assistant turns in
+ * between are exactly the unattended loop the load-time admission guard exists to stop.
+ *
+ * A continuation the provider refused for a usage or rate limit ran no model turn, so it is not part of that
+ * loop (senpi#4085). A goal that waited a limit out for more wakes than the cap is therefore not a flood, and it
+ * resumes after a restart or a config reload.
+ */
+export declare function readTrailingGoalContinuations(entries: readonly SessionEntry[]): TrailingGoalContinuations;
+/** Routes startup and resume continuations through the same verdict and delivery accounting as agent-end paths. */
+export declare function queueGoalContinuation(pi: ExtensionAPI, ctx: ExtensionContext, goal: Goal, options: SessionStartContinuationOptions): Promise<Goal | null>;
+//# sourceMappingURL=session-start-continuation.d.ts.map

package/dist/core/extensions/builtin/goal/session-start-continuation.js

@@ -0,0 +1,75 @@
+import { GOAL_CONTINUATION_MESSAGE_TYPE } from "../../../messages.js";
+import { admitAndQueueGoalContinuation, buildCurrentGoalContinuationSignature, isLastTurnStuckOnContextOverflow, lastAssistantText, } from "./lifecycle-helpers.js";
+import { buildContinuationPrompt } from "./prompt.js";
+import { isLimitRefusal } from "./provider-retry.js";
+/**
+ * Reads the goal continuations queued since the most recent real user message in the branch (mirrors the
+ * todo-gate / todo-bridge backward branch read). A real user message is the only reset: the assistant turns in
+ * between are exactly the unattended loop the load-time admission guard exists to stop.
+ *
+ * A continuation the provider refused for a usage or rate limit ran no model turn, so it is not part of that
+ * loop (senpi#4085). A goal that waited a limit out for more wakes than the cap is therefore not a flood, and it
+ * resumes after a restart or a config reload.
+ */
+export function readTrailingGoalContinuations(entries) {
+    let counted = 0;
+    let waitingOutLimit;
+    let turn = [];
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry?.type === "message") {
+            if (entry.message.role === "user")
+                break;
+            if (entry.message.role === "assistant")
+                turn.push(entry.message);
+            continue;
+        }
+        if (entry?.type !== "custom_message" || entry.customType !== GOAL_CONTINUATION_MESSAGE_TYPE)
+            continue;
+        const refused = wasRefusedForLimit(turn);
+        waitingOutLimit ??= refused;
+        if (!refused)
+            counted += 1;
+        turn = [];
+    }
+    return { counted, waitingOutLimit: waitingOutLimit ?? false };
+}
+function wasRefusedForLimit(turn) {
+    return (turn.length > 0 &&
+        turn.every((message) => message.stopReason === "error") &&
+        turn.some((message) => isLimitRefusal([message])));
+}
+/** Routes startup and resume continuations through the same verdict and delivery accounting as agent-end paths. */
+export async function queueGoalContinuation(pi, ctx, goal, options) {
+    const lastAssistant = lastAssistantFromEntries(ctx.sessionManager.getBranch());
+    const signature = buildCurrentGoalContinuationSignature(ctx, goal, lastAssistant === undefined ? "" : lastAssistantText([lastAssistant]));
+    return admitAndQueueGoalContinuation(pi, ctx, goal, {
+        input: {
+            isIdle: ctx.isIdle(),
+            hasPendingMessages: ctx.hasPendingMessages(),
+            path: "sessionStart",
+            lastStopReason: undefined,
+            lastTurnWasMalformedToolUse: false,
+            consecutiveContinuations: goal.consecutiveContinuations ?? 0,
+            lastContinuationSignature: goal.lastContinuationSignature,
+            currentSignature: signature,
+            consecutiveLengthRecoveries: 0,
+            recentNormalizedOutputHashes: [],
+            toollessContinuationStreak: 0,
+            continuationPending: options.continuationPending,
+            lastTurnStuckOnContextOverflow: isLastTurnStuckOnContextOverflow(ctx, lastAssistant),
+            ...(options.limitWait === true ? { limitWait: true } : {}),
+        },
+        content: () => buildContinuationPrompt(goal, { modelId: ctx.model?.id }),
+        markContinuationPending: options.markContinuationPending,
+    });
+}
+function lastAssistantFromEntries(entries) {
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry?.type === "message" && entry.message.role === "assistant")
+            return entry.message;
+    }
+    return undefined;
+}
+//# sourceMappingURL=session-start-continuation.js.map

package/dist/core/extensions/builtin/goal/store.d.ts

@@ -15,6 +15,7 @@ export declare function clearGoal(ref: GoalStoreRef): Promise<boolean>;
 export declare function accountGoalUsage(ref: GoalStoreRef, usage: TokenUsageSnapshot, elapsedSeconds: number, mode?: GoalAccountingMode, expectedGoalId?: string): Promise<Goal | null>;
 export declare function recordContinuationDelivered(ref: GoalStoreRef, signature: string, expectedGoalId?: string, options?: {
     countUnattended?: boolean;
+    countStreak?: boolean;
 }): Promise<Goal | null>;
 export declare function resetContinuationStreak(ref: GoalStoreRef, options?: {
     unattended?: boolean;

package/dist/core/extensions/builtin/goal/store.js

@@ -177,7 +177,7 @@ export async function recordContinuationDelivered(ref, signature, expectedGoalId
         const counted = options.countUnattended === false ? 0 : 1;
         const next = {
             ...goal,
-            consecutiveContinuations: (goal.consecutiveContinuations ?? 0) + 1,
+            consecutiveContinuations: (goal.consecutiveContinuations ?? 0) + (options.countStreak === false ? 0 : 1),
             unattendedContinuations: (goal.unattendedContinuations ?? 0) + counted,
             noProgressContinuations: (goal.noProgressContinuations ?? 0) + counted,
             lastContinuationSignature: signature,

package/dist/core/extensions/builtin/handoff-hint/index.js

@@ -5,6 +5,7 @@ import { readGoal } from "../goal/store.js";
 import { goalStoreRef } from "../goal/store-ref.js";
 import { buildHandoffBrief } from "./brief.js";
 import { estimateHandoff, hintText } from "./estimate.js";
+import { createReplacementRelay } from "./replacement-relay.js";
 export const HANDOFF_HINT_ENTRY_TYPE = "handoff-hint";
 export const HANDOFF_BRIEF_MESSAGE_TYPE = "handoff-brief";
 export const HANDOFF_HINT_EVENT = "handoff_hint";
@@ -51,6 +52,7 @@ const readActiveGoal = (ctx) => readGoal(goalStoreRef(ctx.sessionManager, ctx.cw
 export function createHandoffHintExtension(dependencies = {}) {
     const now = dependencies.now ?? Date.now;
     const goalOf = dependencies.readGoal ?? readActiveGoal;
+    const acceptances = createReplacementRelay();
     return (pi) => {
         let ctx;
         let timer;
@@ -168,22 +170,21 @@ export function createHandoffHintExtension(dependencies = {}) {
                 previousSessionFile: current.sessionManager.getSessionFile(),
                 contextTokens: usage?.tokens ?? estimate?.contextTokens ?? 0,
             });
-            const accepted = estimate === undefined ? undefined : hintEvent("accepted", current, estimate);
             const sessionId = current.sessionManager.getSessionId();
+            const previousSessionFile = current.sessionManager.getSessionFile();
+            // The replacement's session_start emits it through the new generation's pi (senpi#4051).
+            if (estimate !== undefined)
+                acceptances.hold(previousSessionFile, hintEvent("accepted", current, estimate));
             hide(current);
-            const result = await current.newSession({
-                parentSession: current.sessionManager.getSessionFile(),
+            const switching = current.newSession({
+                parentSession: previousSessionFile,
                 withSession: async (next) => {
                     await next.sendMessage({ customType: HANDOFF_BRIEF_MESSAGE_TYPE, content: brief, display: true }, { triggerTurn: false });
                 },
             });
-            if (result.cancelled) {
-                if (estimate !== undefined && current.sessionManager.getSessionId() === sessionId)
-                    render(current, estimate);
-                return;
-            }
-            if (accepted !== undefined)
-                pi.events?.emit(HANDOFF_HINT_EVENT, accepted);
+            const result = await switching.finally(() => acceptances.release(previousSessionFile));
+            if (result.cancelled && estimate !== undefined && current.sessionManager.getSessionId() === sessionId)
+                render(current, estimate);
         }
         pi.registerCommand(HANDOFF_COMMAND, {
             description: "Start a fresh session seeded with a short handoff brief (`/handoff keep` hides the hint)",
@@ -207,8 +208,11 @@ export function createHandoffHintExtension(dependencies = {}) {
                 await startFresh(current);
             },
         });
-        pi.on("session_start", (_event, next) => {
+        pi.on("session_start", (event, next) => {
             ctx = next;
+            const accepted = event.reason === "new" ? acceptances.take(event.previousSessionFile) : undefined;
+            if (accepted !== undefined)
+                pi.events?.emit(HANDOFF_HINT_EVENT, accepted);
             disarm();
             visible = undefined;
             shownThisCrossing = false;

package/dist/core/extensions/builtin/handoff-hint/replacement-relay.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Carries a value from a session to the session that replaces it (senpi#4051).
+ *
+ * `newSession()` retires the old extension generation before the replacement starts, so a captured `pi` cannot emit
+ * after the switch, and emitting before it would report a switch that `session_before_switch` may still cancel. The
+ * builtin factory outlives both generations in one process, so the value waits here, keyed by the session being
+ * replaced, until the replacement's `session_start` takes it through its own live `pi`. The holder releases its key
+ * once `newSession()` settles, so a cancelled or failed switch delivers nothing.
+ */
+export interface ReplacementRelay<T> {
+    hold(previousSessionFile: string | undefined, value: T): void;
+    take(previousSessionFile: string | undefined): T | undefined;
+    release(previousSessionFile: string | undefined): void;
+}
+export declare function createReplacementRelay<T>(): ReplacementRelay<T>;
+//# sourceMappingURL=replacement-relay.d.ts.map

package/dist/core/extensions/builtin/handoff-hint/replacement-relay.js

@@ -0,0 +1,17 @@
+export function createReplacementRelay() {
+    const pending = new Map();
+    return {
+        hold: (previousSessionFile, value) => {
+            pending.set(previousSessionFile, value);
+        },
+        take: (previousSessionFile) => {
+            const value = pending.get(previousSessionFile);
+            pending.delete(previousSessionFile);
+            return value;
+        },
+        release: (previousSessionFile) => {
+            pending.delete(previousSessionFile);
+        },
+    };
+}
+//# sourceMappingURL=replacement-relay.js.map

package/dist/core/extensions/builtin/prompt-preset/claude-fable-5-1.js

@@ -85,7 +85,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -93,7 +93,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
 
 The request sets the scope, and the scope is the deliverable: deliver all of it and only it. Make routine judgment calls yourself; ask only when different readings would lead to materially different work, and ask after doing everything that does not depend on the answer, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer). If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way. If part of the task is blocked, finish every other part and say exactly what you left out and why.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -107,7 +107,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/claude-fable-5-2.js

@@ -19,7 +19,8 @@
 // - Scope, structure ("Say who owns the code"): the guide's ownership sentence
 //   opens the structure paragraph and replaces the smallest-change sentence
 //   (owner order). Without it, 5.2 acts as a guest: parallel code, duplicates
-//   left in place, and nearby bugs only mentioned.
+//   left in place, and nearby bugs only mentioned. senpi#6358 carries the same
+//   sentence, with what the owner does, into every core.
 // - Working the Task, delegation ("Set expectations for subagents"): the 5.1
 //   sentence was a standing invitation to delegate, which the guide says to
 //   review first. It now states the cost before the invitation, what a brief
@@ -67,7 +68,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -77,7 +78,7 @@ The request sets the scope, and the scope is the deliverable: deliver all of it
 
 Errors, timeouts, locked files, empty results, and failing tools are ordinary obstacles, not blockers: diagnose them, then work through them with the access you have (wait and retry a call that is safe to repeat, fix the request, use another tool or source) without asking first. A file marked not to be touched, withheld access, or a safety guardrail is a deliberate blocker: leave it alone and look for another safe way to finish. If part of the task stays blocked, finish every other part and say exactly what you left out and why.
 
-This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -91,7 +92,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/claude-fable-5.js

@@ -59,7 +59,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code, report the answer or findings - no edits, no fixes yet.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally, at exactly the asked scope - the smallest path that fully satisfies an open-ended goal; name an ambiguity and resolve it from context when possible.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause, at exactly the asked scope - what fully satisfies an open-ended goal and nothing beyond it; name an ambiguity and resolve it from context when possible.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan; queued steering messages outrank earlier intent. Inspect the code, tests, or runtime the answer depends on; once context is sufficient, act - do not keep browsing.
 
@@ -80,7 +80,7 @@ Tier the scope, never the rigor:
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with the output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with the output."} Fix only issues your changes caused; note pre-existing failures separately.
+"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with the output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with the output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 
@@ -96,7 +96,7 @@ ${buildHandoffSection({ turnEndRuleStatedElsewhere: true, surface: context.surfa
 
 ## Style
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code. Trust framework guarantees; validate only at system boundaries.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. No helpers or abstractions for hypothetical needs, no defensive checks inside trusted code. Trust framework guarantees; validate only at system boundaries.
 
 Act, then report. Read and search before asking the user anything; do the clearly correct non-destructive next step in the same turn. Permission-begging ("Shall I?") is prohibited. Pause only when the work genuinely requires the user - a destructive or irreversible action, a real scope change, or input only they can provide - then ask, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer), and end the turn rather than ending on a promise; for destructive actions, state the recommended action and stop. Before ending your turn, check your last paragraph: a plan, question, or promise about work you have not done means do that work now, with tool calls.