@code-yeongyu/senpi 2026.10.24-4 → 2026.10.25-2

package/dist/bundle/rpc-entry.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import"./chunks/chunk-PXKF2RHD.js";import{main}from"./chunks/chunk-GVJ76VQI.js";import"./chunks/chunk-SGDOZT6B.js";import"./chunks/chunk-VOBD6FQG.js";import{configureHttpDispatcher}from"./chunks/chunk-NQC7MI2G.js";import"./chunks/chunk-DXJJP6RP.js";import"./chunks/chunk-GXY5JEI5.js";import"./chunks/chunk-42OY5SZZ.js";import"./chunks/chunk-GY5MR5KR.js";import"./chunks/chunk-EHQXLHRB.js";import"./chunks/chunk-XF3LJC3O.js";import"./chunks/chunk-CNPDUC4D.js";import"./chunks/chunk-CDRFFHLL.js";import"./chunks/chunk-7UUOGZKR.js";import"./chunks/chunk-Y5OTHMXO.js";import"./chunks/chunk-MLVIYDHK.js";import"./chunks/chunk-TIVW4P37.js";import"./chunks/chunk-H4QOEVS5.js";import"./chunks/chunk-3LNSLJ7N.js";import"./chunks/chunk-MSQCTH6V.js";import"./chunks/chunk-KLAX467B.js";import"./chunks/chunk-JFFS72FL.js";import"./chunks/chunk-ORXZXUMC.js";import"./chunks/chunk-GZVCRV7I.js";import"./chunks/chunk-SOMFLLPD.js";import"./chunks/chunk-MTQQ2VQH.js";import"./chunks/chunk-3VOG6WFU.js";import"./chunks/chunk-BMYNMUVZ.js";import"./chunks/chunk-QMRJYMNH.js";import"./chunks/chunk-FWXMMMCV.js";import"./chunks/chunk-4AOMNOGY.js";import"./chunks/chunk-KUPQO7MC.js";import"./chunks/chunk-U67ML6CQ.js";import"./chunks/chunk-26UBFF6N.js";import"./chunks/chunk-EWOEVVQT.js";import"./chunks/chunk-II22E3CV.js";import"./chunks/chunk-7IRLFYNM.js";import"./chunks/chunk-XUFUKDKJ.js";import"./chunks/chunk-RHHBXIRN.js";import"./chunks/chunk-U3VOXCGP.js";import"./chunks/chunk-RVYSJBZ7.js";import"./chunks/chunk-HB35RBP4.js";import"./chunks/chunk-Z6WGAK7W.js";import"./chunks/chunk-DLAY7CIU.js";import"./chunks/chunk-3BTN337S.js";import"./chunks/chunk-QXREUA5F.js";import"./chunks/chunk-RUGYFYH7.js";import"./chunks/chunk-OEFCY46F.js";import"./chunks/chunk-KRNXUTZJ.js";import"./chunks/chunk-TAV6QZFM.js";import"./chunks/chunk-PELNNWGO.js";import"./chunks/chunk-QH2HSCMX.js";import"./chunks/chunk-FDL4CF6F.js";import"./chunks/chunk-BWA4FVFW.js";import"./chunks/chunk-YU4AYH4C.js";import"./chunks/chunk-E6WYH3ZL.js";import"./chunks/chunk-COH5F7QV.js";import"./chunks/chunk-RFB5CBW7.js";import"./chunks/chunk-2VZJTDUX.js";import"./chunks/chunk-E4LBKOZG.js";import"./chunks/chunk-GVSBCJFI.js";import"./chunks/chunk-WASCMT6Y.js";import"./chunks/chunk-T36LJ6MW.js";import"./chunks/chunk-QGJLZ6BI.js";import"./chunks/chunk-WHPDEDCC.js";import"./chunks/chunk-AA2L2RHH.js";import"./chunks/chunk-HK46JMSC.js";import"./chunks/chunk-4P7WARQZ.js";import"./chunks/chunk-WDTJ6JKE.js";import"./chunks/chunk-5ROMKDLK.js";import"./chunks/chunk-3W47LTXQ.js";import"./chunks/chunk-6AOVUTUR.js";import"./chunks/chunk-45SZOLCU.js";import"./chunks/chunk-DMI55M2N.js";import"./chunks/chunk-PJ34QVL5.js";import"./chunks/chunk-BMX2U22F.js";import"./chunks/chunk-YU2P3CAR.js";import"./chunks/chunk-IUHU5PEC.js";import"./chunks/chunk-ZOFZRJSL.js";import"./chunks/chunk-2SOVDETB.js";import"./chunks/chunk-V3CK2AVC.js";import"./chunks/chunk-VRDU425E.js";import"./chunks/chunk-ZGAB7WQA.js";import{APP_NAME,scrubBrandFromEnvironment}from"./chunks/chunk-7YO7VQZW.js";import"./chunks/chunk-ATQFN5HI.js";import"./chunks/chunk-MIENF2YK.js";import"./chunks/chunk-OXNWERO4.js";import"./chunks/chunk-QN2BHP3M.js";import"./chunks/chunk-NTK2MHJ5.js";import"./chunks/chunk-7ASLQ243.js";import"./chunks/chunk-IKOFCODM.js";process.title=`${APP_NAME}-rpc`;scrubBrandFromEnvironment();process.env.PI_CODING_AGENT="true";process.env.AI_AGENT=APP_NAME;process.emitWarning=(()=>{});configureHttpDispatcher();main(["--mode","rpc",...process.argv.slice(2)]);
+import"./chunks/chunk-UFJ2K7Q7.js";import{main}from"./chunks/chunk-J2U5VDG7.js";import"./chunks/chunk-MXZPAUFB.js";import"./chunks/chunk-FHXR4ZAC.js";import{configureHttpDispatcher}from"./chunks/chunk-2EFVQWXZ.js";import"./chunks/chunk-DXJJP6RP.js";import"./chunks/chunk-GXY5JEI5.js";import"./chunks/chunk-JRXKLIEQ.js";import"./chunks/chunk-GY5MR5KR.js";import"./chunks/chunk-EHQXLHRB.js";import"./chunks/chunk-XF3LJC3O.js";import"./chunks/chunk-CNPDUC4D.js";import"./chunks/chunk-CDRFFHLL.js";import"./chunks/chunk-RXKNOEQQ.js";import"./chunks/chunk-Y5OTHMXO.js";import"./chunks/chunk-MLVIYDHK.js";import"./chunks/chunk-TIVW4P37.js";import"./chunks/chunk-H4QOEVS5.js";import"./chunks/chunk-3LNSLJ7N.js";import"./chunks/chunk-MSQCTH6V.js";import"./chunks/chunk-KLAX467B.js";import"./chunks/chunk-JFFS72FL.js";import"./chunks/chunk-ORXZXUMC.js";import"./chunks/chunk-GZVCRV7I.js";import"./chunks/chunk-SOMFLLPD.js";import"./chunks/chunk-MTQQ2VQH.js";import"./chunks/chunk-KJZAY5YH.js";import"./chunks/chunk-W2BKZBYJ.js";import"./chunks/chunk-QMRJYMNH.js";import"./chunks/chunk-LYGAV6KU.js";import"./chunks/chunk-4AOMNOGY.js";import"./chunks/chunk-KUPQO7MC.js";import"./chunks/chunk-U67ML6CQ.js";import"./chunks/chunk-26UBFF6N.js";import"./chunks/chunk-YN7ELQ43.js";import"./chunks/chunk-OI4NMCKP.js";import"./chunks/chunk-G2UETS2R.js";import"./chunks/chunk-VNN2V74Y.js";import"./chunks/chunk-4WZRVZNX.js";import"./chunks/chunk-U3VOXCGP.js";import"./chunks/chunk-WFXUCVIR.js";import"./chunks/chunk-HB35RBP4.js";import"./chunks/chunk-Z6WGAK7W.js";import"./chunks/chunk-DLAY7CIU.js";import"./chunks/chunk-3BTN337S.js";import"./chunks/chunk-QXREUA5F.js";import"./chunks/chunk-RUGYFYH7.js";import"./chunks/chunk-OEFCY46F.js";import"./chunks/chunk-KRNXUTZJ.js";import"./chunks/chunk-TAV6QZFM.js";import"./chunks/chunk-PELNNWGO.js";import"./chunks/chunk-TTU2RNVX.js";import"./chunks/chunk-FDL4CF6F.js";import"./chunks/chunk-BWA4FVFW.js";import"./chunks/chunk-YU4AYH4C.js";import"./chunks/chunk-E6WYH3ZL.js";import"./chunks/chunk-COH5F7QV.js";import"./chunks/chunk-RFB5CBW7.js";import"./chunks/chunk-2VZJTDUX.js";import"./chunks/chunk-E4LBKOZG.js";import"./chunks/chunk-GVSBCJFI.js";import"./chunks/chunk-WASCMT6Y.js";import"./chunks/chunk-T36LJ6MW.js";import"./chunks/chunk-QGJLZ6BI.js";import"./chunks/chunk-WHPDEDCC.js";import"./chunks/chunk-AA2L2RHH.js";import"./chunks/chunk-HK46JMSC.js";import"./chunks/chunk-4P7WARQZ.js";import"./chunks/chunk-WDTJ6JKE.js";import"./chunks/chunk-5ROMKDLK.js";import"./chunks/chunk-3W47LTXQ.js";import"./chunks/chunk-6AOVUTUR.js";import"./chunks/chunk-45SZOLCU.js";import"./chunks/chunk-DMI55M2N.js";import"./chunks/chunk-PJ34QVL5.js";import"./chunks/chunk-BMX2U22F.js";import"./chunks/chunk-YU2P3CAR.js";import"./chunks/chunk-XBUSVKWC.js";import"./chunks/chunk-ZOFZRJSL.js";import"./chunks/chunk-2SOVDETB.js";import"./chunks/chunk-V3CK2AVC.js";import"./chunks/chunk-VRDU425E.js";import"./chunks/chunk-ZGAB7WQA.js";import{APP_NAME,scrubBrandFromEnvironment}from"./chunks/chunk-7YO7VQZW.js";import"./chunks/chunk-ATQFN5HI.js";import"./chunks/chunk-MIENF2YK.js";import"./chunks/chunk-OXNWERO4.js";import"./chunks/chunk-QN2BHP3M.js";import"./chunks/chunk-NTK2MHJ5.js";import"./chunks/chunk-O5RYI3IW.js";import"./chunks/chunk-IKOFCODM.js";process.title=`${APP_NAME}-rpc`;scrubBrandFromEnvironment();process.env.PI_CODING_AGENT="true";process.env.AI_AGENT=APP_NAME;process.emitWarning=(()=>{});configureHttpDispatcher();main(["--mode","rpc",...process.argv.slice(2)]);

package/dist/bundle/runtime-manifest.json

@@ -1 +1 @@
-{"buildId":"3f292cb226833e18","externals":["@earendil-works/chord","@earendil-works/pi-pty","@silvia-odwyer/photon-node","bufferutil","canvas","kerberos","supports-color","utf-8-validate"]}
+{"buildId":"256057df5dd08be8","externals":["@earendil-works/chord","@earendil-works/pi-pty","@silvia-odwyer/photon-node","bufferutil","canvas","kerberos","supports-color","utf-8-validate"]}

package/dist/core/agent-session.d.ts

@@ -1708,6 +1708,7 @@ export declare class AgentSession {
     noteAutomaticInput(text: string): boolean;
     private _stopAddedSince;
     private _stopHoldLive;
+    private _resumeCause;
     get pauseView(): {
         pauseSeq: number;
         records: {

package/dist/core/agent-session.js

@@ -56,7 +56,7 @@ import { assertExpectedUserLeaf, buildEditedUserMessage, UserEditError, userText
 import { ENGINE_PAUSED_ENTRY_TYPE, enginePauseSinceLastTurn, settledRepetitiveTurnPause } from "./engine-paused.js";
 import { EngineTurnHold, engineTurnHoldHistory, engineWakeSource } from "./engine-turn-hold.js";
 import { EngineTurnInput } from "./engine-turn-input.js";
-import { ENGINE_TURN_LIMIT_ENTRY_TYPE, ENGINE_TURN_LIMIT_EVENT, ENGINE_TURN_START_ENTRY_TYPE, engineTurnHistory, engineTurnLimitNotice, engineTurnStop, isUserDirectedTurn, } from "./engine-turn-limit.js";
+import { ENGINE_TURN_LIMIT_ENTRY_TYPE, ENGINE_TURN_LIMIT_EVENT, ENGINE_TURN_START_ENTRY_TYPE, engineTurnHistory, engineTurnLimitNotice, engineTurnStop, isUserDirectedTurn, resetsEngineTurnHistory, } from "./engine-turn-limit.js";
 import { EngineTurnRelease } from "./engine-turn-release.js";
 import { environmentContextMessageIfChanged, resolveEnvironmentContext, } from "./environment-context.js";
 import { areExperimentalFeaturesEnabled } from "./experimental.js";
@@ -5771,7 +5771,11 @@ export class AgentSession {
             });
         const deliveredNotices = this._engineTurnHold.noticeCount;
         const deliveredHeldInputs = this._heldInputs.pending().length;
-        if (this._stopHoldLive() || this._engineTurnHold.fences.length > 0 || deliveredHeldInputs > 0) {
+        // Payload-free notices (including goals) revalidate through their producer after release.
+        // An interruption must not add a directive-only turn when that work has already completed.
+        const resumeHeldTurn = this._stopHoldLive() &&
+            (this._resumeCause() === "stop" || deliveredNotices === 0 || this._engineTurnHold.messages().length > 0);
+        if (resumeHeldTurn || this._engineTurnHold.fences.length > 0 || deliveredHeldInputs > 0) {
             const { turnStarted, settled } = await this._resumeAfterStop(onQueued);
             return {
                 answer: { resumed: true, pauseSeq, turnStarted, deliveredNotices, deliveredHeldInputs },
@@ -5810,8 +5814,9 @@ export class AgentSession {
      * resume settlement delivered the turn.
      */
     async _resumeAfterStop(onQueued) {
+        const resumeCause = this._resumeCause();
         const sources = this._engineTurnHold.releaseAll("resume_session");
-        const { turnId, delivered } = await this._startResumeTurn(onQueued);
+        const { turnId, delivered } = await this._startResumeTurn(onQueued, resumeCause);
         const settled = (async () => {
             if (!(await delivered)) {
                 this._engineTurnHold.rejectInput();
@@ -5833,7 +5838,7 @@ export class AgentSession {
         return this._resumeSettlement;
     }
     /** The resume turn both resume paths start; held input and notices are consumed only if no newer Stop aborted it. */
-    async _startResumeTurn(onQueued) {
+    async _startResumeTurn(onQueued, resumeCause = "stop") {
         const settlement = Promise.withResolvers();
         this._resumeSettlement = settlement.promise;
         try {
@@ -5864,7 +5869,7 @@ export class AgentSession {
                 }));
                 // The hold is already released: include new or re-held input before sending, and omit withdrawals.
             }
-            const started = await this._startResumeTurnWith(generation, continues, heldInputs, onQueued);
+            const started = await this._startResumeTurnWith(generation, continues, heldInputs, onQueued, resumeCause);
             started.delivered.then(() => settlement.resolve(), () => settlement.resolve());
             return started;
         }
@@ -5873,8 +5878,9 @@ export class AgentSession {
             throw error;
         }
     }
-    _startResumeTurnWith(generation, continues, heldInputs, onQueued) {
+    _startResumeTurnWith(generation, continues, heldInputs, onQueued, resumeCause = "stop") {
         return startRunResumeTurn({
+            resumeCause,
             heldInputs: () => heldInputs,
             continueInputs: () => [...continues],
             heldWakes: () => this._engineTurnHold.messages(),
@@ -5906,7 +5912,7 @@ export class AgentSession {
             return;
         this._releaseExtrasGeneration = this._userAbortGeneration;
         if (this._stopHoldLive())
-            this._releaseExtras.push({ role: "custom", ...stopResumeDirective(), timestamp: Date.now() });
+            this._releaseExtras.push({ role: "custom", ...stopResumeDirective(this._resumeCause()), timestamp: Date.now() });
         const { messages, commands } = this._takeHeldInputs();
         this._releaseExtras.push(...messages);
         // A later capture that finds no commands keeps the run an earlier one (a question answer's) still owes.
@@ -6019,7 +6025,7 @@ export class AgentSession {
         });
     }
     noteAutomaticInput(text) {
-        const userHold = this._engineTurnHold.holds.some((hold) => hold.kind === "session_hold" || hold.kind === "inherited_hold");
+        const userHold = this._engineTurnHold.holds.some((hold) => (hold.kind === "session_hold" && hold.key !== "interrupted-run") || hold.kind === "inherited_hold");
         if (!userHold)
             return false;
         const message = {
@@ -6039,6 +6045,13 @@ export class AgentSession {
     _stopHoldLive() {
         return this._engineTurnHold.holds.some((hold) => hold.kind === "session_hold");
     }
+    _resumeCause() {
+        const holds = this._engineTurnHold.holds;
+        return holds.some((hold) => hold.kind === "session_hold" && hold.key === "interrupted-run") &&
+            !holds.some((hold) => hold.kind === "session_hold" && hold.key !== "interrupted-run")
+            ? "interrupted"
+            : "stop";
+    }
     get pauseView() {
         return {
             pauseSeq: this._engineTurnHold.currentPauseSeq,
@@ -6150,7 +6163,8 @@ export class AgentSession {
     }
     /** Keeps this process's engine-turn record: a user message clears it, a tool call marks the running engine turn. */
     _observeEngineTurnMessage(message) {
-        if (message.role === "user" || (message.role === "custom" && isUserDirectedTurn(message.customType))) {
+        if (message.role === "user" ||
+            (message.role === "custom" && resetsEngineTurnHistory(message.customType, message.details))) {
             this._engineTurnStarts = [];
             this._engineResumeWindow = false;
             this._engineTurnPauseRecorded = false;
@@ -6615,6 +6629,7 @@ export class AgentSession {
     /** A user Stop: hold automatic turns until human input or resume_session, then stop the running turn (senpi#3811). */
     async stop() {
         this._runHolds.stamp();
+        this.refreshLifecycle();
         this._stopInterrupt = { pauseSeq: this._engineTurnHold.currentPauseSeq, at: new Date().toISOString() };
         try {
             await this.abort();
@@ -9211,6 +9226,10 @@ export class AgentSession {
                 this._extensionErrorListener = bindings.onError;
             }
             this._applyExtensionBindings(this._extensionRunner);
+            // Opening a session is not explicit Resume. Install the same hold used by Stop before
+            // session_start producers run, so automatic work waits quietly in notice custody.
+            if (this._lifecycleBinding.controller.requiresHumanContinuation)
+                this._engineTurnHold.addHold("session_hold", { key: "interrupted-run" });
             this._engineTurnHold.start();
             this.syncPromptCacheSafeWaitEnv();
             await this._extensionRunner.emit({

package/dist/core/engine-turn-limit.d.ts

@@ -27,6 +27,8 @@ export interface EngineTurnStop {
 export declare function engineTurnLimitNotice(stop: EngineTurnStop): string;
 /** A `.` manual continue or a continue-from-leaf is the user's own request, not an automatic turn. */
 export declare function isUserDirectedTurn(customType: string): boolean;
+/** Recovering an interrupted run is not a new message that resets the unattended turn budget. */
+export declare function resetsEngineTurnHistory(customType: string, details?: unknown): boolean;
 /** The session's engine turns since the user's last message, in order: when each started and whether its reply called a tool. */
 export interface EngineTurnHistory {
     readonly starts: EngineTurnStartRecord[];

package/dist/core/engine-turn-limit.js

@@ -23,9 +23,15 @@ export function isUserDirectedTurn(customType) {
         customType === CONTINUE_FROM_LEAF_CUSTOM_TYPE ||
         customType === STOP_RESUME_CUSTOM_TYPE);
 }
+/** Recovering an interrupted run is not a new message that resets the unattended turn budget. */
+export function resetsEngineTurnHistory(customType, details) {
+    return (isUserDirectedTurn(customType) &&
+        !(customType === STOP_RESUME_CUSTOM_TYPE &&
+            details?.resumeCause === "interrupted"));
+}
 function isUserMessage(entry) {
     if (entry.type === "custom_message")
-        return isUserDirectedTurn(entry.customType);
+        return resetsEngineTurnHistory(entry.customType, entry.details);
     return entry.type === "message" && entry.message.role === "user";
 }
 function isEngineTurnStart(entry) {

package/dist/core/extensions/builtin/anthropic-subscription/auth-attempt.js

@@ -24,6 +24,11 @@ async function* closingQueryMessages(query) {
     }
 }
 export async function createAttemptMessages(input, auth) {
+    // Claude Code loads auto memory independently of settingSources. Keep its private
+    // notes out of every subscription session, after all auth and caller overrides.
+    auth.options.env = { ...auth.options.env, CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" };
+    if (typeof auth.options.settings !== "string")
+        auth.options.settings = { ...auth.options.settings, autoMemoryEnabled: false };
     if (input.createAttempt)
         return recordingLimitWindows(retainedAttemptMessages(await input.createAttempt(auth)), auth);
     const query = input.query({ prompt: input.prompt, options: auth.options });

package/dist/core/extensions/builtin/anthropic-subscription/session-binding.d.ts

@@ -9,6 +9,8 @@ export type BindingInvalidation = {
     readonly schemaVersion: 1;
     readonly invalidated: true;
     readonly reason: string;
+    /** senpi#1975: first diverged field path, only on assistant_rewritten records. Paths only, never values. */
+    readonly divergedPath?: string;
 };
 type BranchEntry = {
     readonly id?: string;

package/dist/core/extensions/builtin/anthropic-subscription/session-commit-boundary.d.ts

@@ -1,5 +1,10 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 export type AssistantCommitOutcome = "clean" | "rewritten" | "not-resident";
+export type AssistantCommitResult = {
+    outcome: AssistantCommitOutcome;
+    /** senpi#1975: first diverged field path on a rewrite. Paths only, never values. */
+    divergedPath?: string;
+};
 export declare function assistantContentHash(message: AssistantMessage): string;
 export declare function isResidentAssistant(message: AssistantMessage, modelId: string): boolean;
 export declare function isTerminalFailure(message: AssistantMessage): boolean;
@@ -12,7 +17,7 @@ export declare function isTerminalFailure(message: AssistantMessage): boolean;
 export declare class AssistantCommitBoundary {
     private readonly providerFinalByKey;
     captureProviderFinal(key: string, message: AssistantMessage): void;
-    commit(key: string, message: AssistantMessage, modelId: string): AssistantCommitOutcome;
+    commit(key: string, message: AssistantMessage, modelId: string): AssistantCommitResult;
     forget(key: string): void;
 }
 //# sourceMappingURL=session-commit-boundary.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/session-commit-boundary.js

@@ -1,5 +1,6 @@
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "./account-management.js";
 import { CLAUDE_SDK_OAUTH_API_ID } from "./api-id.js";
+import { firstDivergedPath, snapshotProjection, } from "./session-commit-divergence.js";
 import { sessionSyncDigest } from "./session-sync.js";
 /**
  * Only the payload the model produced is fingerprinted. Everything the stream
@@ -21,14 +22,17 @@ function semanticContentBlock(block) {
             return block;
     }
 }
-export function assistantContentHash(message) {
-    return sessionSyncDigest({
+function semanticProjection(message) {
+    return {
         role: message.role,
         api: message.api,
         provider: message.provider,
         model: message.model,
         content: message.content.map(semanticContentBlock),
-    });
+    };
+}
+export function assistantContentHash(message) {
+    return sessionSyncDigest(semanticProjection(message));
 }
 export function isResidentAssistant(message, modelId) {
     return (message.api === CLAUDE_SDK_OAUTH_API_ID &&
@@ -49,16 +53,23 @@ export class AssistantCommitBoundary {
         this.providerFinalByKey = new Map();
     }
     captureProviderFinal(key, message) {
-        this.providerFinalByKey.set(key, assistantContentHash(message));
+        const projection = semanticProjection(message);
+        this.providerFinalByKey.set(key, {
+            hash: sessionSyncDigest(projection),
+            projection: snapshotProjection(projection),
+        });
     }
     commit(key, message, modelId) {
         const providerFinal = this.providerFinalByKey.get(key);
         this.providerFinalByKey.delete(key);
         if (!isResidentAssistant(message, modelId))
-            return "not-resident";
+            return { outcome: "not-resident" };
         if (providerFinal === undefined)
-            return "clean";
-        return providerFinal === assistantContentHash(message) ? "clean" : "rewritten";
+            return { outcome: "clean" };
+        const committed = semanticProjection(message);
+        if (providerFinal.hash === sessionSyncDigest(committed))
+            return { outcome: "clean" };
+        return { outcome: "rewritten", divergedPath: firstDivergedPath(providerFinal.projection, committed) };
     }
     forget(key) {
         this.providerFinalByKey.delete(key);

package/dist/core/extensions/builtin/anthropic-subscription/session-commit-divergence.d.ts

@@ -0,0 +1,23 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+export type AssistantSemanticProjection = {
+    role: AssistantMessage["role"];
+    api: AssistantMessage["api"];
+    provider: AssistantMessage["provider"];
+    model: AssistantMessage["model"];
+    content: unknown[];
+};
+/**
+ * The captured projection must be a snapshot, not a reference: the rewrite
+ * class this exists for (senpi#1472, senpi#1975) mutates tool-call arguments in
+ * place between `message_update` and `message_end`, and a shared reference
+ * would follow the mutation and blind the walk to exactly that case.
+ */
+export declare function snapshotProjection(projection: AssistantSemanticProjection): AssistantSemanticProjection;
+/**
+ * First diverged path between the provider-final and committed projections:
+ * `content.length`, then per block `type`, its semantic fields, and for
+ * toolCall blocks `arguments.<path>`, then `api` / `provider` / `model`.
+ * Only paths leave this function; no value from either side is embedded.
+ */
+export declare function firstDivergedPath(providerFinal: AssistantSemanticProjection, committed: AssistantSemanticProjection): string;
+//# sourceMappingURL=session-commit-divergence.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/session-commit-divergence.js

@@ -0,0 +1,107 @@
+const MAX_DIVERGENCE_DEPTH = 16;
+// The walk starts at `arguments`, one level below the block the snapshot starts at, and still compares one level past
+// its cap; the snapshot copies two levels further so every value the walk can reach is a copy, not a shared reference.
+const MAX_SNAPSHOT_DEPTH = MAX_DIVERGENCE_DEPTH + 2;
+// Argument keys are model-produced data: only a short plain identifier is named in a path. Anything else (long,
+// or containing `.`/`[` that would make the path ambiguous) is named by its sorted position, never by its text.
+const PLAIN_KEY = /^[A-Za-z_$][A-Za-z0-9_$-]{0,63}$/;
+function keySegment(key, position) {
+    return PLAIN_KEY.test(key) ? `.${key}` : `.<key#${position}>`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The captured projection must be a snapshot, not a reference: the rewrite
+ * class this exists for (senpi#1472, senpi#1975) mutates tool-call arguments in
+ * place between `message_update` and `message_end`, and a shared reference
+ * would follow the mutation and blind the walk to exactly that case.
+ */
+export function snapshotProjection(projection) {
+    return { ...projection, content: projection.content.map((block) => snapshotValue(block, 0)) };
+}
+function snapshotValue(value, depth) {
+    if (depth > MAX_SNAPSHOT_DEPTH)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => snapshotValue(item, depth + 1));
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).map((key) => [key, snapshotValue(value[key], depth + 1)]));
+}
+function fieldOf(block, field) {
+    return isRecord(block) ? block[field] : undefined;
+}
+/**
+ * First diverged sub-path between two JSON-shaped values: objects contribute
+ * `.key` (sorted, so the path is deterministic), arrays contribute `[n]`, and a
+ * length difference names the first index present on only one side. Returns ""
+ * when the values at this position differ and undefined when they are equal;
+ * past the depth cap the parent position is named instead of recursing.
+ */
+function firstDivergedSegment(left, right, depth) {
+    if (left === right)
+        return undefined;
+    if (depth > MAX_DIVERGENCE_DEPTH)
+        return "";
+    if (Array.isArray(left) && Array.isArray(right)) {
+        const shared = Math.min(left.length, right.length);
+        for (let index = 0; index < shared; index += 1) {
+            const inner = firstDivergedSegment(left[index], right[index], depth + 1);
+            if (inner !== undefined)
+                return `[${index}]${inner}`;
+        }
+        return left.length === right.length ? undefined : `[${shared}]`;
+    }
+    if (isRecord(left) && isRecord(right)) {
+        const keys = [...new Set([...Object.keys(left), ...Object.keys(right)])].sort();
+        for (const [position, key] of keys.entries()) {
+            const inner = firstDivergedSegment(left[key], right[key], depth + 1);
+            if (inner !== undefined)
+                return `${keySegment(key, position)}${inner}`;
+        }
+        return undefined;
+    }
+    return "";
+}
+function firstDivergedBlockField(index, left, right) {
+    const kind = fieldOf(left, "type");
+    if (kind !== fieldOf(right, "type"))
+        return `content[${index}].type`;
+    const scalarFields = kind === "text"
+        ? ["text"]
+        : kind === "thinking"
+            ? ["thinking", "thinkingSignature"]
+            : kind === "toolCall"
+                ? ["id", "name"]
+                : undefined;
+    if (scalarFields === undefined) {
+        const segment = firstDivergedSegment(left, right, 0);
+        return segment === undefined ? undefined : `content[${index}]${segment}`;
+    }
+    const field = scalarFields.find((name) => fieldOf(left, name) !== fieldOf(right, name));
+    if (field !== undefined)
+        return `content[${index}].${field}`;
+    if (kind !== "toolCall")
+        return undefined;
+    const argumentsSegment = firstDivergedSegment(fieldOf(left, "arguments"), fieldOf(right, "arguments"), 0);
+    return argumentsSegment === undefined ? undefined : `content[${index}].arguments${argumentsSegment}`;
+}
+/**
+ * First diverged path between the provider-final and committed projections:
+ * `content.length`, then per block `type`, its semantic fields, and for
+ * toolCall blocks `arguments.<path>`, then `api` / `provider` / `model`.
+ * Only paths leave this function; no value from either side is embedded.
+ */
+export function firstDivergedPath(providerFinal, committed) {
+    if (providerFinal.content.length !== committed.content.length)
+        return "content.length";
+    for (let index = 0; index < providerFinal.content.length; index += 1) {
+        const path = firstDivergedBlockField(index, providerFinal.content[index], committed.content[index]);
+        if (path !== undefined)
+            return path;
+    }
+    const identityField = ["api", "provider", "model"].find((field) => providerFinal[field] !== committed[field]);
+    return identityField ?? "content";
+}
+//# sourceMappingURL=session-commit-divergence.js.map

package/dist/core/extensions/builtin/anthropic-subscription/session-entry-annotations.d.ts

@@ -4,7 +4,7 @@ export type AnnotatableRegistry = {
     touch(entry: AnthropicSubscriptionSessionEntry): void;
 };
 export declare function switchEntryModel(registry: AnnotatableRegistry, senpiSessionId: string, modelId: string, sdkModel?: string): Promise<boolean>;
-export declare function annotatePendingFork(registry: AnnotatableRegistry, senpiSessionId: string, reason: string): void;
+export declare function annotatePendingFork(registry: AnnotatableRegistry, senpiSessionId: string, reason: string, divergedPath?: string): void;
 export declare function annotateTainted(registry: AnnotatableRegistry, senpiSessionId: string, reason: string): void;
 export declare function annotateBranchInfo(registry: AnnotatableRegistry, senpiSessionId: string, info: SessionBranchInfo): void;
 //# sourceMappingURL=session-entry-annotations.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/session-entry-annotations.js

@@ -8,11 +8,13 @@ export async function switchEntryModel(registry, senpiSessionId, modelId, sdkMod
     registry.touch(entry);
     return true;
 }
-export function annotatePendingFork(registry, senpiSessionId, reason) {
+export function annotatePendingFork(registry, senpiSessionId, reason, divergedPath) {
     const entry = registry.get(senpiSessionId);
     if (!entry)
         return;
     entry.pendingForkReason = reason;
+    // A fork recorded without a path (compaction, tree change) must not inherit an earlier rewrite's path.
+    entry.pendingForkDivergedPath = divergedPath ?? null;
     registry.touch(entry);
 }
 export function annotateTainted(registry, senpiSessionId, reason) {

package/dist/core/extensions/builtin/anthropic-subscription/session-observability.d.ts

@@ -27,6 +27,8 @@ export type ContinuityObservation = {
     seat?: string;
     /** The attempt runs on a different seat than the lineage's last one: its prompt cache is cold. */
     seatChanged?: boolean;
+    /** senpi#1975: first diverged field path behind an assistant_rewritten decision. Paths only, never values. */
+    divergedPath?: string;
 };
 export type ContinuityObservabilityBoundary = {
     emit: (observation: ContinuityObservation) => void;
@@ -62,6 +64,7 @@ export declare function observeSessionSyncDecision(input: {
     senpiSessionId: string;
     payloadBytes?: number;
     collapsedDirectives?: number;
+    divergedPath?: string;
 }): ContinuityObservation;
 export type StagedContinuityDecision = {
     observation: ContinuityObservation;

package/dist/core/extensions/builtin/anthropic-subscription/session-observability.js

@@ -133,6 +133,7 @@ export function consumePendingCloseCause(senpiSessionId) {
  * incremental→delta, resume→fork, cold-seed→flatten.
  */
 export function observeSessionSyncDecision(input) {
+    const diverged = input.divergedPath === undefined ? {} : { divergedPath: input.divergedPath };
     if (input.kind === "incremental") {
         return { kind: "delta", reason: "prefix_matched", deltaMessages: input.deltaMessages };
     }
@@ -142,6 +143,7 @@ export function observeSessionSyncDecision(input) {
             kind: "fork",
             reason: retainedCause ?? (input.reason === undefined ? "branch_resume" : sanitizeReason(input.reason)),
             deltaMessages: input.deltaMessages,
+            ...diverged,
         };
     }
     // Peek, not consume: the staged observation is emitted only when the
@@ -155,6 +157,7 @@ export function observeSessionSyncDecision(input) {
         deltaMessages: input.deltaMessages,
         ...(input.payloadBytes !== undefined ? { payloadBytes: input.payloadBytes } : {}),
         ...(input.collapsedDirectives !== undefined ? { collapsedDirectives: input.collapsedDirectives } : {}),
+        ...diverged,
     };
 }
 /** Stages an attempt's decision; `emit` fires only when the attempt is retained. */
@@ -181,6 +184,7 @@ export function emitContinuityObservation(observation, sessionId, onDecision) {
         ...(observation.settingSource === undefined ? {} : { settingSource: observation.settingSource }),
         ...(observation.seat === undefined ? {} : { seat: observation.seat }),
         ...(observation.seatChanged === undefined ? {} : { seatChanged: observation.seatChanged }),
+        ...(observation.divergedPath === undefined ? {} : { divergedPath: observation.divergedPath }),
         ...(sessionId === undefined ? {} : { sessionId }),
     });
 }

package/dist/core/extensions/builtin/anthropic-subscription/session-registry-wiring.js

@@ -9,17 +9,22 @@ import { bindingFromEntry, forgetBinding, getBinding, rememberBinding, rememberB
 import { closeSession, getSession, recordBranchInfo, recordPendingFork, switchSessionModel, } from "./session-registry.js";
 import { sentHashesForEntry, sentMessageHashes, sentMessages } from "./session-sync.js";
 const commitBoundary = new AssistantCommitBoundary();
-function persistBindingInvalidation(pi, sessionId, reason) {
-    pi.appendEntry?.(BINDING_ENTRY_TYPE, { schemaVersion: 1, invalidated: true, reason });
+function persistBindingInvalidation(pi, sessionId, reason, divergedPath) {
+    pi.appendEntry?.(BINDING_ENTRY_TYPE, {
+        schemaVersion: 1,
+        invalidated: true,
+        reason,
+        ...(divergedPath === undefined ? {} : { divergedPath }),
+    });
     rememberBindingInvalidation(sessionId, reason);
 }
-async function invalidateBinding(pi, ctx, reason) {
+async function invalidateBinding(pi, ctx, reason, divergedPath) {
     const sessionId = ctx.sessionManager.getSessionId();
     forgetBinding(sessionId);
     const sessionFile = ctx.sessionManager.getSessionFile?.();
     if (sessionFile)
         await deleteStoredBinding(sessionFile);
-    persistBindingInvalidation(pi, sessionId, reason);
+    persistBindingInvalidation(pi, sessionId, reason, divergedPath);
 }
 function keepBindingThenClose(sessionId, reason) {
     const entry = getSession(sessionId);
@@ -129,10 +134,10 @@ export function registerSessionRegistry(pi) {
             commitBoundary.forget(sessionId);
             return;
         }
-        const outcome = commitBoundary.commit(sessionId, event.message, modelId);
+        const { outcome, divergedPath } = commitBoundary.commit(sessionId, event.message, modelId);
         if (outcome === "rewritten") {
-            recordPendingFork(sessionId, "assistant_rewritten");
-            await invalidateBinding(pi, ctx, "assistant_rewritten");
+            recordPendingFork(sessionId, "assistant_rewritten", divergedPath);
+            await invalidateBinding(pi, ctx, "assistant_rewritten", divergedPath);
             return;
         }
         // Only an assistant this provider actually produced may anchor a record.

package/dist/core/extensions/builtin/anthropic-subscription/session-registry.d.ts

@@ -41,6 +41,8 @@ export interface AnthropicSubscriptionSessionEntry {
     taintedReason: string | null;
     /** Wave C seam: a divergence boundary recorded for the next continuity decision. */
     pendingForkReason: string | null;
+    /** senpi#1975: first diverged field path the commit boundary named for the pending fork, when it named one. */
+    pendingForkDivergedPath: string | null;
     lastUsedAt: number;
     /** Digest of the access token the resident subprocess was spawned with. */
     credentialDigest?: string;
@@ -91,7 +93,7 @@ export declare function closeSession(senpiSessionId: string, reason: string): vo
 export declare function isIdleExpired(entry: Pick<AnthropicSubscriptionSessionEntry, "lastUsedAt">): boolean;
 export declare function markTainted(senpiSessionId: string, reason: string): void;
 export declare function switchSessionModel(senpiSessionId: string, modelId: string, sdkModel?: string): Promise<boolean>;
-export declare function recordPendingFork(senpiSessionId: string, reason: string): void;
+export declare function recordPendingFork(senpiSessionId: string, reason: string, divergedPath?: string): void;
 export declare function recordBranchInfo(senpiSessionId: string, info: SessionBranchInfo): void;
 export declare function isCurrentGeneration(senpiSessionId: string, generation: number): boolean;
 export declare function isBoundAccountTokenExpiring(entry: Pick<AnthropicSubscriptionSessionEntry, "accountName">, accounts: readonly Pick<AccountSlot, "name" | "expires" | "source">[]): boolean;

package/dist/core/extensions/builtin/anthropic-subscription/session-registry.js

@@ -162,6 +162,7 @@ export class AnthropicSubscriptionSessionRegistry {
             branchInfo: null,
             taintedReason: null,
             pendingForkReason: null,
+            pendingForkDivergedPath: null,
             lastUsedAt: now,
         };
         // oxlint-disable-next-line eslint/prefer-const -- a closure reads it; const would throw in the TDZ if that closure ran before the assignment, so the rewrite is reviewed separately
@@ -250,8 +251,8 @@ export function markTainted(senpiSessionId, reason) {
 export async function switchSessionModel(senpiSessionId, modelId, sdkModel) {
     return switchEntryModel(sessionRegistry, senpiSessionId, modelId, sdkModel);
 }
-export function recordPendingFork(senpiSessionId, reason) {
-    annotatePendingFork(sessionRegistry, senpiSessionId, reason);
+export function recordPendingFork(senpiSessionId, reason, divergedPath) {
+    annotatePendingFork(sessionRegistry, senpiSessionId, reason, divergedPath);
 }
 export function recordBranchInfo(senpiSessionId, info) {
     annotateBranchInfo(sessionRegistry, senpiSessionId, info);

package/dist/core/extensions/builtin/anthropic-subscription/session-stream.js

@@ -155,6 +155,7 @@ async function createResidentAttempt(input, auth) {
         ? flattenResult.blocks
         : buildDeltaPromptBlocks(messages.slice(from), input.customToolNameToSdk);
     const payloadBytes = flattenResult ? serializedPayloadBytes(flattenResult.blocks) : undefined;
+    const divergedPath = observedReason === "assistant_rewritten" ? (existing?.pendingForkDivergedPath ?? undefined) : undefined;
     const staged = stageContinuityDecision({
         ...observeSessionSyncDecision({
             kind: observedKind,
@@ -166,6 +167,7 @@ async function createResidentAttempt(input, auth) {
             ...(flattenResult?.collapsedDirectives !== undefined
                 ? { collapsedDirectives: flattenResult.collapsedDirectives }
                 : {}),
+            ...(divergedPath === undefined ? {} : { divergedPath }),
         }),
         ...seat,
     }, sessionId, input.onContinuityDecision, 

package/dist/core/extensions/builtin/goal/stop-pause.js

@@ -1,7 +1,8 @@
 export const GOAL_STOP_PAUSED_ENTRY = "goal-stop-paused";
 export const GOAL_STOP_RESUMED_ENTRY = "goal-stop-resumed";
 export function stopHoldLive(ctx) {
-    return ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold") === true;
+    return (ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold" && hold.key !== "interrupted-run") ===
+        true);
 }
 export function markStopPaused(pi, goalId) {
     pi.appendEntry(GOAL_STOP_PAUSED_ENTRY, { goalId });

package/dist/core/extensions/builtin/loop/session-hold.js

@@ -2,6 +2,7 @@ export function sessionHeld(ctx) {
     return ctx.getPauseState?.().holds.some((hold) => hold.kind !== "run_fence") === true;
 }
 export function userStopped(ctx) {
-    return ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold") === true;
+    return (ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold" && hold.key !== "interrupted-run") ===
+        true);
 }
 //# sourceMappingURL=session-hold.js.map

package/dist/core/lifecycle-runtime-facts.js

@@ -35,6 +35,9 @@ export function readLifecycleRuntimeFacts(session) {
         });
     }
     const holds = session.holds.flatMap((hold) => {
+        // The interruption gate is a human wait, not a user Stop. Preserve unattended and real Stop precedence.
+        if (hold.kind === "session_hold" && hold.key === "interrupted-run")
+            return [];
         switch (hold.kind) {
             case "unattended":
             case "session_hold":