newmark-agent 0.3.7 → 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();
@@ -191,6 +193,9 @@ class Agent {
     continuations = [];
     activeConversationId = 'default';
     lastCompression = null;
+    compressionCache = [];
+    nextCompressionCacheId = 1;
+    compressionHistoryArchive;
     workspaceConversations = new Map();
     isSubagentRuntime = false;
     subagentName = '';
@@ -254,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;
     /**
@@ -275,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'))
@@ -1462,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,
@@ -1527,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);
@@ -1565,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,
@@ -1579,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;
@@ -1825,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.',
@@ -1843,6 +2098,7 @@ class Agent {
             this.activeWorkRunId = '';
             this.finalizingWorkRunId = '';
             this.managedWorkRunIds.delete(run.runId);
+            this.persistBuildBlockWorkOverview(run, status, endedAt, goalAudit);
             this.saveWorkspaceConversationState();
             return true;
         }
@@ -1850,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.',
@@ -1864,6 +2122,7 @@ class Agent {
         this.activeWorkRunId = '';
         this.finalizingWorkRunId = '';
         this.managedWorkRunIds.delete(run.runId);
+        this.persistBuildBlockWorkOverview(run, status, endedAt, goalAudit);
         this.saveWorkspaceConversationState();
         return true;
     }
@@ -1970,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) {
@@ -3099,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;
@@ -3106,9 +3384,11 @@ class Agent {
         if (!key)
             return;
         const updatedAt = new Date().toISOString();
+        const runtimeOwner = this.activeConversationRuntimeOwner();
         this.workspaceConversations.set(key, {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
@@ -3119,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();
@@ -3138,6 +3421,7 @@ class Agent {
             title,
             chatMessages: [...this.chatMessages],
             history: [...this.history],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
@@ -3148,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) {
@@ -3167,6 +3454,8 @@ class Agent {
         if (!key) {
             this.chatMessages = [];
             this.history = [];
+            this.compressionCache = [];
+            this.nextCompressionCacheId = 1;
             this.conversationPlan = { items: [] };
             this.linkedPlan = { markdown: '', revision: 0 };
             this.workRuns = [];
@@ -3183,6 +3472,8 @@ class Agent {
         const saved = this.workspaceConversations.get(key);
         if (saved) {
             this.history = [...saved.history];
+            this.compressionCache = saved.compressionCache ? saved.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+            this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
             this.chatMessages = this.normalizeConversationChatMessages(saved.chatMessages, this.history);
             this.conversationPlan = this.normalizeConversationPlan(saved.plan);
             this.linkedPlan = this.normalizeLinkedPlan(saved.linkedPlan);
@@ -3195,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;
         }
@@ -3202,10 +3494,12 @@ class Agent {
         const stateKey = this.workspaceConversationStateKey();
         const persisted = stateKey && stored.conversations ? stored.conversations[stateKey] : null;
         this.history = persisted?.history ? [...persisted.history] : [];
+        this.compressionCache = persisted?.compressionCache ? persisted.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+        this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
         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);
@@ -3213,33 +3507,64 @@ 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],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
             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) {
@@ -3466,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).', 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) => ({
@@ -3489,11 +3814,19 @@ class Agent {
                 metadata: { kind: 'context-history-list' },
             };
         }
+        const protectedZone = this.contextHistoryProtectedZone();
         if (action === 'remove') {
             const position = Math.floor(Number(input.position));
             if (!Number.isFinite(position) || position < 0 || position >= this.history.length) {
                 return { ok: false, output: `[context_history_manage] remove position ${position} out of range (0..${this.history.length - 1}).`, error: 'remove position out of range.' };
             }
+            if (protectedZone.has(position) && !Boolean(input.dangerous)) {
+                return {
+                    ok: false,
+                    output: `[context_history_manage] remove position ${position} is protected (recent context tail or the last user message). Pass dangerous: true to override.`,
+                    error: 'remove position is in the protected context zone.',
+                };
+            }
             const removed = this.history.splice(position, 1)[0];
             this.saveWorkspaceConversationState(true);
             return {
@@ -3517,11 +3850,20 @@ class Agent {
                 return { ok: false, output: `[context_history_manage] summarize position ${from} out of range (0..${this.history.length - 1}).`, error: 'summarize position out of range.' };
             if (to - from < 1)
                 return { ok: false, output: '[context_history_manage] summarize requires at least two entries in range.', error: 'summarize requires a range of at least two entries.' };
+            const protectedHit = this.history.slice(from, to + 1).some((_, index) => protectedZone.has(from + index));
+            if (protectedHit && !Boolean(input.dangerous)) {
+                return {
+                    ok: false,
+                    output: '[context_history_manage] summarize range includes protected entries (recent context tail or the last user message). Pass dangerous: true to override.',
+                    error: 'summarize range overlaps the protected context zone.',
+                };
+            }
             const segment = this.history.slice(from, to + 1);
             const chars = segment.reduce((sum, message) => sum + (typeof message.content === 'string' ? message.content.length : JSON.stringify(message.content || '').length), 0);
             const summary = this.localCompressionSummary(`Workspace: ${this.workspace.current?.path || this.rootPath}\nMode: ${this.modeName()}`, segment.map((message, i) => `#${i + 1} [${String(message.role || 'unknown')}${message.name ? ` ${String(message.name)}` : ''}]\n${this.compressionHistoryContent(message.content || '')}`).join('\n\n').slice(0, 20000), segment.length, chars);
             const replacement = { role: 'system', content: `[Context History Summary]\n${summary}` };
             this.history.splice(from, to - from + 1, replacement);
+            this.pushCompressionCacheEntry(`[Context History Summary]\n${summary}`, segment, 'local-summarize', true);
             this.saveWorkspaceConversationState(true);
             return {
                 ok: true,
@@ -3539,6 +3881,196 @@ class Agent {
                 metadata: { kind: 'context-history-summarize' },
             };
         }
+        if (action === 'restore') {
+            const restoreId = String(input.restore_id || '').trim();
+            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]';
+            const markerIndex = this.history.findIndex(message => String(message.role || '') === 'system' && String(message.content || '').includes(summaryHeader) && String(message.content || '').includes(entry.summary.slice(0, 200)));
+            if (markerIndex < 0) {
+                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 })));
+            if (hotEntry)
+                this.compressionCache = this.compressionCache.filter(item => item.id !== entry.id);
+            if (coldEntry)
+                this.markColdCompressionRestored(entry.id);
+            this.saveWorkspaceConversationState(true);
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'restore',
+                    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' },
+            };
+        }
+        if (action === 'search') {
+            const query = String(input.query || '').trim().toLowerCase();
+            const limit = Math.max(1, Math.min(200, Math.floor(Number(input.limit || 20))));
+            if (!query)
+                return { ok: false, output: '[context_history_manage] search requires query.', error: 'search requires query.' };
+            const matches = [];
+            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 { 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) });
+                }
+                entry.messages.forEach((message, index) => {
+                    if (matches.length >= limit || hit.matches.length >= 40)
+                        return;
+                    const content = this.compressionHistoryContent(message.content || message.reasoning_content || '');
+                    if (content.toLowerCase().includes(query)) {
+                        hit.matches.push({ index, snippet: this.snippetAround(content, query) });
+                    }
+                });
+                if (hit.matches.length)
+                    matches.push(hit);
+            }
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    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({
+                    ok: true,
+                    action: 'status',
+                    historyLength: this.history.length,
+                    chatMessages: this.chatMessages.length,
+                    estimatedTokens,
+                    maxTokens,
+                    triggerTokens: budget.triggerTokens,
+                    targetTokens: budget.targetTokens,
+                    summaryTokens: budget.summaryTokens,
+                    usagePercent: maxTokens > 0 ? Math.round((estimatedTokens / maxTokens) * 1000) / 10 : 0,
+                    thresholdReached: budget.triggerTokens > 0 && estimatedTokens >= budget.triggerTokens,
+                    keepRecentMessages: this.config.getNum('context', 'keep_recent_messages') || 10,
+                    lastCompression: this.lastCompression ? {
+                        at: this.lastCompression.at,
+                        originalMessages: this.lastCompression.originalMessages,
+                        compressedMessages: this.lastCompression.compressedMessages,
+                        compressedTokens: this.lastCompression.compressedTokens,
+                        model: this.lastCompression.model,
+                        fallback: this.lastCompression.fallback,
+                    } : null,
+                    cache: {
+                        entries: this.compressionCache.length,
+                        totalFoldedEntries: this.compressionCache.reduce((sum, item) => sum + item.foldedEntries, 0),
+                        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,
+                        lastUserMessageIndex: lastUserIndex,
+                        protectedCount: protectedStartIndex >= 0 ? this.history.length - protectedStartIndex : 0,
+                    },
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-status' },
+            };
+        }
         return { ok: false, output: `[context_history_manage] Unknown action: ${action}`, error: `Unknown action: ${action}` };
     }
     recordContextCompressionStep() {
@@ -3980,6 +4512,7 @@ class Agent {
                     model: fallbackUsed ? 'model-switch-segmented-with-fallback' : modelName,
                     fallback: fallbackUsed,
                 };
+                this.pushCompressionCacheEntry(summary, originalMessages.slice(0, recentStart), 'model-switch', fallbackUsed);
                 this.persistCompressedHistory(summary, recent.length, candidate);
                 this.saveWorkspaceConversationState(true);
                 return { compressed: true, rounds, segments, droppedMessages: 0, estimatedTokens: this.estimateContextTokens(candidate), maxTokens };
@@ -4016,6 +4549,7 @@ class Agent {
             model: fallbackUsed ? 'model-switch-segmented-with-fallback' : modelName,
             fallback: fallbackUsed || droppedMessages > 0,
         };
+        this.pushCompressionCacheEntry(summary, originalMessages.slice(0, recentStart), 'model-switch', fallbackUsed || droppedMessages > 0);
         this.persistCompressedHistory(summary, recent.length, candidate);
         this.saveWorkspaceConversationState(true);
         return { compressed: true, rounds, segments, droppedMessages, estimatedTokens: this.estimateContextTokens(candidate), maxTokens };
@@ -4046,6 +4580,7 @@ class Agent {
         };
     }
     updateGoal(newGoal) {
+        const existingGoalPaused = this.goal?.paused || false;
         if (this.goal) {
             this.goal.update(newGoal);
         }
@@ -4055,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);
@@ -4070,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')
@@ -4094,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) {
@@ -6574,6 +7121,7 @@ class Agent {
             model: compression.model,
             fallback: compression.fallback,
         };
+        this.pushCompressionCacheEntry(compression.summary, middle, compression.model, compression.fallback);
         this.persistCompressedHistory(compression.summary, recent.length, msgs);
     }
     async buildCompressionSummary(middle, totalChars, budget, provider, signal, compressionModel, currentInstruction = '') {
@@ -6731,6 +7279,111 @@ 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);
+        this.compressionCache.push({
+            id: `ctx-cache-${this.nextCompressionCacheId}`,
+            at: new Date().toISOString(),
+            summary,
+            messages: messages.map(message => ({ ...message })),
+            foldedEntries: messages.length,
+            foldedChars,
+            model,
+            fallback,
+        });
+        this.nextCompressionCacheId += 1;
+        const maxEntries = Math.max(0, Math.floor(this.config.getNum('context', 'compression_cache_max') || 8));
+        if (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);
+    }
+    contextHistoryProtectedStartIndex() {
+        const preserve = Math.max(0, Math.floor(this.config.getNum('context', 'preserve_recent_messages') || 5));
+        const lastUserIndex = this.history.map(message => String(message.role || '')).lastIndexOf('user');
+        const candidates = [];
+        if (preserve > 0 && this.history.length > 0)
+            candidates.push(Math.max(0, this.history.length - preserve));
+        if (lastUserIndex >= 0)
+            candidates.push(lastUserIndex);
+        return candidates.length ? Math.min(...candidates) : -1;
+    }
+    contextHistoryProtectedZone() {
+        const start = this.contextHistoryProtectedStartIndex();
+        const zone = new Set();
+        if (start >= 0)
+            for (let i = start; i < this.history.length; i += 1)
+                zone.add(i);
+        return zone;
+    }
+    snippetAround(content, query, radius = 150) {
+        const text = String(content || '');
+        const index = text.toLowerCase().indexOf(query.toLowerCase());
+        if (index < 0)
+            return text.slice(0, radius * 2);
+        const from = Math.max(0, index - radius);
+        const to = Math.min(text.length, index + query.length + radius);
+        return `${from > 0 ? '…' : ''}${text.slice(from, to).trim()}${to < text.length ? '…' : ''}`;
+    }
     buildSystemPrompt() {
         const cwd = this.workspace.current?.path || this.rootPath;
         const enabledSkills = this.skills.active();