larkin 0.4.24 → 0.4.26

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.26",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [