newmark-agent 0.3.8 → 0.3.10

package/dist/core/agent.js

@@ -66,6 +66,8 @@ const agent_context_manager_1 = require("../context/services/agent-context-manag
 const toolchain_1 = require("../toolchain");
 const agent_runtime_1 = require("../agent-runtime");
 const performanceDiagnostics_1 = require("./performanceDiagnostics");
+const compressionHistoryArchive_1 = require("./compressionHistoryArchive");
+const runtimeLifecycle_1 = require("./runtimeLifecycle");
 exports.ROOT_AGENT_ACTOR_ID = '00000000-0000-4000-8000-000000000001';
 function normalizeIntelligenceTier(value) {
     const tier = String(value || '').trim().toLowerCase();
@@ -193,6 +195,7 @@ class Agent {
     lastCompression = null;
     compressionCache = [];
     nextCompressionCacheId = 1;
+    compressionHistoryArchive;
     workspaceConversations = new Map();
     isSubagentRuntime = false;
     subagentName = '';
@@ -256,8 +259,10 @@ class Agent {
     rootInboxListener = (message) => this.deliverRootInboxMessage(message);
     agentOnly;
     runtimeActorId;
+    runtimeLifecycleRole;
     /** dev-0.3.0 context system facade (feature-flagged, default off). */
     contextV2;
+    runtimeLifecycle;
     /** dev-0.3.0 toolchain core (registry + capability catalog). Seeded lazily from cachedToolDefinitions; not consumed by the legacy path. */
     toolchainCore = null;
     /**
@@ -277,15 +282,18 @@ class Agent {
     }
     constructor(rootPath, options = {}) {
         this.rootPath = rootPath;
+        this.runtimeLifecycle = (0, runtimeLifecycle_1.beginRuntimeLifecycle)(rootPath, options.runtimeLifecycleRole || 'main');
         this.isSubagentRuntime = !!options.subagent;
         this.agentOnly = !!options.agentOnly;
         this.runtimeActorId = options.actorId || exports.ROOT_AGENT_ACTOR_ID;
+        this.runtimeLifecycleRole = options.runtimeLifecycleRole || 'main';
         if (options.conversationId)
             this.activeConversationId = this.safeConversationId(options.conversationId);
         this.subagentName = options.subagentName || '';
         this.subagentPrompt = options.subagentPrompt || '';
         this.linkedPlanAccess = options.linkedPlanAccess;
         this.config = new config_1.ConfigManager(rootPath);
+        this.compressionHistoryArchive = new compressionHistoryArchive_1.CompressionHistoryArchive(rootPath);
         this.contextV2 = new agent_context_manager_1.AgentContextManager(rootPath, this.config);
         this.agentRunService = this.config.contextFlag('agent_runtime_v2')
             ? new agent_runtime_1.AgentRunService(path.join(rootPath, '.newmark-context-v2'))
@@ -1464,6 +1472,11 @@ class Agent {
                 runId,
                 target,
                 runtimeKey: String(raw.runtimeKey || (0, conversationTarget_1.conversationRuntimeKey)(target)),
+                runtimeOwnerId: String(raw.runtimeOwnerId || '') || undefined,
+                runtimeOwnerPid: Number.isFinite(Number(raw.runtimeOwnerPid)) && Number(raw.runtimeOwnerPid) > 0
+                    ? Math.floor(Number(raw.runtimeOwnerPid)) : undefined,
+                runtimeLifecycleRole: ['main', 'utility', 'wsl'].includes(String(raw.runtimeLifecycleRole || ''))
+                    ? String(raw.runtimeLifecycleRole) : undefined,
                 status,
                 startedAt: raw.startedAt || this.nowIso(),
                 endedAt: raw.endedAt,
@@ -1529,27 +1542,76 @@ class Agent {
         const sorted = [...byRun.values()].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
         return sorted.length > RUN_WINDOW ? sorted.slice(-RUN_WINDOW) : sorted;
     }
-    recoverPersistedWorkRuns(runs, persistedUpdatedAt) {
+    recoverPersistedWorkRuns(runs, persistedUpdatedAt, unexpectedExit = false) {
         const normalized = this.normalizeWorkRuns(runs);
         let changed = false;
-        // Only convert 'running' to 'interrupted' when the persisted state is
-        // stale enough to indicate a cold start. If the state was persisted
-        // recently the conversation may still be running in a background kernel
-        // runtime, so preserve the running status for the UI.
+        // A frontend tracking window can expire while the backend process keeps
+        // running. Owner PID evidence is stronger than the persistence timestamp:
+        // never rewrite a live backend run merely because a cold snapshot is old.
         const isRecentPersist = !!persistedUpdatedAt
             && (Date.now() - new Date(persistedUpdatedAt).getTime()) < 120_000;
-        if (isRecentPersist)
-            return { runs: normalized, changed: false };
+        let preservedLiveRun = false;
         for (const run of normalized) {
             if (run.status !== 'running')
                 continue;
+            const ownerAlive = !!run.runtimeOwnerPid && (0, runtimeLifecycle_1.isRuntimeProcessAlive)(run.runtimeOwnerPid);
+            if (!unexpectedExit && (ownerAlive || (!run.runtimeOwnerPid && this.runtimeLifecycle.previousOwnerAlive))) {
+                preservedLiveRun = true;
+                continue;
+            }
+            if (!unexpectedExit && isRecentPersist) {
+                preservedLiveRun = true;
+                continue;
+            }
             run.status = 'interrupted';
-            run.endedAt = persistedUpdatedAt || run.startedAt || this.nowIso();
+            run.endedAt = unexpectedExit ? this.nowIso() : (persistedUpdatedAt || run.startedAt || this.nowIso());
             run.expanded = true;
+            const sequence = Math.max(0, Number(run.sequence || 0)) + 1;
+            run.sequence = sequence;
+            run.events.push({
+                id: `${run.runId}-unexpected-exit-${sequence}`,
+                conversationId: run.target.conversationId,
+                type: 'status',
+                content: unexpectedExit
+                    ? 'Runtime exited unexpectedly; this Build was paused for recovery.'
+                    : 'Persisted running Build was recovered as interrupted.',
+                mode: 'build',
+                model: this.model,
+                timestamp: run.endedAt,
+                workspaceId: run.target.workspaceId,
+                runtimeKey: run.runtimeKey,
+                runId: run.runId,
+                sequence,
+                status: 'interrupted',
+            });
             changed = true;
         }
+        if (preservedLiveRun && !changed)
+            return { runs: normalized, changed: false };
         return { runs: normalized, changed };
     }
+    pauseFlowAfterUnexpectedExit() {
+        if (this.mode !== 'flow' || !this.flow?.name)
+            return false;
+        if (this.getStoredFlowSuspension(this.activeConversationId)) {
+            this.status = 'idle';
+            return true;
+        }
+        const target = this.currentConversationTarget();
+        this.saveStoredFlowSuspension({
+            workflowName: this.flow.name,
+            componentId: Math.max(0, Math.floor(Number(this.flowPc) || 0)),
+            input: String([...this.chatMessages].reverse().find(message => message.role === 'user')?.content || ''),
+            completedResults: [],
+            previousMode: 'build',
+            reason: 'interrupted',
+            message: 'Flow paused after an unexpected runtime exit. Resume it explicitly.',
+            target,
+            updatedAt: this.nowIso(),
+        }, this.activeConversationId);
+        this.status = 'idle';
+        return true;
+    }
     beginConversationWorkRun(runId, target = this.currentConversationTarget(), startedAt = this.nowIso(), managed = false, runtimeKey) {
         const cleanRunId = String(runId || crypto.randomUUID()).trim().slice(0, 200);
         const existing = this.workRuns.find(run => run.runId === cleanRunId);
@@ -1567,6 +1629,9 @@ class Agent {
             runId: cleanRunId,
             target: normalizedTarget,
             runtimeKey: String(runtimeKey || (0, conversationTarget_1.conversationRuntimeKey)(normalizedTarget)),
+            runtimeOwnerId: this.runtimeLifecycle.ownerId,
+            runtimeOwnerPid: this.runtimeLifecycle.pid,
+            runtimeLifecycleRole: this.runtimeLifecycleRole,
             status: 'running',
             startedAt,
             expanded: true,
@@ -1581,10 +1646,186 @@ class Agent {
         if (managed)
             this.managedWorkRunIds.add(run.runId);
         this.activeWorkRunId = run.runId;
+        this.ensureBuildHistoryBlock(run);
         if (this.agentRunService)
             this.createAgentRunForWorkRun(run, normalizedTarget);
         return run;
     }
+    buildHistoryStatus(status) {
+        if (status === 'completed')
+            return 'completed';
+        if (status === 'error')
+            return 'failed';
+        if (status === 'force_interrupted')
+            return 'cancelled';
+        return 'paused';
+    }
+    ensureBuildHistoryBlock(run) {
+        if (!this.contextV2.flags.buildHistoryPersistence)
+            return null;
+        try {
+            const repository = this.contextV2.buildHistory;
+            const existing = repository.readBlock(run.runId);
+            if (existing)
+                return existing;
+            const block = {
+                id: run.runId,
+                conversationId: run.target.conversationId,
+                branchId: run.branchNodeId || `conversation:${run.target.conversationId}`,
+                parentBuildBlockId: null,
+                startupInput: this.sanitizePublicWorkContent(run.primaryPrompt || '(user input unavailable)').slice(0, 50_000),
+                status: 'active',
+                createdAt: run.startedAt,
+                startedAt: run.startedAt,
+                completedAt: null,
+                revision: 1,
+                activeCheckpointId: null,
+                tokenBudgetPolicyId: 'default',
+                metadata: {
+                    runtimeKey: run.runtimeKey,
+                    conversationWorkRunId: run.runId,
+                },
+            };
+            repository.saveBlock(block);
+            return block;
+        }
+        catch (error) {
+            console.error(`[NewmarkBuildHistory] unable to create Build Block ${run.runId}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    finalWorkRunSummary(run) {
+        const finalEvent = [...run.events].reverse().find(event => event.type === 'final_response' || event.type === 'response');
+        if (finalEvent?.content)
+            return this.sanitizePublicWorkContent(finalEvent.content).slice(0, 4_000);
+        const finalMessage = [...this.chatMessages].reverse().find(message => message.role === 'assistant' && message.runId === run.runId);
+        return this.sanitizePublicWorkContent(finalMessage?.content || '(no final summary)').slice(0, 4_000);
+    }
+    auditGoalAtWorkRunEnd(run, status, endedAt) {
+        if (!this.goal)
+            return { tracked: false, checked: false, matched: false, completed: false, checkedAt: endedAt };
+        const objective = this.goal.objective;
+        const pausedBeforeSync = this.goal.paused;
+        const matched = this.goal.checkComplete(this.finalWorkRunSummary(run));
+        const completed = status === 'completed' && matched && !pausedBeforeSync;
+        if (completed)
+            this.markGoalComplete();
+        return {
+            tracked: true,
+            checked: true,
+            matched,
+            completed,
+            objective,
+            paused: completed ? false : pausedBeforeSync,
+            checkedAt: endedAt,
+        };
+    }
+    enforceGoalTerminalInvariant(status, goalAudit) {
+        if (!this.goal)
+            return;
+        const continuationIsOwned = status === 'completed' && !goalAudit.completed && !!this.goalContinuationGate;
+        if (continuationIsOwned)
+            return;
+        if (!this.goal.paused) {
+            this.goal.paused = true;
+            this.status = 'goal_paused';
+            this.saveWorkspaceConversationState(true);
+        }
+        goalAudit.paused = this.goal.paused;
+    }
+    persistBuildBlockWorkOverview(run, status, endedAt, goalAudit) {
+        if (!this.contextV2.flags.buildHistoryPersistence)
+            return;
+        try {
+            const repository = this.contextV2.buildHistory;
+            let block = this.ensureBuildHistoryBlock(run);
+            if (!block)
+                return;
+            const nextStatus = this.buildHistoryStatus(status);
+            const nextCompletedAt = nextStatus === 'active' ? null : endedAt;
+            const startupInput = this.sanitizePublicWorkContent(run.primaryPrompt || block.startupInput || '(user input unavailable)').slice(0, 50_000);
+            if (block.status !== nextStatus || block.completedAt !== nextCompletedAt || block.startupInput !== startupInput) {
+                const transitioned = repository.transitionBlock(block, {
+                    startupInput,
+                    status: nextStatus,
+                    completedAt: nextCompletedAt,
+                    metadata: {
+                        ...block.metadata,
+                        terminalWorkRunStatus: status,
+                        terminalAt: endedAt,
+                    },
+                }, {
+                    expectedRevision: block.revision,
+                    operationId: `work-run-terminal:${run.runId}:${status}:${endedAt}`,
+                });
+                block = transitioned.applied ? transitioned.block : (repository.readBlock(run.runId) || block);
+            }
+            const eventCounts = run.events.reduce((counts, event) => {
+                counts[event.type] = (counts[event.type] || 0) + 1;
+                return counts;
+            }, {});
+            const guides = run.guides.slice(-8).map(guide => `${guide.status}: ${this.sanitizePublicWorkContent(String(guide.content || '')).slice(0, 500)}`);
+            const finalSummary = this.finalWorkRunSummary(run);
+            const goalLine = goalAudit.tracked
+                ? `Goal: checked=${goalAudit.checked}; matched=${goalAudit.matched}; completed=${goalAudit.completed}; paused=${goalAudit.paused}; objective=${goalAudit.objective}`
+                : 'Goal: not tracked for this Build Block.';
+            const content = [
+                'Build Block Work Overview',
+                `Run: ${run.runId}`,
+                `Status: ${status}`,
+                `Conversation: ${run.target.conversationId}`,
+                `Startup input: ${this.sanitizePublicWorkContent(run.primaryPrompt || block.startupInput || '(user input unavailable)').slice(0, 2_000)}`,
+                `Final summary: ${finalSummary}`,
+                `Events: ${JSON.stringify(eventCounts)}`,
+                guides.length ? `Guides: ${guides.join(' | ')}` : 'Guides: none',
+                goalLine,
+            ].join('\n');
+            repository.appendEntry({
+                buildBlockId: run.runId,
+                type: 'work_overview',
+                content: content.slice(0, 50_000),
+                source: 'agent',
+                importance: status === 'completed' ? 'normal' : 'high',
+                structuredData: {
+                    conversationId: run.target.conversationId,
+                    branchId: block.branchId,
+                    status,
+                    endedAt,
+                    finalSummary,
+                    eventCounts,
+                    guideCount: run.guides.length,
+                    goal: goalAudit,
+                },
+                operationId: `work-run-overview:${run.runId}`,
+                revision: block.revision,
+            });
+        }
+        catch (error) {
+            console.error(`[NewmarkBuildHistory] unable to write Build Block overview ${run.runId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    recoverMissingTerminalBuildOverviews() {
+        if (!this.contextV2.flags.buildHistoryPersistence)
+            return;
+        const repository = this.contextV2.buildHistory;
+        for (const run of this.workRuns) {
+            if (run.status === 'running')
+                continue;
+            try {
+                if (repository.readEntries(run.runId).some(entry => entry.type === 'work_overview'))
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const endedAt = run.endedAt || this.nowIso();
+            if (run.status === 'completed')
+                this.ensureCompletedWorkRunFinalResult(run);
+            const goalAudit = this.auditGoalAtWorkRunEnd(run, run.status, endedAt);
+            this.enforceGoalTerminalInvariant(run.status, goalAudit);
+            this.persistBuildBlockWorkOverview(run, run.status, endedAt, goalAudit);
+        }
+    }
     createAgentRunForWorkRun(run, target) {
         if (!this.agentRunService)
             return;
@@ -1827,10 +2068,22 @@ class Agent {
             return false;
         this.syncAgentRunTerminal(run.runId, status, endedAt);
         if (run.status !== 'running') {
-            if (run.status !== 'interrupted' || status !== 'force_interrupted')
-                return run.status === status;
+            if (run.status !== 'interrupted' || status !== 'force_interrupted') {
+                if (run.status !== status)
+                    return false;
+                const terminalAt = run.endedAt || endedAt;
+                if (status === 'completed')
+                    this.ensureCompletedWorkRunFinalResult(run);
+                const goalAudit = this.auditGoalAtWorkRunEnd(run, status, terminalAt);
+                this.enforceGoalTerminalInvariant(status, goalAudit);
+                this.persistBuildBlockWorkOverview(run, status, terminalAt, goalAudit);
+                this.saveWorkspaceConversationState();
+                return true;
+            }
             this.activeWorkRunId = run.runId;
             this.finalizingWorkRunId = run.runId;
+            const goalAudit = this.auditGoalAtWorkRunEnd(run, status, endedAt);
+            this.enforceGoalTerminalInvariant(status, goalAudit);
             this.emitWorkEvent({
                 type: 'status',
                 content: 'Force interrupted.',
@@ -1845,6 +2098,7 @@ class Agent {
             this.activeWorkRunId = '';
             this.finalizingWorkRunId = '';
             this.managedWorkRunIds.delete(run.runId);
+            this.persistBuildBlockWorkOverview(run, status, endedAt, goalAudit);
             this.saveWorkspaceConversationState();
             return true;
         }
@@ -1852,6 +2106,8 @@ class Agent {
         this.finalizingWorkRunId = run.runId;
         if (status === 'completed')
             this.ensureCompletedWorkRunFinalResult(run);
+        const goalAudit = this.auditGoalAtWorkRunEnd(run, status, endedAt);
+        this.enforceGoalTerminalInvariant(status, goalAudit);
         this.emitWorkEvent({
             type: status === 'completed' ? 'done' : status === 'error' ? 'error' : 'status',
             content: status === 'force_interrupted' ? 'Force interrupted.' : status === 'interrupted' ? 'Interrupted.' : 'Response complete.',
@@ -1866,6 +2122,7 @@ class Agent {
         this.activeWorkRunId = '';
         this.finalizingWorkRunId = '';
         this.managedWorkRunIds.delete(run.runId);
+        this.persistBuildBlockWorkOverview(run, status, endedAt, goalAudit);
         this.saveWorkspaceConversationState();
         return true;
     }
@@ -1972,6 +2229,14 @@ class Agent {
             this.saveWorkspaceConversationState(false);
         if (event.type === 'done' || event.type === 'error')
             this.saveWorkspaceConversationState(true);
+        if (activeRun && this.finalizingWorkRunId !== activeRun.runId
+            && (event.type === 'done' || event.type === 'error') && activeRun.status !== 'running') {
+            const terminalStatus = activeRun.status;
+            const terminalAt = activeRun.endedAt || this.nowIso();
+            const goalAudit = this.auditGoalAtWorkRunEnd(activeRun, terminalStatus, terminalAt);
+            this.enforceGoalTerminalInvariant(terminalStatus, goalAudit);
+            this.persistBuildBlockWorkOverview(activeRun, terminalStatus, terminalAt, goalAudit);
+        }
         return event;
     }
     appendWorkflowMessage(content, toolName, toolArgs, persist = true) {
@@ -3101,6 +3366,17 @@ class Agent {
         }
         return cleaned;
     }
+    activeConversationRuntimeOwner() {
+        const activeGoal = !!this.goal && !this.goal.paused;
+        const activeFlow = this.mode === 'flow' && !!this.flow?.name && !this.getStoredFlowSuspension(this.activeConversationId);
+        if (!activeGoal && !activeFlow)
+            return {};
+        return {
+            runtimeOwnerId: this.runtimeLifecycle.ownerId,
+            runtimeOwnerPid: this.runtimeLifecycle.pid,
+            runtimeLifecycleRole: this.runtimeLifecycleRole,
+        };
+    }
     saveWorkspaceConversationState(flush = true) {
         if (this.isSubagentRuntime)
             return;
@@ -3108,6 +3384,7 @@ class Agent {
         if (!key)
             return;
         const updatedAt = new Date().toISOString();
+        const runtimeOwner = this.activeConversationRuntimeOwner();
         this.workspaceConversations.set(key, {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
@@ -3122,6 +3399,9 @@ class Agent {
             inputMode: this.inputMode,
             mode: this.mode,
             goal: this.serializeGoal(),
+            runtimeOwnerId: runtimeOwner.runtimeOwnerId,
+            runtimeOwnerPid: runtimeOwner.runtimeOwnerPid,
+            runtimeLifecycleRole: runtimeOwner.runtimeLifecycleRole,
             updatedAt,
         });
         const stored = this.readStoredConversationState();
@@ -3152,6 +3432,9 @@ class Agent {
             inputMode: this.inputMode,
             mode: this.mode,
             goal: this.serializeGoal(),
+            runtimeOwnerId: runtimeOwner.runtimeOwnerId,
+            runtimeOwnerPid: runtimeOwner.runtimeOwnerPid,
+            runtimeLifecycleRole: runtimeOwner.runtimeLifecycleRole,
             updatedAt,
         };
         if (nextEntry.tree || nextEntry.branches?.length) {
@@ -3203,6 +3486,7 @@ class Agent {
             this.mode = saved.mode || 'build';
             this.goal = this.restoreGoal(saved.goal);
             this.status = this.restoreStatusFromWorkRuns(saved.goal);
+            this.recoverMissingTerminalBuildOverviews();
             this.activeWorkRunId = this.workRuns.find(run => run.status === 'running')?.runId || '';
             return;
         }
@@ -3215,7 +3499,7 @@ class Agent {
         this.chatMessages = this.normalizeConversationChatMessages(persisted?.chatMessages || [], this.history);
         this.conversationPlan = this.normalizeConversationPlan(persisted?.plan);
         this.linkedPlan = this.normalizeLinkedPlan(persisted?.linkedPlan);
-        const recoveredWorkRuns = this.recoverPersistedWorkRuns(persisted?.workRuns, persisted?.updatedAt);
+        const recoveredWorkRuns = this.recoverPersistedWorkRuns(persisted?.workRuns, persisted?.updatedAt, this.runtimeLifecycle.unexpectedExit);
         this.workRuns = recoveredWorkRuns.runs;
         this.continuations = this.normalizeContinuations(persisted?.continuations);
         this.restoreConversationModelSelection(persisted?.modelSelection);
@@ -3223,9 +3507,29 @@ class Agent {
         this.inputMode = this.defaultInputMode();
         this.mode = persisted?.mode || 'build';
         this.goal = this.restoreGoal(persisted?.goal);
-        this.status = this.restoreStatusFromWorkRuns(persisted?.goal);
+        const persistedRuntimeOwnerPid = Math.floor(Number(persisted?.runtimeOwnerPid) || 0);
+        const persistedRuntimeOwnerKnown = persistedRuntimeOwnerPid > 0;
+        const persistedRuntimeOwnerAlive = persistedRuntimeOwnerKnown && (0, runtimeLifecycle_1.isRuntimeProcessAlive)(persistedRuntimeOwnerPid);
+        const runtimeOwnerLost = persistedRuntimeOwnerKnown ? !persistedRuntimeOwnerAlive : this.runtimeLifecycle.unexpectedExit;
+        const shouldPauseRecoveredState = recoveredWorkRuns.changed || runtimeOwnerLost;
+        let goalPausedByRecovery = false;
+        if (shouldPauseRecoveredState && this.goal && !this.goal.paused) {
+            this.goal.paused = true;
+            goalPausedByRecovery = true;
+        }
+        this.status = this.restoreStatusFromWorkRuns(this.serializeGoal());
+        const flowPausedByRecovery = shouldPauseRecoveredState && this.pauseFlowAfterUnexpectedExit();
         this.activeWorkRunId = this.workRuns.find(run => run.status === 'running')?.runId || '';
         this.bindConversationSubagents(this.activeConversationId, persisted?.subagentState);
+        if (recoveredWorkRuns.changed) {
+            for (const run of recoveredWorkRuns.runs.filter(item => item.status === 'interrupted')) {
+                const audit = this.auditGoalAtWorkRunEnd(run, 'interrupted', run.endedAt || this.nowIso());
+                this.persistBuildBlockWorkOverview(run, 'interrupted', run.endedAt || this.nowIso(), audit);
+            }
+        }
+        this.recoverMissingTerminalBuildOverviews();
+        const recoveryApplied = recoveredWorkRuns.changed || runtimeOwnerLost || goalPausedByRecovery || flowPausedByRecovery;
+        const recoveryAt = recoveryApplied ? this.nowIso() : persisted?.updatedAt;
         this.workspaceConversations.set(key, {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
@@ -3236,21 +3540,31 @@ class Agent {
             workRuns: this.normalizeWorkRuns(this.workRuns),
             continuations: this.normalizeContinuations(this.continuations),
             modelSelection: persisted?.modelSelection || this.currentConversationModelSelection(),
-            flowSelection: persisted?.flowSelection || null,
+            flowSelection: this.currentConversationFlowSelection(),
             inputMode: this.defaultInputMode(),
-            mode: persisted?.mode || 'build',
-            goal: persisted?.goal || null,
-            updatedAt: persisted?.updatedAt,
+            mode: this.mode,
+            goal: this.serializeGoal(),
+            runtimeOwnerId: this.activeConversationRuntimeOwner().runtimeOwnerId,
+            runtimeOwnerPid: this.activeConversationRuntimeOwner().runtimeOwnerPid,
+            runtimeLifecycleRole: this.activeConversationRuntimeOwner().runtimeLifecycleRole,
+            updatedAt: recoveryAt,
         });
-        if (recoveredWorkRuns.changed && stateKey && persisted) {
-            const recoveredAt = this.nowIso();
-            stored.conversations[stateKey] = {
-                ...persisted,
+        if (recoveryApplied && stateKey && persisted) {
+            const recoveredStored = this.readStoredConversationState();
+            recoveredStored.conversations = recoveredStored.conversations || {};
+            recoveredStored.conversations[stateKey] = {
+                ...(recoveredStored.conversations[stateKey] || persisted),
                 workRuns: this.normalizeWorkRuns(this.workRuns),
-                updatedAt: recoveredAt,
+                flowSelection: this.currentConversationFlowSelection(),
+                mode: this.mode,
+                goal: this.serializeGoal(),
+                runtimeOwnerId: this.activeConversationRuntimeOwner().runtimeOwnerId,
+                runtimeOwnerPid: this.activeConversationRuntimeOwner().runtimeOwnerPid,
+                runtimeLifecycleRole: this.activeConversationRuntimeOwner().runtimeLifecycleRole,
+                updatedAt: recoveryAt,
             };
-            this.workspaceConversations.get(key).updatedAt = recoveredAt;
-            this.writeStoredConversationStateNow(stored);
+            this.workspaceConversations.get(key).updatedAt = recoveryAt;
+            this.writeStoredConversationStateNow(recoveredStored);
         }
     }
     applyWorkspaceContext(ws) {
@@ -3477,7 +3791,7 @@ class Agent {
         catch { }
         const action = String(input.action || '').trim();
         if (!action)
-            return { ok: false, output: '[context_history_manage] action is required (list|remove|summarize|restore|search|status).', error: 'action is required.' };
+            return { ok: false, output: '[context_history_manage] action is required (list|remove|summarize|restore|search|read|status).', error: 'action is required.' };
         if (action === 'list') {
             const limit = Math.max(5, Math.min(400, Math.floor(Number(input.limit || 200))));
             const entries = this.history.slice(0, limit).map((message, index) => ({
@@ -3569,7 +3883,9 @@ class Agent {
         }
         if (action === 'restore') {
             const restoreId = String(input.restore_id || '').trim();
-            const entry = this.compressionCache.find(item => item.id === restoreId);
+            const hotEntry = this.compressionCache.find(item => item.id === restoreId);
+            const coldEntry = hotEntry ? undefined : this.coldCompressionEntries().find(item => item.id === restoreId);
+            const entry = hotEntry || coldEntry;
             if (!entry)
                 return { ok: false, output: `[context_history_manage] restore unknown restore_id: ${restoreId}.`, error: 'restore_id not found.' };
             const summaryHeader = entry.summary.startsWith('[Context Compression') ? '[Context Compression' : '[Context History Summary]';
@@ -3578,7 +3894,10 @@ class Agent {
                 return { ok: false, output: '[context_history_manage] restore failed: the folded summary is no longer present in context history (already re-folded or removed).', error: 'restore target summary not found in history.' };
             }
             this.history.splice(markerIndex, 1, ...entry.messages.map(message => ({ ...message })));
-            this.compressionCache = this.compressionCache.filter(item => item.id !== entry.id);
+            if (hotEntry)
+                this.compressionCache = this.compressionCache.filter(item => item.id !== entry.id);
+            if (coldEntry)
+                this.markColdCompressionRestored(entry.id);
             this.saveWorkspaceConversationState(true);
             return {
                 ok: true,
@@ -3588,7 +3907,9 @@ class Agent {
                     restoreId: entry.id,
                     restoredEntries: entry.messages.length,
                     restoredChars: entry.foldedChars,
+                    source: hotEntry ? 'hot-cache' : 'cold-archive',
                     cacheRemaining: this.compressionCache.length,
+                    archiveRemaining: this.coldCompressionEntries().length,
                     displayHistory: { untouched: true, messageCount: this.chatMessages.length },
                 }, null, 2),
                 metadata: { kind: 'context-history-restore' },
@@ -3600,10 +3921,16 @@ class Agent {
             if (!query)
                 return { ok: false, output: '[context_history_manage] search requires query.', error: 'search requires query.' };
             const matches = [];
-            for (const entry of this.compressionCache) {
+            const coldEntries = this.coldCompressionEntries();
+            const searchable = [
+                ...this.compressionCache.map(entry => ({ entry, source: 'hot-cache' })),
+                ...coldEntries.map(entry => ({ entry, source: 'cold-archive' })),
+            ];
+            for (const item of searchable) {
                 if (matches.length >= limit)
                     break;
-                const hit = { cacheId: entry.id, at: entry.at, summary: entry.summary.slice(0, 500), matches: [] };
+                const { entry } = item;
+                const hit = { cacheId: entry.id, source: item.source, at: entry.at, summary: entry.summary.slice(0, 500), matches: [] };
                 if (entry.summary.toLowerCase().includes(query)) {
                     hit.matches.push({ index: -1, snippet: this.snippetAround(entry.summary, query) });
                 }
@@ -3625,18 +3952,78 @@ class Agent {
                     action: 'search',
                     query: String(input.query || ''),
                     cacheEntries: this.compressionCache.length,
+                    archiveEntries: coldEntries.length,
                     matches,
                     displayHistory: { untouched: true, messageCount: this.chatMessages.length },
                 }, null, 2),
                 metadata: { kind: 'context-history-search' },
             };
         }
+        if (action === 'read') {
+            const restoreId = String(input.restore_id || '').trim();
+            if (!restoreId)
+                return { ok: false, output: '[context_history_manage] read requires restore_id.', error: 'read requires restore_id.' };
+            const hotEntry = this.compressionCache.find(item => item.id === restoreId);
+            const coldEntry = hotEntry ? undefined : this.coldCompressionEntries().find(item => item.id === restoreId);
+            const entry = hotEntry || coldEntry;
+            if (!entry)
+                return { ok: false, output: `[context_history_manage] read unknown restore_id: ${restoreId}.`, error: 'restore_id not found.' };
+            const offset = Math.max(0, Math.floor(Number(input.offset || 0)));
+            const contentOffset = Math.max(0, Math.floor(Number(input.content_offset || 0)));
+            const limit = Math.max(1, Math.min(100, Math.floor(Number(input.limit || 20))));
+            const maxChars = Math.max(1_000, Math.min(60_000, Math.floor(Number(input.max_chars || 12_000))));
+            const messages = [];
+            let emittedChars = 0;
+            let nextOffset = null;
+            let nextContentOffset = 0;
+            for (let index = offset; index < entry.messages.length && messages.length < limit; index += 1) {
+                const message = entry.messages[index];
+                const remaining = maxChars - emittedChars;
+                if (remaining <= 0)
+                    break;
+                const fullContent = this.compressionHistoryContent(message.content || message.reasoning_content || '');
+                const start = index === offset ? Math.min(contentOffset, fullContent.length) : 0;
+                const content = fullContent.slice(start, start + remaining);
+                const truncated = start + content.length < fullContent.length;
+                messages.push({ index, role: String(message.role || ''), name: String(message.name || ''), contentOffset: start, content, truncated });
+                emittedChars += content.length;
+                if (truncated) {
+                    nextOffset = index;
+                    nextContentOffset = start + content.length;
+                    break;
+                }
+            }
+            if (nextOffset === null && offset + messages.length < entry.messages.length)
+                nextOffset = offset + messages.length;
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'read',
+                    restoreId: entry.id,
+                    source: hotEntry ? 'hot-cache' : 'cold-archive',
+                    at: entry.at,
+                    foldedEntries: entry.foldedEntries,
+                    foldedChars: entry.foldedChars,
+                    offset,
+                    contentOffset,
+                    returned: messages.length,
+                    nextOffset,
+                    nextContentOffset: nextOffset === null ? null : nextContentOffset,
+                    summary: entry.summary.slice(0, 2_000),
+                    messages,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-read' },
+            };
+        }
         if (action === 'status') {
             const budget = this.compressionBudget(this.history);
             const estimatedTokens = this.estimateContextTokens(this.history);
             const maxTokens = this.contextMaxTokens();
             const protectedStartIndex = this.contextHistoryProtectedStartIndex();
             const lastUserIndex = this.history.map(message => String(message.role || '')).lastIndexOf('user');
+            const coldEntries = this.coldCompressionEntries();
             return {
                 ok: true,
                 output: JSON.stringify({
@@ -3666,6 +4053,13 @@ class Agent {
                         totalFoldedChars: this.compressionCache.reduce((sum, item) => sum + item.foldedChars, 0),
                         ids: this.compressionCache.map(item => item.id),
                     },
+                    archive: {
+                        enabled: this.config.getBool('context', 'compression_archive_enabled'),
+                        entries: coldEntries.length,
+                        totalFoldedEntries: coldEntries.reduce((sum, item) => sum + item.foldedEntries, 0),
+                        totalFoldedChars: coldEntries.reduce((sum, item) => sum + item.foldedChars, 0),
+                        recentIds: coldEntries.slice(-50).map(item => item.id),
+                    },
                     protectedZone: {
                         preserveRecentMessages: this.config.getNum('context', 'preserve_recent_messages') || 5,
                         protectedStartIndex,
@@ -4186,6 +4580,7 @@ class Agent {
         };
     }
     updateGoal(newGoal) {
+        const existingGoalPaused = this.goal?.paused || false;
         if (this.goal) {
             this.goal.update(newGoal);
         }
@@ -4195,9 +4590,10 @@ class Agent {
         }
         if (this.goal) {
             this.goal.verified = false;
-            this.goal.paused = false;
+            // Replacing the objective must not implicitly resume an explicitly paused Goal.
+            this.goal.paused = existingGoalPaused;
             this.goal.goalRounds = 0;
-            this.status = 'idle';
+            this.status = this.goal.paused ? 'goal_paused' : 'idle';
         }
         this.mode = 'goal';
         this.saveWorkspaceConversationState(true);
@@ -4210,6 +4606,17 @@ class Agent {
         this.saveWorkspaceConversationState(true);
         return this.goal.paused;
     }
+    /** Pause only in response to the user's explicit Stop action. */
+    pauseGoalForUserInterrupt() {
+        if (!this.goal)
+            return false;
+        if (!this.goal.paused) {
+            this.goal.paused = true;
+            this.status = 'goal_paused';
+            this.saveWorkspaceConversationState(true);
+        }
+        return true;
+    }
     clearGoal() {
         this.goal = null;
         if (this.mode === 'goal')
@@ -4234,8 +4641,8 @@ class Agent {
     canAutoContinueGoal() {
         return this.goalContinuationGate ? this.goalContinuationGate() : true;
     }
-    claimGoalContinuationMessage() {
-        if (this.mode !== 'goal' || !this.goal || this.goal.paused || !this.canAutoContinueGoal())
+    claimGoalContinuationMessage(options) {
+        if (this.mode !== 'goal' || !this.goal || this.goal.paused || (!options?.force && !this.canAutoContinueGoal()))
             return null;
         const maxGoalContinuations = Math.max(0, Math.floor(this.config.getNum('agent', 'goal_max_continuations') || 0));
         if (maxGoalContinuations > 0 && this.goal.goalRounds >= maxGoalContinuations) {
@@ -6872,9 +7279,62 @@ class Agent {
         if (this.isSubagentRuntime)
             this.subagentContextPersist?.(this.history.map(message => ({ ...message })), this.lastCompression);
     }
+    compressionArchiveScopeKey() {
+        if (this.isSubagentRuntime || !this.config.getBool('context', 'compression_archive_enabled'))
+            return null;
+        return this.workspaceConversationKey();
+    }
+    coldCompressionEntries() {
+        const scopeKey = this.compressionArchiveScopeKey();
+        if (!scopeKey)
+            return [];
+        try {
+            const hotIds = new Set(this.compressionCache.map(entry => entry.id));
+            return this.compressionHistoryArchive.activeEntries(scopeKey).filter(entry => !hotIds.has(entry.id));
+        }
+        catch {
+            return [];
+        }
+    }
+    archiveColdCompressionEntries(entries) {
+        const scopeKey = this.compressionArchiveScopeKey();
+        if (!scopeKey)
+            return [];
+        const failed = [];
+        for (const entry of entries) {
+            try {
+                this.compressionHistoryArchive.archive(scopeKey, entry);
+            }
+            catch {
+                // Prefer a temporarily oversized hot cache over irreversible history loss.
+                failed.push(entry);
+            }
+        }
+        return failed;
+    }
+    markColdCompressionRestored(id) {
+        const scopeKey = this.compressionArchiveScopeKey();
+        if (!scopeKey)
+            return;
+        try {
+            this.compressionHistoryArchive.markRestored(scopeKey, id);
+        }
+        catch {
+            // The restored context is already authoritative; archive bookkeeping is best-effort.
+        }
+    }
     pushCompressionCacheEntry(summary, messages, model, fallback) {
         if (!messages.length)
             return;
+        const scopeKey = this.compressionArchiveScopeKey();
+        let archivedMaxId = 0;
+        if (scopeKey) {
+            try {
+                archivedMaxId = this.compressionHistoryArchive.maxNumericId(scopeKey);
+            }
+            catch { }
+        }
+        this.nextCompressionCacheId = Math.max(this.nextCompressionCacheId, archivedMaxId + 1);
         const foldedChars = messages.reduce((sum, message) => sum + (typeof message.content === 'string'
             ? message.content.length
             : JSON.stringify(message.content || '').length), 0);
@@ -6891,7 +7351,9 @@ class Agent {
         this.nextCompressionCacheId += 1;
         const maxEntries = Math.max(0, Math.floor(this.config.getNum('context', 'compression_cache_max') || 8));
         if (this.compressionCache.length > maxEntries) {
-            this.compressionCache = this.compressionCache.slice(this.compressionCache.length - maxEntries);
+            const evicted = this.compressionCache.slice(0, this.compressionCache.length - maxEntries);
+            const failed = this.archiveColdCompressionEntries(evicted);
+            this.compressionCache = [...failed, ...this.compressionCache.slice(this.compressionCache.length - maxEntries)];
         }
         this.saveWorkspaceConversationState(true);
     }