larkin 0.4.24 → 0.4.25

package/dist/agent/context-prompt.cjs

@@ -41,8 +41,25 @@ class ContextPromptBuilder {
             agent: { id: input.agentId, name: input.name, description: input.description },
             runtime: input.runtime,
             cli: input.cli ?? (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)(),
+            previousSession: input.previousSession ?? null,
         });
     }
+    /** Rendered only for the single most recent predecessor; never a chain. */
+    previousSessionSection(previous) {
+        if (!previous)
+            return [];
+        const location = previous.file
+            ? `\`${clean(previous.file)}\``
+            : `session id \`${clean(previous.sessionId)}\` in the Runtime session directory`;
+        return [
+            "",
+            "## Previous session archive",
+            "",
+            `The session before this one was closed (${clean(previous.reason)}, ${clean(previous.closedAt)}). Its archive is ${location}.`,
+            "Consult it only when the user refers to earlier context. Do not load it whole: use `tail` or `rg` on the file for the relevant part.",
+            "Older archives are kept on disk and are intentionally not referenced here.",
+        ];
+    }
     buildInboxNotice(input) {
         return this.buildRuntimeInput(input.busy ? "inbox_update" : "wake", "notice", input).text;
     }
@@ -57,6 +74,7 @@ class ContextPromptBuilder {
             `You are the persistent Larkin agent **${identity}** (agent id: \`${input.agent.id}\`) running on ${input.runtime}.`,
             `Your authoritative self identity is **${identity}** (agent id: \`${input.agent.id}\`). Do not call \`${command("profile show")}\` merely to learn your identity.`,
             input.agent.description ? `Identity context: ${clean(input.agent.description)}` : "",
+            ...this.previousSessionSection(input.previousSession),
             "",
             "## Message handling",
             "",

package/dist/agent/context-prompt.mjs

@@ -38,8 +38,25 @@ export class ContextPromptBuilder {
             agent: { id: input.agentId, name: input.name, description: input.description },
             runtime: input.runtime,
             cli: input.cli ?? agentCliPromptCapabilities(),
+            previousSession: input.previousSession ?? null,
         });
     }
+    /** Rendered only for the single most recent predecessor; never a chain. */
+    previousSessionSection(previous) {
+        if (!previous)
+            return [];
+        const location = previous.file
+            ? `\`${clean(previous.file)}\``
+            : `session id \`${clean(previous.sessionId)}\` in the Runtime session directory`;
+        return [
+            "",
+            "## Previous session archive",
+            "",
+            `The session before this one was closed (${clean(previous.reason)}, ${clean(previous.closedAt)}). Its archive is ${location}.`,
+            "Consult it only when the user refers to earlier context. Do not load it whole: use `tail` or `rg` on the file for the relevant part.",
+            "Older archives are kept on disk and are intentionally not referenced here.",
+        ];
+    }
     buildInboxNotice(input) {
         return this.buildRuntimeInput(input.busy ? "inbox_update" : "wake", "notice", input).text;
     }
@@ -54,6 +71,7 @@ export class ContextPromptBuilder {
             `You are the persistent Larkin agent **${identity}** (agent id: \`${input.agent.id}\`) running on ${input.runtime}.`,
             `Your authoritative self identity is **${identity}** (agent id: \`${input.agent.id}\`). Do not call \`${command("profile show")}\` merely to learn your identity.`,
             input.agent.description ? `Identity context: ${clean(input.agent.description)}` : "",
+            ...this.previousSessionSection(input.previousSession),
             "",
             "## Message handling",
             "",

package/dist/feishu/host-shell.cjs

@@ -221,6 +221,13 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
     const agentStates = new Map();
     const saveAgentState = (record) => {
         try {
+            const latest = record.store.readJson("agentState", {});
+            if (isRecord(latest.previousSessions)) {
+                record.state.previousSessions = {
+                    ...latest.previousSessions,
+                    ...(record.state.previousSessions ?? {}),
+                };
+            }
             record.store.writeJson("agentState", record.state);
         }
         catch (error) {
@@ -235,7 +242,11 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
         let state;
         try {
             const loaded = store.readJson("agentState", {});
-            state = { ...loaded, sessions: isRecord(loaded.sessions) ? loaded.sessions : {} };
+            state = {
+                ...loaded,
+                sessions: isRecord(loaded.sessions) ? loaded.sessions : {},
+                ...(isRecord(loaded.previousSessions) ? { previousSessions: loaded.previousSessions } : {}),
+            };
         }
         catch {
             state = { sessions: {} };
@@ -1309,13 +1320,21 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
         }
         if (message.type === "session") {
             const record = agentStates.get(agent.agentId);
-            if (record && record.state.sessions[message.runtime] !== message.sessionId) {
-                if (message.sessionId)
-                    record.state.sessions[message.runtime] = message.sessionId;
-                else
-                    delete record.state.sessions[message.runtime];
-                saveAgentState(record);
-                log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
+            if (record) {
+                const sessionChanged = record.state.sessions[message.runtime] !== message.sessionId;
+                if (sessionChanged) {
+                    if (message.sessionId)
+                        record.state.sessions[message.runtime] = message.sessionId;
+                    else
+                        delete record.state.sessions[message.runtime];
+                }
+                if (message.previousSession) {
+                    record.state.previousSessions = { ...(record.state.previousSessions ?? {}), [message.runtime]: message.previousSession };
+                }
+                if (sessionChanged || message.previousSession) {
+                    saveAgentState(record);
+                    log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
+                }
             }
             hostState.updateStatus(agent, (0, host_business_state_js_1.projectSessionStatus)(hostState.readStatus(agent), message.runtime, message.sessionId, message.launchId, new Date(), {
                 ...(message.model ? { model: message.model } : {}),
@@ -1564,6 +1583,7 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                 await runtimeHost.start(agents.map((agent) => ({
                     ...agent,
                     sessionId: agentStates.get(agent.agentId)?.state.sessions[agent.runtime] || null,
+                    previousSession: agentStates.get(agent.agentId)?.state.previousSessions?.[agent.runtime] ?? null,
                 })));
                 reminder.startSync();
                 inboxAudit.start();

package/dist/feishu/host-shell.mjs

@@ -181,6 +181,13 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
     const agentStates = new Map();
     const saveAgentState = (record) => {
         try {
+            const latest = record.store.readJson("agentState", {});
+            if (isRecord(latest.previousSessions)) {
+                record.state.previousSessions = {
+                    ...latest.previousSessions,
+                    ...(record.state.previousSessions ?? {}),
+                };
+            }
             record.store.writeJson("agentState", record.state);
         }
         catch (error) {
@@ -195,7 +202,11 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         let state;
         try {
             const loaded = store.readJson("agentState", {});
-            state = { ...loaded, sessions: isRecord(loaded.sessions) ? loaded.sessions : {} };
+            state = {
+                ...loaded,
+                sessions: isRecord(loaded.sessions) ? loaded.sessions : {},
+                ...(isRecord(loaded.previousSessions) ? { previousSessions: loaded.previousSessions } : {}),
+            };
         }
         catch {
             state = { sessions: {} };
@@ -1269,13 +1280,21 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         }
         if (message.type === "session") {
             const record = agentStates.get(agent.agentId);
-            if (record && record.state.sessions[message.runtime] !== message.sessionId) {
-                if (message.sessionId)
-                    record.state.sessions[message.runtime] = message.sessionId;
-                else
-                    delete record.state.sessions[message.runtime];
-                saveAgentState(record);
-                log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
+            if (record) {
+                const sessionChanged = record.state.sessions[message.runtime] !== message.sessionId;
+                if (sessionChanged) {
+                    if (message.sessionId)
+                        record.state.sessions[message.runtime] = message.sessionId;
+                    else
+                        delete record.state.sessions[message.runtime];
+                }
+                if (message.previousSession) {
+                    record.state.previousSessions = { ...(record.state.previousSessions ?? {}), [message.runtime]: message.previousSession };
+                }
+                if (sessionChanged || message.previousSession) {
+                    saveAgentState(record);
+                    log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
+                }
             }
             hostState.updateStatus(agent, projectSessionStatus(hostState.readStatus(agent), message.runtime, message.sessionId, message.launchId, new Date(), {
                 ...(message.model ? { model: message.model } : {}),
@@ -1524,6 +1543,7 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                 await runtimeHost.start(agents.map((agent) => ({
                     ...agent,
                     sessionId: agentStates.get(agent.agentId)?.state.sessions[agent.runtime] || null,
+                    previousSession: agentStates.get(agent.agentId)?.state.previousSessions?.[agent.runtime] ?? null,
                 })));
                 reminder.startSync();
                 inboxAudit.start();

package/dist/runtime/runtime-adapters.mjs

@@ -479,6 +479,7 @@ class PiSession extends EventSession {
             }));
     }
     get sessionId() { return this.sdk.sessionId ?? null; }
+    get sessionFile() { return this.sdk.sessionFile ?? null; }
     get effectiveModel() { return this.sdk.model ? `${this.sdk.model.provider}/${this.sdk.model.id}` : null; }
     get effectiveReasoningEffort() { return this.sdk.thinkingLevel ?? null; }
     async prompt(input) { return this.enqueue(input, () => this.sdk.prompt(input.text)); }
@@ -925,6 +926,7 @@ class PiRpcBackend {
     policy;
     policyManaged;
     sessionId;
+    sessionFile;
     model;
     thinkingLevel;
     constructor(client, state, policy) {
@@ -932,6 +934,7 @@ class PiRpcBackend {
         this.policy = policy;
         this.policyManaged = Boolean(policy);
         this.sessionId = state.sessionId ?? null;
+        this.sessionFile = typeof state.sessionFile === "string" && state.sessionFile ? state.sessionFile : null;
         if (state.model?.provider && state.model.id)
             this.model = {
                 provider: state.model.provider, id: state.model.id,
@@ -953,12 +956,23 @@ class PiRpcBackend {
         if (effectiveModel !== this.policy.model || state.model?.contextWindow !== this.policy.contextWindow) {
             throw new Error("Pi model or context window changed after startup; compaction policy is no longer safe");
         }
-        const ownedSettings = readOwnedPiSettings(this.policy.ownedPiDirectory);
-        assertEffectivePiCompactionSettings({ contextWindow: state.model?.contextWindow, compaction: {
-                enabled: state.autoCompactionEnabled,
-                reserveTokens: ownedSettings.compaction?.reserveTokens,
-                keepRecentTokens: ownedSettings.compaction?.keepRecentTokens,
-            } });
+        if (typeof state.sessionFile === "string" && state.sessionFile)
+            this.sessionFile = state.sessionFile;
+        if (typeof state.sessionId === "string" && state.sessionId)
+            this.sessionId = state.sessionId;
+        // Use the live process handshake, not a disk re-read of owned settings.json.
+        // Disk reserveTokens can drift after startup; that must not reject prompt.
+        const handshake = state.compactionCapabilities;
+        if (typeof handshake?.reserveTokens === "number" && typeof handshake?.keepRecentTokens === "number") {
+            assertEffectivePiCompactionSettings({ contextWindow: state.model?.contextWindow, compaction: {
+                    enabled: state.autoCompactionEnabled,
+                    reserveTokens: handshake.reserveTokens,
+                    keepRecentTokens: handshake.keepRecentTokens,
+                } });
+            return;
+        }
+        if (state.autoCompactionEnabled !== true)
+            throw new Error("Pi native compaction must be enabled");
     }
     getState() { return this.client.request("get_state"); }
     dispose() { return this.client.close(); }

package/dist/runtime/runtime-host.cjs

@@ -45,6 +45,63 @@ const BACKGROUND_COMPLETION_IMMEDIATE_RETRY_LIMIT = 5;
 const DEFAULT_SUBAGENT_RECONCILE_INTERVAL_MS = 15_000;
 const now = () => new Date().toISOString();
 const isActiveDelivery = (status) => ["pending", "submitting", "accepted"].includes(status);
+const previousSessionRefFor = (session, reason) => session.sessionId
+    ? { sessionId: session.sessionId, file: session.sessionFile ?? null, closedAt: new Date().toISOString(), reason }
+    : null;
+function parsePreviousSessionRef(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.sessionId !== "string" || !record.sessionId)
+        return null;
+    if (typeof record.closedAt !== "string" || typeof record.reason !== "string")
+        return null;
+    return {
+        sessionId: record.sessionId,
+        file: typeof record.file === "string" && record.file ? record.file : null,
+        closedAt: record.closedAt,
+        reason: record.reason,
+    };
+}
+function loadPersistedPreviousSession(config, store) {
+    const fromConfig = parsePreviousSessionRef(config.previousSession);
+    if (fromConfig)
+        return fromConfig;
+    if (!store)
+        return null;
+    try {
+        const state = store.readJson("agentState", {});
+        return parsePreviousSessionRef(state.previousSessions?.[config.runtime]);
+    }
+    catch {
+        return null;
+    }
+}
+function persistPreviousSession(agent, previous) {
+    agent.previousSession = previous;
+    agent.config.previousSession = previous;
+    const store = agent.stateStore;
+    if (!store)
+        return;
+    try {
+        const current = store.readJson("agentState", { sessions: {} });
+        // Delivery-ledger mocks ignore the JSON key and would be clobbered by this write.
+        if (Array.isArray(current.records) && !("sessions" in current))
+            return;
+        const previousSessions = current.previousSessions && typeof current.previousSessions === "object"
+            && !Array.isArray(current.previousSessions)
+            ? { ...current.previousSessions }
+            : {};
+        if (previous)
+            previousSessions[agent.adapter.id] = previous;
+        else
+            delete previousSessions[agent.adapter.id];
+        store.writeJson("agentState", { ...current, previousSessions });
+    }
+    catch {
+        // In-memory ref still holds for this process; restart will miss it only if this write failed.
+    }
+}
 const REPLAY_FAILURE_CODES = new Set([
     "canonical_inbox_row_missing", "canonical_inbox_malformed", "duplicate_message_id",
     "inbox_state_conflict", "delivery_target_conflict", "structured_target_invalid",
@@ -466,17 +523,12 @@ function createRuntimeHost(options) {
             && agent.piProactiveCompactionGeneration === agent.generation
             && agent.piProactiveCompactionSession === agent.session
             ? agent.piProactiveCompaction : null;
-        if (proactive && await proactive === "failed") {
-            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-        }
-        if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation) {
-            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-        }
+        if (proactive)
+            await proactive;
         if (agent.adapter.id === "pi" && !busy && !agent.busy && !agent.turnInProgress && agent.session) {
             const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-            if (idleGate && await idleGate === "failed") {
-                return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-            }
+            if (idleGate)
+                await idleGate;
         }
         agent.submitting = true;
         if (!busy)
@@ -550,20 +602,18 @@ function createRuntimeHost(options) {
                 && agent.piProactiveCompactionGeneration === agent.generation
                 && agent.piProactiveCompactionSession === agent.session
                 ? agent.piProactiveCompaction : null;
-            if (proactive && await proactive === "failed")
-                return;
+            if (proactive)
+                await proactive;
             if (agent.submitting || agent.starting) {
                 agent.retryAfterSubmit = true;
                 return;
             }
-            if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation)
-                return;
             if (agent.busy || agent.turnInProgress || !agent.session)
                 return;
             if (agent.adapter.id === "pi") {
                 const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-                if (idleGate && await idleGate === "failed")
-                    return;
+                if (idleGate)
+                    await idleGate;
             }
             const record = [...agent.records.values()].find((candidate) => candidate.status === "pending" || candidate.status === "submitting");
             if (record)
@@ -769,14 +819,12 @@ function createRuntimeHost(options) {
             && agent.piProactiveCompactionGeneration === agent.generation
             && agent.piProactiveCompactionSession === agent.session
             ? agent.piProactiveCompaction : null;
-        if (proactive && await proactive === "failed")
-            return;
-        if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation)
-            return;
+        if (proactive)
+            await proactive;
         if (agent.adapter.id === "pi" && !agent.busy && !agent.turnInProgress && agent.session) {
             const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-            if (idleGate && await idleGate === "failed")
-                return;
+            if (idleGate)
+                await idleGate;
         }
         if (agent.stopped || agent.busy || agent.turnInProgress || agent.submitting)
             return;
@@ -958,8 +1006,8 @@ function createRuntimeHost(options) {
             void ensureSession(agent).then(async () => {
                 const session = agent.session;
                 const proactive = session ? proactivelyCompactPiAtIdle(agent, session) : null;
-                if (proactive && await proactive === "failed")
-                    return;
+                if (proactive)
+                    await proactive;
                 reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "pi session gone" });
                 enqueueUndeliveredTerminalWakes(agent);
                 await retryPending(agent);
@@ -1199,8 +1247,6 @@ function createRuntimeHost(options) {
         })();
         const tracked = task.catch((error) => {
             agent.piProactiveCompactionFailedGeneration = generation;
-            emit({ type: "agent-status", agentId: agent.config.agentId, status: "error",
-                error: "Pi proactive compaction failed; the current session generation is degraded" });
             log("Pi proactive compaction failed", String(error));
             return "failed";
         }).finally(() => {
@@ -1334,10 +1380,7 @@ function createRuntimeHost(options) {
                 emit({ type: "agent-status", agentId: agent.config.agentId, status: "active", readiness: agent.readiness });
             }
             const proactive = proactivelyCompactPiAtIdle(agent, session);
-            void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-                if (outcome !== "failed")
-                    return retryPending(agent);
-            });
+            void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
             queueMicrotask(() => { void scanAndPromoteAcceptedInboxUpdates(agent); });
         }
         else if (event.type === "runtime-observation") {
@@ -1466,7 +1509,7 @@ function createRuntimeHost(options) {
         const standingPrompt = options.promptBuilder.build({
             agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
             description: agent.config.description || "", runtime: agent.adapter.id,
-            cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+            cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"), previousSession: agent.previousSession,
         });
         const generation = ++agent.generation;
         let completedSession = null;
@@ -1526,9 +1569,11 @@ function createRuntimeHost(options) {
             workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir, env: probeEnv }) : { runtime: "pi", state: "ready" };
         if (readiness.state !== "ready")
             throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Pi context fallback readiness failed");
+        const previousRef = previousSessionRefFor(oldSession, "context-window overflow");
         const standingPrompt = options.promptBuilder.build({
             agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
             description: agent.config.description || "", runtime: agent.adapter.id, cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+            previousSession: previousRef,
         });
         let fresh;
         try {
@@ -1557,6 +1602,7 @@ function createRuntimeHost(options) {
         const oldConfigSessionId = agent.config.sessionId;
         const oldReadiness = agent.readiness;
         const oldDisabledReason = agent.disabledReason;
+        const oldPreviousSession = agent.previousSession;
         const oldRecord = { ...record, input: { ...record.input } };
         let durableRollback = null;
         let rearmedCount = 1;
@@ -1572,6 +1618,7 @@ function createRuntimeHost(options) {
             agent.launchId = node_crypto_1.default.randomUUID();
             agent.config.sessionId = null;
             agent.session = fresh;
+            persistPreviousSession(agent, previousRef);
             agent.readiness = readiness;
             agent.disabledReason = null;
             for (const candidate of agent.records.values()) {
@@ -1606,6 +1653,7 @@ function createRuntimeHost(options) {
             agent.launchId = oldLaunchId;
             agent.config.sessionId = oldConfigSessionId;
             agent.session = oldSession;
+            persistPreviousSession(agent, oldPreviousSession);
             agent.readiness = oldReadiness;
             agent.disabledReason = oldDisabledReason;
             Object.assign(record, oldRecord);
@@ -1620,17 +1668,15 @@ function createRuntimeHost(options) {
             agent.config.sessionId = fresh.sessionId;
             emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                 ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
         }
         emit({ type: "agent-status", agentId, status: "active", readiness });
         agent.piSessionOwner = probeEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
         await oldSession.close("Pi context fallback committed").catch((error) => log("previous Pi session close after fallback failed", String(error)));
         reconcileAfterSessionSwap(agent);
         const proactive = proactivelyCompactPiAtIdle(agent, fresh);
-        void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-            if (outcome !== "failed")
-                return retryPending(agent);
-        });
+        void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
         return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
             runtimeReady: true, pendingCount: remainingPendingCount, rearmedCount,
             replayStatus: remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -1664,7 +1710,7 @@ function createRuntimeHost(options) {
             const standingPrompt = options.promptBuilder.build({
                 agentId: config.agentId, name: config.displayName || config.name,
                 description: config.description || "", runtime: adapter.id,
-                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"), previousSession: previous.previousSession,
             });
             const session = await adapter.createSession({
                 agentId: config.agentId, model: config.model, reasoningEffort: config.effort || null,
@@ -1770,10 +1816,11 @@ function createRuntimeHost(options) {
                 : { runtime: agent.adapter.id, state: "ready" };
             if (readiness.state !== "ready")
                 throw new runtime_readiness_js_1.RuntimePrerequisiteError(readiness);
+            const previousRef = previousSessionRefFor(oldSession, "operator reset");
             const standingPrompt = options.promptBuilder.build({
                 agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
                 description: agent.config.description || "", runtime: agent.adapter.id,
-                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"), previousSession: previousRef,
             });
             const create = agent.adapter.createSession({
                 agentId: agent.config.agentId, model: agent.config.model, reasoningEffort: agent.config.effort || null,
@@ -1802,6 +1849,7 @@ function createRuntimeHost(options) {
                 agent.launchId = node_crypto_1.default.randomUUID();
                 agent.config.sessionId = null;
                 agent.session = fresh;
+                persistPreviousSession(agent, previousRef);
                 agent.readiness = readiness;
                 agent.disabledReason = null;
             };
@@ -1820,7 +1868,8 @@ function createRuntimeHost(options) {
                 agent.config.sessionId = fresh.sessionId;
                 emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                     ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                    ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                    ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                    ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
             }
             emit({ type: "agent-status", agentId, status: "active", readiness });
             agent.piSessionOwner = probeEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
@@ -1880,10 +1929,12 @@ function createRuntimeHost(options) {
             }
             if (readiness.state !== "ready")
                 throw new runtime_readiness_js_1.RuntimePrerequisiteError(readiness);
+            const previousRef = previousSessionRefFor(oldSession, "context-window recovery");
+            const oldPreviousSession = agent.previousSession;
             const standingPrompt = options.promptBuilder.build({
                 agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
                 description: agent.config.description || "", runtime: agent.adapter.id,
-                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"), previousSession: previousRef,
             });
             let fresh;
             try {
@@ -1924,6 +1975,7 @@ function createRuntimeHost(options) {
                 agent.generation = oldGeneration;
                 agent.launchId = oldLaunchId;
                 agent.config.sessionId = oldConfigSessionId;
+                persistPreviousSession(agent, oldPreviousSession);
                 agent.readiness = oldReadiness;
                 agent.disabledReason = oldDisabledReason;
                 agent.records = new Map(oldRecords);
@@ -1956,6 +2008,7 @@ function createRuntimeHost(options) {
                     agent.launchId = node_crypto_1.default.randomUUID();
                     agent.config.sessionId = null;
                     agent.session = fresh;
+                    persistPreviousSession(agent, previousRef);
                     agent.readiness = readiness;
                     agent.disabledReason = null;
                     for (const record of agent.records.values()) {
@@ -1971,7 +2024,8 @@ function createRuntimeHost(options) {
                     agent.config.sessionId = fresh.sessionId;
                     emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                         ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                        ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                        ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                        ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
                 }
                 emit({ type: "agent-status", agentId, status: "active", readiness });
                 durableRollback = null;
@@ -1980,10 +2034,7 @@ function createRuntimeHost(options) {
                     .catch((error) => log("previous runtime close after context-window recovery failed", String(error)));
                 reconcileAfterSessionSwap(agent);
                 const proactive = proactivelyCompactPiAtIdle(agent, fresh);
-                void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-                    if (outcome !== "failed")
-                        return retryPending(agent);
-                });
+                void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
                 return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                     runtimeReady: true, pendingCount: rearmed.remainingPendingCount, rearmedCount: rearmed.rearmedCount,
                     replayStatus: rearmed.remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -2063,7 +2114,8 @@ function createRuntimeHost(options) {
                         }) : undefined,
                     compactionMachines: new Map(), compactionRecoveryInFlight: new Set(), piOverflowCompactionFailed: new Set(),
                     piProactiveCompaction: null, piProactiveCompactionGeneration: null, piProactiveCompactionSession: null,
-                    piProactiveCompactionFailedGeneration: null, readiness: null,
+                    piProactiveCompactionFailedGeneration: null,
+                    previousSession: loadPersistedPreviousSession(config, stateStore), readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false,
                     promotedInboxUpdateIds: new Set(),
                     backgroundCompletionQueue: [], backgroundCompletionKeys: new Set(),
@@ -2105,10 +2157,10 @@ function createRuntimeHost(options) {
                     await recoverStalePiCompaction(agent);
                     const startupSession = agent.session;
                     const proactive = startupSession ? proactivelyCompactPiAtIdle(agent, startupSession) : null;
-                    const proactiveOutcome = proactive ? await proactive : "noop";
+                    if (proactive)
+                        await proactive;
                     activeCount += 1;
-                    if (proactiveOutcome !== "failed")
-                        await retryPending(agent);
+                    await retryPending(agent);
                 }
                 catch (error) {
                     const reason = error instanceof Error ? error.message : String(error);

package/dist/runtime/runtime-host.mjs

@@ -36,6 +36,63 @@ const BACKGROUND_COMPLETION_IMMEDIATE_RETRY_LIMIT = 5;
 const DEFAULT_SUBAGENT_RECONCILE_INTERVAL_MS = 15_000;
 const now = () => new Date().toISOString();
 const isActiveDelivery = (status) => ["pending", "submitting", "accepted"].includes(status);
+const previousSessionRefFor = (session, reason) => session.sessionId
+    ? { sessionId: session.sessionId, file: session.sessionFile ?? null, closedAt: new Date().toISOString(), reason }
+    : null;
+function parsePreviousSessionRef(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.sessionId !== "string" || !record.sessionId)
+        return null;
+    if (typeof record.closedAt !== "string" || typeof record.reason !== "string")
+        return null;
+    return {
+        sessionId: record.sessionId,
+        file: typeof record.file === "string" && record.file ? record.file : null,
+        closedAt: record.closedAt,
+        reason: record.reason,
+    };
+}
+function loadPersistedPreviousSession(config, store) {
+    const fromConfig = parsePreviousSessionRef(config.previousSession);
+    if (fromConfig)
+        return fromConfig;
+    if (!store)
+        return null;
+    try {
+        const state = store.readJson("agentState", {});
+        return parsePreviousSessionRef(state.previousSessions?.[config.runtime]);
+    }
+    catch {
+        return null;
+    }
+}
+function persistPreviousSession(agent, previous) {
+    agent.previousSession = previous;
+    agent.config.previousSession = previous;
+    const store = agent.stateStore;
+    if (!store)
+        return;
+    try {
+        const current = store.readJson("agentState", { sessions: {} });
+        // Delivery-ledger mocks ignore the JSON key and would be clobbered by this write.
+        if (Array.isArray(current.records) && !("sessions" in current))
+            return;
+        const previousSessions = current.previousSessions && typeof current.previousSessions === "object"
+            && !Array.isArray(current.previousSessions)
+            ? { ...current.previousSessions }
+            : {};
+        if (previous)
+            previousSessions[agent.adapter.id] = previous;
+        else
+            delete previousSessions[agent.adapter.id];
+        store.writeJson("agentState", { ...current, previousSessions });
+    }
+    catch {
+        // In-memory ref still holds for this process; restart will miss it only if this write failed.
+    }
+}
 const REPLAY_FAILURE_CODES = new Set([
     "canonical_inbox_row_missing", "canonical_inbox_malformed", "duplicate_message_id",
     "inbox_state_conflict", "delivery_target_conflict", "structured_target_invalid",
@@ -457,17 +514,12 @@ export function createRuntimeHost(options) {
             && agent.piProactiveCompactionGeneration === agent.generation
             && agent.piProactiveCompactionSession === agent.session
             ? agent.piProactiveCompaction : null;
-        if (proactive && await proactive === "failed") {
-            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-        }
-        if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation) {
-            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-        }
+        if (proactive)
+            await proactive;
         if (agent.adapter.id === "pi" && !busy && !agent.busy && !agent.turnInProgress && agent.session) {
             const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-            if (idleGate && await idleGate === "failed") {
-                return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
-            }
+            if (idleGate)
+                await idleGate;
         }
         agent.submitting = true;
         if (!busy)
@@ -541,20 +593,18 @@ export function createRuntimeHost(options) {
                 && agent.piProactiveCompactionGeneration === agent.generation
                 && agent.piProactiveCompactionSession === agent.session
                 ? agent.piProactiveCompaction : null;
-            if (proactive && await proactive === "failed")
-                return;
+            if (proactive)
+                await proactive;
             if (agent.submitting || agent.starting) {
                 agent.retryAfterSubmit = true;
                 return;
             }
-            if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation)
-                return;
             if (agent.busy || agent.turnInProgress || !agent.session)
                 return;
             if (agent.adapter.id === "pi") {
                 const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-                if (idleGate && await idleGate === "failed")
-                    return;
+                if (idleGate)
+                    await idleGate;
             }
             const record = [...agent.records.values()].find((candidate) => candidate.status === "pending" || candidate.status === "submitting");
             if (record)
@@ -760,14 +810,12 @@ export function createRuntimeHost(options) {
             && agent.piProactiveCompactionGeneration === agent.generation
             && agent.piProactiveCompactionSession === agent.session
             ? agent.piProactiveCompaction : null;
-        if (proactive && await proactive === "failed")
-            return;
-        if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation)
-            return;
+        if (proactive)
+            await proactive;
         if (agent.adapter.id === "pi" && !agent.busy && !agent.turnInProgress && agent.session) {
             const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-            if (idleGate && await idleGate === "failed")
-                return;
+            if (idleGate)
+                await idleGate;
         }
         if (agent.stopped || agent.busy || agent.turnInProgress || agent.submitting)
             return;
@@ -949,8 +997,8 @@ export function createRuntimeHost(options) {
             void ensureSession(agent).then(async () => {
                 const session = agent.session;
                 const proactive = session ? proactivelyCompactPiAtIdle(agent, session) : null;
-                if (proactive && await proactive === "failed")
-                    return;
+                if (proactive)
+                    await proactive;
                 reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "pi session gone" });
                 enqueueUndeliveredTerminalWakes(agent);
                 await retryPending(agent);
@@ -1190,8 +1238,6 @@ export function createRuntimeHost(options) {
         })();
         const tracked = task.catch((error) => {
             agent.piProactiveCompactionFailedGeneration = generation;
-            emit({ type: "agent-status", agentId: agent.config.agentId, status: "error",
-                error: "Pi proactive compaction failed; the current session generation is degraded" });
             log("Pi proactive compaction failed", String(error));
             return "failed";
         }).finally(() => {
@@ -1325,10 +1371,7 @@ export function createRuntimeHost(options) {
                 emit({ type: "agent-status", agentId: agent.config.agentId, status: "active", readiness: agent.readiness });
             }
             const proactive = proactivelyCompactPiAtIdle(agent, session);
-            void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-                if (outcome !== "failed")
-                    return retryPending(agent);
-            });
+            void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
             queueMicrotask(() => { void scanAndPromoteAcceptedInboxUpdates(agent); });
         }
         else if (event.type === "runtime-observation") {
@@ -1457,7 +1500,7 @@ export function createRuntimeHost(options) {
         const standingPrompt = options.promptBuilder.build({
             agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
             description: agent.config.description || "", runtime: agent.adapter.id,
-            cli: agentCliPromptCapabilities("larkin"),
+            cli: agentCliPromptCapabilities("larkin"), previousSession: agent.previousSession,
         });
         const generation = ++agent.generation;
         let completedSession = null;
@@ -1517,9 +1560,11 @@ export function createRuntimeHost(options) {
             workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir, env: probeEnv }) : { runtime: "pi", state: "ready" };
         if (readiness.state !== "ready")
             throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Pi context fallback readiness failed");
+        const previousRef = previousSessionRefFor(oldSession, "context-window overflow");
         const standingPrompt = options.promptBuilder.build({
             agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
             description: agent.config.description || "", runtime: agent.adapter.id, cli: agentCliPromptCapabilities("larkin"),
+            previousSession: previousRef,
         });
         let fresh;
         try {
@@ -1548,6 +1593,7 @@ export function createRuntimeHost(options) {
         const oldConfigSessionId = agent.config.sessionId;
         const oldReadiness = agent.readiness;
         const oldDisabledReason = agent.disabledReason;
+        const oldPreviousSession = agent.previousSession;
         const oldRecord = { ...record, input: { ...record.input } };
         let durableRollback = null;
         let rearmedCount = 1;
@@ -1563,6 +1609,7 @@ export function createRuntimeHost(options) {
             agent.launchId = crypto.randomUUID();
             agent.config.sessionId = null;
             agent.session = fresh;
+            persistPreviousSession(agent, previousRef);
             agent.readiness = readiness;
             agent.disabledReason = null;
             for (const candidate of agent.records.values()) {
@@ -1597,6 +1644,7 @@ export function createRuntimeHost(options) {
             agent.launchId = oldLaunchId;
             agent.config.sessionId = oldConfigSessionId;
             agent.session = oldSession;
+            persistPreviousSession(agent, oldPreviousSession);
             agent.readiness = oldReadiness;
             agent.disabledReason = oldDisabledReason;
             Object.assign(record, oldRecord);
@@ -1611,17 +1659,15 @@ export function createRuntimeHost(options) {
             agent.config.sessionId = fresh.sessionId;
             emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                 ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
         }
         emit({ type: "agent-status", agentId, status: "active", readiness });
         agent.piSessionOwner = probeEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
         await oldSession.close("Pi context fallback committed").catch((error) => log("previous Pi session close after fallback failed", String(error)));
         reconcileAfterSessionSwap(agent);
         const proactive = proactivelyCompactPiAtIdle(agent, fresh);
-        void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-            if (outcome !== "failed")
-                return retryPending(agent);
-        });
+        void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
         return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
             runtimeReady: true, pendingCount: remainingPendingCount, rearmedCount,
             replayStatus: remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -1655,7 +1701,7 @@ export function createRuntimeHost(options) {
             const standingPrompt = options.promptBuilder.build({
                 agentId: config.agentId, name: config.displayName || config.name,
                 description: config.description || "", runtime: adapter.id,
-                cli: agentCliPromptCapabilities("larkin"),
+                cli: agentCliPromptCapabilities("larkin"), previousSession: previous.previousSession,
             });
             const session = await adapter.createSession({
                 agentId: config.agentId, model: config.model, reasoningEffort: config.effort || null,
@@ -1761,10 +1807,11 @@ export function createRuntimeHost(options) {
                 : { runtime: agent.adapter.id, state: "ready" };
             if (readiness.state !== "ready")
                 throw new RuntimePrerequisiteError(readiness);
+            const previousRef = previousSessionRefFor(oldSession, "operator reset");
             const standingPrompt = options.promptBuilder.build({
                 agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
                 description: agent.config.description || "", runtime: agent.adapter.id,
-                cli: agentCliPromptCapabilities("larkin"),
+                cli: agentCliPromptCapabilities("larkin"), previousSession: previousRef,
             });
             const create = agent.adapter.createSession({
                 agentId: agent.config.agentId, model: agent.config.model, reasoningEffort: agent.config.effort || null,
@@ -1793,6 +1840,7 @@ export function createRuntimeHost(options) {
                 agent.launchId = crypto.randomUUID();
                 agent.config.sessionId = null;
                 agent.session = fresh;
+                persistPreviousSession(agent, previousRef);
                 agent.readiness = readiness;
                 agent.disabledReason = null;
             };
@@ -1811,7 +1859,8 @@ export function createRuntimeHost(options) {
                 agent.config.sessionId = fresh.sessionId;
                 emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                     ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                    ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                    ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                    ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
             }
             emit({ type: "agent-status", agentId, status: "active", readiness });
             agent.piSessionOwner = probeEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
@@ -1871,10 +1920,12 @@ export function createRuntimeHost(options) {
             }
             if (readiness.state !== "ready")
                 throw new RuntimePrerequisiteError(readiness);
+            const previousRef = previousSessionRefFor(oldSession, "context-window recovery");
+            const oldPreviousSession = agent.previousSession;
             const standingPrompt = options.promptBuilder.build({
                 agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
                 description: agent.config.description || "", runtime: agent.adapter.id,
-                cli: agentCliPromptCapabilities("larkin"),
+                cli: agentCliPromptCapabilities("larkin"), previousSession: previousRef,
             });
             let fresh;
             try {
@@ -1915,6 +1966,7 @@ export function createRuntimeHost(options) {
                 agent.generation = oldGeneration;
                 agent.launchId = oldLaunchId;
                 agent.config.sessionId = oldConfigSessionId;
+                persistPreviousSession(agent, oldPreviousSession);
                 agent.readiness = oldReadiness;
                 agent.disabledReason = oldDisabledReason;
                 agent.records = new Map(oldRecords);
@@ -1947,6 +1999,7 @@ export function createRuntimeHost(options) {
                     agent.launchId = crypto.randomUUID();
                     agent.config.sessionId = null;
                     agent.session = fresh;
+                    persistPreviousSession(agent, previousRef);
                     agent.readiness = readiness;
                     agent.disabledReason = null;
                     for (const record of agent.records.values()) {
@@ -1962,7 +2015,8 @@ export function createRuntimeHost(options) {
                     agent.config.sessionId = fresh.sessionId;
                     emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
                         ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
-                        ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                        ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}),
+                        ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
                 }
                 emit({ type: "agent-status", agentId, status: "active", readiness });
                 durableRollback = null;
@@ -1971,10 +2025,7 @@ export function createRuntimeHost(options) {
                     .catch((error) => log("previous runtime close after context-window recovery failed", String(error)));
                 reconcileAfterSessionSwap(agent);
                 const proactive = proactivelyCompactPiAtIdle(agent, fresh);
-                void (proactive ?? Promise.resolve("noop")).then((outcome) => {
-                    if (outcome !== "failed")
-                        return retryPending(agent);
-                });
+                void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
                 return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                     runtimeReady: true, pendingCount: rearmed.remainingPendingCount, rearmedCount: rearmed.rearmedCount,
                     replayStatus: rearmed.remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -2054,7 +2105,8 @@ export function createRuntimeHost(options) {
                         }) : undefined,
                     compactionMachines: new Map(), compactionRecoveryInFlight: new Set(), piOverflowCompactionFailed: new Set(),
                     piProactiveCompaction: null, piProactiveCompactionGeneration: null, piProactiveCompactionSession: null,
-                    piProactiveCompactionFailedGeneration: null, readiness: null,
+                    piProactiveCompactionFailedGeneration: null,
+                    previousSession: loadPersistedPreviousSession(config, stateStore), readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false,
                     promotedInboxUpdateIds: new Set(),
                     backgroundCompletionQueue: [], backgroundCompletionKeys: new Set(),
@@ -2096,10 +2148,10 @@ export function createRuntimeHost(options) {
                     await recoverStalePiCompaction(agent);
                     const startupSession = agent.session;
                     const proactive = startupSession ? proactivelyCompactPiAtIdle(agent, startupSession) : null;
-                    const proactiveOutcome = proactive ? await proactive : "noop";
+                    if (proactive)
+                        await proactive;
                     activeCount += 1;
-                    if (proactiveOutcome !== "failed")
-                        await retryPending(agent);
+                    await retryPending(agent);
                 }
                 catch (error) {
                     const reason = error instanceof Error ? error.message : String(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkin",
-  "version": "0.4.24",
+  "version": "0.4.25",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [