newmark-agent 0.3.7 → 0.3.10

package/dist/core/agentKernelRunner.js

@@ -401,7 +401,7 @@ async function runAgentKernel(agent) {
             throw new ProviderRunError(normalizePublicProviderError(lastTurn.errorMessage || lastTurn.text, [agent.activeModelConfig()?.api_key]));
         }
         const lastAssistant = lastTurn.text;
-        if (agent.mode === 'goal' && agent.goal && agent.goal.checkComplete(lastAssistant)) {
+        if (agent.mode === 'goal' && agent.goal && !agent.goal.paused && agent.goal.checkComplete(lastAssistant)) {
             agent.markGoalComplete();
             if (!tokens.some(token => token.type === 'text' && /goal complete/i.test(token.text || ''))) {
                 tokens.push({ type: 'text', text: '\n[Goal Complete]' });

package/dist/core/compressionHistoryArchive.d.ts

@@ -0,0 +1,28 @@
+export interface ArchivedCompressionEntry {
+    id: string;
+    at: string;
+    summary: string;
+    messages: Array<Record<string, unknown>>;
+    foldedEntries: number;
+    foldedChars: number;
+    model: string;
+    fallback: boolean;
+}
+/**
+ * Append-only cold storage for folded context segments evicted from the small
+ * in-state hot cache. The archive is never injected into a model request;
+ * callers must explicitly search/read/restore one bounded segment.
+ */
+export declare class CompressionHistoryArchive {
+    private readonly rootPath;
+    constructor(rootPath: string);
+    private file;
+    private append;
+    archive(scopeKey: string, entry: ArchivedCompressionEntry): void;
+    markRestored(scopeKey: string, id: string): void;
+    /** Replays the append-only ledger and returns only currently restorable entries. */
+    activeEntries(scopeKey: string): ArchivedCompressionEntry[];
+    /** Includes restored/tombstoned ids so a restart never reuses an archive id. */
+    maxNumericId(scopeKey: string): number;
+}
+//# sourceMappingURL=compressionHistoryArchive.d.ts.map

package/dist/core/compressionHistoryArchive.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionHistoryArchive = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Append-only cold storage for folded context segments evicted from the small
+ * in-state hot cache. The archive is never injected into a model request;
+ * callers must explicitly search/read/restore one bounded segment.
+ */
+class CompressionHistoryArchive {
+    rootPath;
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    file(scopeKey) {
+        const digest = crypto.createHash('sha256').update(scopeKey).digest('hex');
+        return path.join(this.rootPath, '.newmark-context-v2', 'compression-history', `${digest}.jsonl`);
+    }
+    append(scopeKey, event) {
+        const file = this.file(scopeKey);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${JSON.stringify(event)}\n`, 'utf-8');
+    }
+    archive(scopeKey, entry) {
+        this.append(scopeKey, {
+            version: 1,
+            type: 'fold',
+            at: new Date().toISOString(),
+            entry: { ...entry, messages: entry.messages.map(message => ({ ...message })) },
+        });
+    }
+    markRestored(scopeKey, id) {
+        this.append(scopeKey, { version: 1, type: 'restore', at: new Date().toISOString(), id });
+    }
+    /** Replays the append-only ledger and returns only currently restorable entries. */
+    activeEntries(scopeKey) {
+        const file = this.file(scopeKey);
+        if (!fs.existsSync(file))
+            return [];
+        const active = new Map();
+        const lines = fs.readFileSync(file, 'utf-8').split(/\r?\n/);
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.version !== 1)
+                    continue;
+                if (event.type === 'restore') {
+                    active.delete(String(event.id || ''));
+                    continue;
+                }
+                if (event.type !== 'fold' || !event.entry || typeof event.entry !== 'object')
+                    continue;
+                const candidate = event.entry;
+                if (!candidate.id || !Array.isArray(candidate.messages) || typeof candidate.summary !== 'string')
+                    continue;
+                active.set(candidate.id, {
+                    ...candidate,
+                    messages: candidate.messages.map(message => ({ ...message })),
+                    foldedEntries: Math.max(0, Number(candidate.foldedEntries) || candidate.messages.length),
+                    foldedChars: Math.max(0, Number(candidate.foldedChars) || 0),
+                    model: String(candidate.model || 'unknown'),
+                    fallback: Boolean(candidate.fallback),
+                });
+            }
+            catch {
+                // A partial/corrupt line must not hide earlier valid append-only events.
+            }
+        }
+        return [...active.values()];
+    }
+    /** Includes restored/tombstoned ids so a restart never reuses an archive id. */
+    maxNumericId(scopeKey) {
+        const file = this.file(scopeKey);
+        if (!fs.existsSync(file))
+            return 0;
+        let max = 0;
+        for (const line of fs.readFileSync(file, 'utf-8').split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                const entry = event.entry && typeof event.entry === 'object' ? event.entry : null;
+                const id = String(entry?.id || event.id || '');
+                max = Math.max(max, Number(id.replace(/^ctx-cache-/, '')) || 0);
+            }
+            catch {
+                // Ignore only the malformed line; valid earlier ids remain authoritative.
+            }
+        }
+        return max;
+    }
+}
+exports.CompressionHistoryArchive = CompressionHistoryArchive;
+//# sourceMappingURL=compressionHistoryArchive.js.map

package/dist/core/config.js

@@ -911,6 +911,9 @@ function defaultConfig() {
             auto_compress: { _description: "Auto-compress history", _type: "boolean", value: true },
             compress_threshold_chars: { _description: "Compression threshold", _type: "integer", value: 80000 },
             keep_recent_messages: { _description: "Keep recent messages", _type: "integer", value: 10 },
+            preserve_recent_messages: { _description: "dev-0.3.8 protected recent-message zone for context_history_manage (0 disables)", _type: "integer", value: 5 },
+            compression_cache_max: { _description: "dev-0.3.8 max folded-segment cache entries retained for restore/search", _type: "integer", value: 8 },
+            compression_archive_enabled: { _description: "dev-0.3.9 append-only cold archive for folded segments evicted from the hot cache", _type: "boolean", value: true },
             structured_context_v2: { _description: "dev-0.3.0 structured context v2 (orchestrator + fixed order + snapshot)", _type: "boolean", value: true },
             build_history_persistence: { _description: "dev-0.3.0 append-only Build History persistence", _type: "boolean", value: true },
             branch_log_v2: { _description: "dev-0.3.0 branch long-log v2 (epoch summaries)", _type: "boolean", value: true },

package/dist/core/conversationKernel.d.ts

@@ -198,7 +198,7 @@ export declare class ConversationKernel {
     setWorkRunExpanded(target: ConversationTargetInput, runId: string, expanded: boolean): boolean;
     setInputMode(target: ConversationTargetInput, mode: string): 'guide' | 'next';
     setMode(target: ConversationTargetInput, mode: AgentMode): AgentMode;
-    toggleGoalPause(target: ConversationTargetInput): boolean;
+    toggleGoalPause(target: ConversationTargetInput): Promise<boolean>;
     clearGoal(target: ConversationTargetInput): boolean;
     updateSetting(section: string, key: string, value: unknown): void;
     runtimeState(target: ConversationTargetInput): ConversationRuntimeState | null;
@@ -212,6 +212,7 @@ export declare class ConversationKernel {
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;
+    private startGoalDrivenBuild;
     private createRunner;
     private enqueueRootInboxWake;
     private applyOptions;

package/dist/core/conversationKernel.js

@@ -333,11 +333,26 @@ class ConversationKernel {
             runtime.options.mode = mode;
         return runner.mode;
     }
-    toggleGoalPause(target) {
+    async toggleGoalPause(target) {
         const normalized = this.normalizeTarget(target);
-        const runtime = this.findRuntime(normalized);
-        const runner = runtime?.runner || this.createRunner(normalized);
-        return runner.toggleGoalPause();
+        let runtime = this.findRuntime(normalized);
+        if (!runtime) {
+            const runner = this.createRunner(normalized);
+            runtime = this.runtime(normalized, {
+                mode: runner.mode,
+                model: runner.model,
+                intelligence: runner.intelligence,
+                inputMode: runner.inputMode,
+                engine: runner.engine,
+            }, runner);
+        }
+        const wasPaused = runtime.runner.isGoalPaused();
+        const hadGoal = !!runtime.runner.goal;
+        const paused = runtime.runner.toggleGoalPause();
+        if (hadGoal && wasPaused && !paused)
+            this.startGoalDrivenBuild(runtime);
+        this.mirrorHostIfTargetActive(runtime);
+        return paused;
     }
     clearGoal(target) {
         const normalized = this.normalizeTarget(target);
@@ -401,6 +416,7 @@ class ConversationKernel {
         }
         runtime.stopRequestedRunId = runtime.runId;
         runtime.forceStopArmedRunId = runtime.runId;
+        runtime.runner.pauseGoalForUserInterrupt();
         this.retainUnconsumedKernelMessages(runtime);
         this.deferOutstandingGuides(runtime);
         const checkpointed = this.checkpoint(runtime.target).checkpointed;
@@ -610,7 +626,7 @@ class ConversationKernel {
             return 0;
         return Math.max(1000, Math.floor(raw));
     }
-    runtime(target, options) {
+    runtime(target, options, runnerOverride) {
         const existing = this.findRuntime(target);
         if (existing) {
             this.ensureRuntimeMetadata(existing, target);
@@ -618,7 +634,7 @@ class ConversationKernel {
             return existing;
         }
         const id = target.conversationId;
-        const runner = this.createRunner(target);
+        const runner = runnerOverride || this.createRunner(target);
         runner.setAutomationManager(this.automation);
         this.applyOptions(runner, options);
         const runtime = {
@@ -732,8 +748,23 @@ class ConversationKernel {
             });
         }, 250);
     }
+    startGoalDrivenBuild(runtime) {
+        if (runtime.goalContinuationTimer) {
+            clearTimeout(runtime.goalContinuationTimer);
+            runtime.goalContinuationTimer = undefined;
+        }
+        const message = runtime.runner.claimGoalContinuationMessage({ force: true });
+        if (!message)
+            return;
+        void this.prompt(message, runtime.target, { ...runtime.options, mode: 'goal' }, 'followUp').catch(() => {
+            // Agent.process records and publishes the Build error.
+        });
+    }
     createRunner(target) {
-        const runner = this.lifecycle.createRunner?.(target) || new agent_1.Agent(this.root, { actorId: this.host.runtimeActorId });
+        const runner = this.lifecycle.createRunner?.(target) || new agent_1.Agent(this.root, {
+            actorId: this.host.runtimeActorId,
+            runtimeLifecycleRole: this.host.runtimeLifecycleRole,
+        });
         if (target.workspace) {
             runner.workspace.current = {
                 id: target.workspace.id,

package/dist/core/electronBrowserUseHost.js

@@ -94,11 +94,20 @@ class ElectronBrowserUseHost {
             evaluateFixed: async (script, signal) => await raceWithAbort(contents.executeJavaScriptInIsolatedWorld(BROWSER_USE_WORLD_ID, [{ code: script }], true), signal),
             clickAt: async (x, y, signal) => {
                 throwIfAborted(signal);
+                // A webview guest can retain the DOM focus while its embedder is still
+                // committing a workspace/tab transition. Focus both sides and yield
+                // between native input events so Chromium receives a real click rather
+                // than a synchronously queued sequence that can be dropped by the guest.
+                contents.hostWebContents?.focus();
                 contents.focus();
+                await abortableDelay(10, signal);
                 const point = { x: Math.max(0, Math.round(x)), y: Math.max(0, Math.round(y)) };
                 contents.sendInputEvent({ type: 'mouseMove', ...point });
+                await abortableDelay(10, signal);
                 contents.sendInputEvent({ type: 'mouseDown', button: 'left', clickCount: 1, ...point });
+                await abortableDelay(10, signal);
                 contents.sendInputEvent({ type: 'mouseUp', button: 'left', clickCount: 1, ...point });
+                await abortableDelay(10, signal);
             },
             replaceFocusedText: async (text, signal) => {
                 throwIfAborted(signal);

package/dist/core/electronUtilityRuntimePool.js

@@ -247,7 +247,7 @@ class ElectronUtilityRuntimePool {
         }
     }
     async toggleGoalPause(target) {
-        const entry = await this.acquireExisting((0, conversationTarget_1.normalizeConversationTarget)(target));
+        const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         if (!entry?.client.toggleGoalPause)
             return null;
         try {
@@ -630,12 +630,11 @@ class ElectronUtilityRuntimePool {
                 }
                 const finalized = !!kernelForce && kernelForce.action === 'force';
                 const checkpointed = finalized ? (kernelForce.checkpointed || intent.checkpointed) : intent.checkpointed;
-                if (!finalized) {
-                    // The worker event loop is wedged: hard-kill the process tree without
-                    // starting a replacement. The first-stop checkpoint preserves the
-                    // conversation; only the latest run is discarded.
-                    await entry.client.forceStop();
-                }
+                // The acknowledgement only gives the kernel a chance to persist its
+                // force_interrupted settlement. A second Stop still owns a process-level
+                // termination boundary and must leave the target runtime down until the
+                // next prompt, even when the worker acknowledged the force request.
+                await entry.client.forceStop();
                 entry.lastSnapshot = null;
                 entry.workEvents = [];
                 entry.lastRunId = '';

package/dist/core/runtimeLifecycle.d.ts

@@ -0,0 +1,23 @@
+export type RuntimeLifecycleRole = 'main' | 'utility' | 'wsl';
+export interface RuntimeLifecycleState {
+    role: RuntimeLifecycleRole;
+    ownerId: string;
+    pid: number;
+    startedAt: string;
+    previousOwnerAlive: boolean;
+    unexpectedExit: boolean;
+    active: true;
+}
+export declare function isRuntimeProcessAlive(pid: number): boolean;
+/**
+ * Claim this process/role as the current runtime owner.
+ *
+ * A frontend cold runner in the same process gets the same in-memory claim and
+ * therefore does not look like a restart. A genuinely new process sees the
+ * previous active claim and can pause orphaned Goal/Flow state once.
+ */
+export declare function beginRuntimeLifecycle(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState;
+/** Mark only this owner clean; a hard kill leaves the active marker intact. */
+export declare function markRuntimeLifecycleClean(root: string, role?: RuntimeLifecycleRole): void;
+export declare function runtimeLifecycleState(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState | null;
+//# sourceMappingURL=runtimeLifecycle.d.ts.map

package/dist/core/runtimeLifecycle.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeProcessAlive = isRuntimeProcessAlive;
+exports.beginRuntimeLifecycle = beginRuntimeLifecycle;
+exports.markRuntimeLifecycleClean = markRuntimeLifecycleClean;
+exports.runtimeLifecycleState = runtimeLifecycleState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const processStates = new Map();
+function stateKey(root, role) {
+    return `${path.resolve(root)}\u0000${role}`;
+}
+function statePath(root, role, ownerId = '') {
+    return path.join(root, '.newmark-runtime', ownerId ? `lifecycle-${role}-${ownerId}.json` : `lifecycle-${role}.json`);
+}
+function readState(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRuntimeProcessAlive(pid) {
+    const candidate = Math.floor(Number(pid) || 0);
+    if (candidate <= 0)
+        return false;
+    try {
+        process.kill(candidate, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writeState(root, role, state) {
+    const ownerId = typeof state.ownerId === 'string' ? state.ownerId : '';
+    const file = statePath(root, role, ownerId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${(0, crypto_1.randomUUID)()}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(state, null, 2), 'utf-8');
+    fs.renameSync(temporary, file);
+}
+function readActiveStates(root, role) {
+    const directory = path.join(root, '.newmark-runtime');
+    try {
+        const prefix = `lifecycle-${role}`;
+        return fs.readdirSync(directory)
+            .filter(file => file.startsWith(prefix) && file.endsWith('.json'))
+            .map(file => readState(path.join(directory, file)))
+            .filter((state) => !!state && state.active === true);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Claim this process/role as the current runtime owner.
+ *
+ * A frontend cold runner in the same process gets the same in-memory claim and
+ * therefore does not look like a restart. A genuinely new process sees the
+ * previous active claim and can pause orphaned Goal/Flow state once.
+ */
+function beginRuntimeLifecycle(root, role = 'main') {
+    const key = stateKey(root, role);
+    const existingProcessState = processStates.get(key);
+    if (existingProcessState)
+        return existingProcessState;
+    const previousStates = readActiveStates(root, role);
+    const previousOwnerAlive = previousStates.some(previous => isRuntimeProcessAlive(Number(previous.pid)));
+    const state = {
+        role,
+        ownerId: (0, crypto_1.randomUUID)(),
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        previousOwnerAlive,
+        unexpectedExit: previousStates.length > 0 && !previousOwnerAlive,
+        active: true,
+    };
+    try {
+        writeState(root, role, state);
+    }
+    catch {
+        // Recovery remains conservative when the marker cannot be written. The
+        // persisted WorkRun timestamp still protects a live backend cold read.
+    }
+    processStates.set(key, state);
+    return state;
+}
+/** Mark only this owner clean; a hard kill leaves the active marker intact. */
+function markRuntimeLifecycleClean(root, role = 'main') {
+    const key = stateKey(root, role);
+    const current = processStates.get(key);
+    if (!current)
+        return;
+    try {
+        writeState(root, role, {
+            ...current,
+            active: false,
+            cleanExitAt: new Date().toISOString(),
+        });
+    }
+    catch {
+        // Leaving the marker active is safer than claiming a clean exit after a
+        // failed durable write.
+    }
+}
+function runtimeLifecycleState(root, role = 'main') {
+    return processStates.get(stateKey(root, role)) || null;
+}
+//# sourceMappingURL=runtimeLifecycle.js.map

package/dist/core/types.d.ts

@@ -129,6 +129,9 @@ export interface ConversationWorkRun {
     runId: string;
     target: ConversationTarget;
     runtimeKey: string;
+    runtimeOwnerId?: string;
+    runtimeOwnerPid?: number;
+    runtimeLifecycleRole?: 'main' | 'utility' | 'wsl';
     status: ConversationWorkRunStatus;
     startedAt: string;
     endedAt?: string;

package/dist/core/wslAgentRuntimePool.js

@@ -262,7 +262,7 @@ class WslAgentRuntimePool {
     }
     async toggleGoalPause(target) {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
-        const entry = await this.acquireExisting(normalized);
+        const entry = await this.acquire(normalized);
         if (!entry?.client.toggleGoalPause)
             return null;
         try {
@@ -616,15 +616,14 @@ class WslAgentRuntimePool {
                 }
                 const finalized = !!kernelForce && kernelForce.action === 'force';
                 const checkpointed = finalized ? (kernelForce.checkpointed || intent.checkpointed) : intent.checkpointed;
-                if (!finalized) {
-                    // The worker event loop is wedged: hard-kill the process group without
-                    // starting a replacement. The first-stop checkpoint preserves the
-                    // conversation; only the latest run is discarded.
-                    if (entry.client.forceStopRuntimeGroup)
-                        await entry.client.forceStopRuntimeGroup();
-                    else
-                        await entry.client.forceRestartRuntimeGroup();
-                }
+                // The acknowledgement only gives the kernel a chance to persist its
+                // force_interrupted settlement. A second Stop still owns a process-group
+                // termination boundary and must leave the target runtime down until the
+                // next prompt, even when the worker acknowledged the force request.
+                if (entry.client.forceStopRuntimeGroup)
+                    await entry.client.forceStopRuntimeGroup();
+                else
+                    await entry.client.forceRestartRuntimeGroup();
                 entry.lastSnapshot = null;
                 entry.workEvents = [];
                 entry.lastRunId = '';

package/dist/main.js

@@ -70,6 +70,7 @@ const wslAgentRuntimePool_1 = require("./core/wslAgentRuntimePool");
 const utilityHostToolRouter_1 = require("./core/utilityHostToolRouter");
 const startupPrewarm_1 = require("./core/startupPrewarm");
 const runtimeShutdown_1 = require("./core/runtimeShutdown");
+const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
 const compat_1 = require("./core/compat");
 const mcpManager_1 = require("./core/mcpManager");
 const APP_NAME = 'Newmark Agent';
@@ -2106,6 +2107,15 @@ else {
                 }
                 electron_1.app.quit();
             };
+            const hasUnsettledGoalOrFlow = () => {
+                const goalRunning = !!agent?.goal && !agent.goal.paused;
+                const flowRunning = Array.from(activeFlowsByRuntimeKey.values()).some(state => !!state.abortController);
+                return goalRunning || flowRunning;
+            };
+            const markMainLifecycleCleanIfSafe = () => {
+                if (!hasUnsettledGoalOrFlow())
+                    (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
+            };
             electron_1.app.on('will-quit', event => {
                 if (_forceQuit)
                     armForcedExitDeadline('will-quit');
@@ -2131,6 +2141,7 @@ else {
                                 throw error;
                             })
                             : undefined;
+                        let shutdownFailed = false;
                         void (0, runtimeShutdown_1.runRuntimeShutdownBarrier)({
                             operations: [
                                 legacyStop,
@@ -2139,9 +2150,12 @@ else {
                             ],
                             shutdownHelpers: async () => await (0, electronUtilityAgentClient_1.shutdownWindowsProcessHelpers)(2_000),
                         }).catch(error => {
+                            shutdownFailed = true;
                             console.error('[Newmark] Runtime shutdown cleanup failed:', error instanceof Error ? error.message : String(error));
                         }).finally(() => {
                             appExitCleanupComplete = true;
+                            if (!shutdownFailed)
+                                markMainLifecycleCleanIfSafe();
                             electron_1.app.quit();
                         });
                     }
@@ -2170,6 +2184,7 @@ else {
                     sidecarProcess = null;
                 }
                 (0, terminalTakeover_1.shutdownTerminalTakeoverSessions)('app-exit');
+                markMainLifecycleCleanIfSafe();
                 if (forcedExitTimer) {
                     clearTimeout(forcedExitTimer);
                     forcedExitTimer = null;

package/dist/tools/index.js

@@ -374,11 +374,17 @@ class ToolExecutor {
             t('linked_plan', 'Read or update the current conversation linked Markdown plan. Update requires the current expected_revision.', { action: { type: 'string', enum: ['get', 'update'] }, markdown: { type: 'string' }, expected_revision: { type: 'number' } }, ['action']),
             t('build_history_query', 'Read the concrete public work details of one historical Build Block. The prompt already exposes user input, final summary, and completion status; call this read-only tool only when the user asks what specifically happened. Select by newest-to-oldest history_index, or by run_id returned from an earlier query.', { history_index: { type: 'number', minimum: 1, description: '1-based historical Build Block index from the request ledger; 1 is the newest previous task.' }, run_id: { type: 'string', description: 'Exact run id returned by an earlier build_history_query result.' }, max_events: { type: 'number', minimum: 1, maximum: 200, description: 'Maximum trailing public work events; defaults to 80.' } }, []),
             t('context_compress', 'Actively compress the LLM context history for this conversation. This collapses older history entries into a concise summary while preserving the recent tail, which reduces context tokens and cost. IMPORTANT: it affects only the LLM context (what the model sees); the displayed conversation history shown to the user is never altered. Call this when the conversation is long, token pressure is high, or you judge that older turns are no longer needed in full. Idempotent and safe: repeated calls produce incremental summaries.', { keep_recent: { type: 'number', minimum: 2, maximum: 60, description: 'Recent message count to keep uncompressed at the tail. Defaults to the configured keep_recent_messages.' }, force: { type: 'boolean', description: 'Compress even if the context is not yet over the automatic threshold. Defaults to false.' } }, []),
-            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. Actions: list returns a bounded index of context entries (position, role, name, length, first-line preview); remove deletes the entry at a given position; summarize replaces a contiguous range of context entries with a concise local summary entry. The displayed conversation history (what the user sees) is never modified by any action.', {
-                action: { type: 'string', enum: ['list', 'remove', 'summarize'], description: 'list: index context entries. remove: delete the entry at position. summarize: fold entries [from, to] into one summary entry.' },
+            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. The hot cache stays bounded; evicted folded segments remain in a conversation-isolated append-only cold archive and are loaded only by explicit search/read/restore calls. Actions: list returns a bounded index of current context entries; remove deletes one current entry; summarize folds a contiguous current range; restore reinserts a folded segment when its summary marker is still present; search finds matching hot or archived segments; read returns one bounded segment without injecting the whole archive; status reports budgets, hot cache, cold archive, and the protected recent zone. The recent context tail and last user message are protected from remove/summarize unless dangerous is true.', {
+                action: { type: 'string', enum: ['list', 'remove', 'summarize', 'restore', 'search', 'read', 'status'], description: 'list current entries; remove one; summarize a range; restore by restore_id; search hot/cold folded segments; read one bounded folded segment; status report context budgets and storage.' },
                 position: { type: 'number', minimum: 0, description: '0-based context entry index for remove, or the start of the range for summarize.' },
                 to: { type: 'number', minimum: 0, description: '0-based inclusive end of the range for summarize. Defaults to position.' },
-                limit: { type: 'number', minimum: 5, maximum: 400, description: 'Maximum context entries to list; defaults to 200.' },
+                limit: { type: 'number', minimum: 1, maximum: 400, description: 'Maximum context entries/messages/matches to return. Current-history list still keeps a minimum page of 5.' },
+                restore_id: { type: 'string', description: 'Cache id of a folded segment (from search or status) to restore into context.' },
+                query: { type: 'string', description: 'Case-insensitive text to search for across cached folded segments and their summaries.' },
+                offset: { type: 'number', minimum: 0, description: 'Message offset for read pagination.' },
+                content_offset: { type: 'number', minimum: 0, description: 'Character offset within the first read message, used with nextContentOffset when one message exceeds max_chars.' },
+                max_chars: { type: 'number', minimum: 1000, maximum: 60000, description: 'Maximum message-content characters returned by read (default 12000).' },
+                dangerous: { type: 'boolean', description: 'Set true to override the protected recent-message zone and allow removing/summarizing entries that include the recent context tail or the last user message.' },
             }, ['action']),
             t('question', 'Ask user a multiple-choice question', { questions: { type: 'array' } }, ['questions']),
             t('skill_download', 'Download a skill', { name: { type: 'string' }, source: { type: 'string' } }, ['name', 'source']),

package/dist/tools/nativeTools.js

@@ -41,7 +41,7 @@ exports.NATIVE_TOOL_CATALOG = [
     { name: 'linked_plan', label: 'Linked plan', description: 'Read or conservatively update the conversation-linked Markdown plan.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'build_history_query', label: 'Build history query', description: 'Read concrete public work details for one historical Build Block.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'context_compress', label: 'Context compress', description: 'Actively compress the LLM context history, leaving the displayed conversation history unchanged.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
-    { name: 'context_history_manage', label: 'Context history manage', description: 'List, remove, or summarize entries in the LLM context history without touching the displayed conversation history.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'context_history_manage', label: 'Context history manage', description: 'Inspect, search, restore, or fold LLM context history without touching the displayed conversation history.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'question', label: 'Ask question', description: 'Ask the user for structured option feedback.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'skill_download', label: 'Skill download', description: 'Download and install a skill.', category: 'agent', defaultEnabled: true },
     { name: 'skill', label: 'Skill', description: 'Search enabled skill metadata or load one skill body on demand.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },