newmark-agent 0.3.10 → 0.3.12

package/dist/core/agent.d.ts

@@ -33,6 +33,7 @@ export interface AgentRuntimeOptions {
     actorId?: string;
     conversationId?: string;
     runtimeLifecycleRole?: RuntimeLifecycleRole;
+    readOnlyConfig?: boolean;
     linkedPlanAccess?: {
         get(conversationId?: string): LinkedPlanState;
         update(markdown: string, expectedRevision: number, actorId: string, conversationId?: string): LinkedPlanState;
@@ -487,7 +488,7 @@ export declare class Agent {
     private normalizeConversationChatMessages;
     persistGuideMessage(clientMessageId: string, content: string, runId?: string, historyContent?: unknown, attachments?: ConversationImageAttachment[], guideId?: string): boolean;
     setConversationWorkRunExpanded(runId: string, expanded: boolean): boolean;
-    finishConversationWorkRun(runId: string, status: Exclude<ConversationWorkRunStatus, 'running'>, endedAt?: string): boolean;
+    finishConversationWorkRun(runId: string, status: Exclude<ConversationWorkRunStatus, 'running'>, endedAt?: string, errorMessage?: string): boolean;
     private ensureCompletedWorkRunFinalResult;
     emitWorkEvent(input: Omit<AgentWorkEvent, 'id' | 'conversationId' | 'mode' | 'model' | 'timestamp'> & Partial<Pick<AgentWorkEvent, 'conversationId' | 'mode' | 'model' | 'timestamp'>>): AgentWorkEvent;
     appendWorkflowMessage(content: string, toolName?: string, toolArgs?: string, persist?: boolean): void;
@@ -598,6 +599,7 @@ export declare class Agent {
     private applyWorkspaceContext;
     selectWorkspace(id: string): WorkspaceInfo | null;
     selectWorkspaceFromStorage(id: string): WorkspaceInfo | null;
+    refreshWorkspaceRegistryFromStorage(): WorkspaceInfo | null;
     setConversation(id: string): string;
     setConversationFromStorage(id: string): string;
     persistActiveConversationSelection(id: string, ws?: WorkspaceInfo | null): string;
@@ -688,9 +690,20 @@ export declare class Agent {
     claimGoalContinuationMessage(options?: {
         force?: boolean;
     }): AgentPromptMessage | null;
+    private buildSessionArchive;
     private writeSessionArchive;
+    private writeSessionArchiveAsync;
     archiveSession(): string;
     archiveConversation(conversationId: string): string | null;
+    /**
+     * Non-blocking archive writer used by the desktop IPC path. The conversation
+     * state merge remains synchronous and lock-protected, but the potentially
+     * large markdown payload and manifest use promise-based filesystem I/O so
+     * independent workspaces can archive in parallel without freezing Electron.
+     */
+    archiveConversationAsync(conversationId: string): Promise<string | null>;
+    private archiveConversationAsyncUnlocked;
+    private finalizeAsyncConversationArchive;
     private listStoredConversationIds;
     listArchives(scope?: 'workspace' | 'all'): Array<{
         id: string;
@@ -743,7 +756,9 @@ export declare class Agent {
     switchToFallbackModel(errorText?: string): string | null;
     isLlmErrorText(text: string): boolean;
     private scopedSwitchModels;
-    validateModels(selectedNames?: string[]): Promise<ModelValidationResult[]>;
+    validateModels(selectedNames?: string[], options?: {
+        persist?: boolean;
+    }): Promise<ModelValidationResult[]>;
     isModelValidationRunning(): boolean;
     modelValidationStatus(): ModelValidationProgress;
     private runModelValidation;
@@ -825,7 +840,7 @@ export declare class Agent {
     handleSkillDownload(args: string): Promise<void>;
     refreshSkills(): void;
     private processOpencode;
-    maybeCompress(msgs: Array<Record<string, unknown>>, provider?: LLMProvider | null, signal?: AbortSignal, compressionModel?: string, force?: boolean): Promise<void>;
+    maybeCompress(msgs: Array<Record<string, unknown>>, provider?: LLMProvider | null, signal?: AbortSignal, compressionModel?: string, force?: boolean): Promise<boolean>;
     private buildCompressionSummary;
     private localCompressionSummary;
     private latestUserHistoryText;

package/dist/core/agent.js

@@ -292,7 +292,7 @@ class Agent {
         this.subagentName = options.subagentName || '';
         this.subagentPrompt = options.subagentPrompt || '';
         this.linkedPlanAccess = options.linkedPlanAccess;
-        this.config = new config_1.ConfigManager(rootPath);
+        this.config = new config_1.ConfigManager(rootPath, { readOnly: options.readOnlyConfig === true });
         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')
@@ -763,7 +763,12 @@ class Agent {
         }
         const previousAuto = this.model === 'auto' ? this.resolvedDeployment : null;
         const qualified = parseDeploymentSelectionValue(requested);
-        const current = qualified ? this.config.findDeployment(qualified) : (requested ? this.config.findModel(requested) : undefined);
+        const legacyQualified = requested.includes('/')
+            ? this.config.allModels().filter(model => `${model.provider_id}/${model.name}` === requested || `${model.provider}/${model.name}` === requested)
+            : [];
+        const current = qualified
+            ? this.config.findDeployment(qualified)
+            : (legacyQualified.length === 1 ? legacyQualified[0] : (requested ? this.config.findModel(requested) : undefined));
         this.model = current?.name || requested;
         this.fixedDeployment = current ? this.deploymentRef(current) : qualified;
         this.resolvedDeployment = null;
@@ -2062,7 +2067,7 @@ class Agent {
         this.saveWorkspaceConversationState(true);
         return true;
     }
-    finishConversationWorkRun(runId, status, endedAt = this.nowIso()) {
+    finishConversationWorkRun(runId, status, endedAt = this.nowIso(), errorMessage = '') {
         const run = this.workRuns.find(item => item.runId === String(runId || ''));
         if (!run)
             return false;
@@ -2110,7 +2115,9 @@ class Agent {
         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.',
+            content: status === 'error'
+                ? (String(errorMessage || '').trim() || 'Agent run failed.')
+                : status === 'force_interrupted' ? 'Force interrupted.' : status === 'interrupted' ? 'Interrupted.' : 'Response complete.',
             status,
             runId: run.runId,
             conversationId: run.target.conversationId,
@@ -2281,6 +2288,12 @@ class Agent {
         this.awaitingAgentKernelRuntime = false;
         if (!runtime)
             return;
+        // A user stop can arrive while the Native Kernel is still being loaded or
+        // assembling its first context. In that handoff window
+        // abortActiveKernelRun() can only abort the outer process signal; make a
+        // runtime that attaches afterwards observe the already-aborted state too.
+        if (this.activeProcessAbortController?.signal.aborted)
+            runtime.abort?.();
         const queued = this.pendingAgentKernelQueue.splice(0);
         for (const item of queued) {
             const accepted = this.forwardAgentKernelQueueMessage(item.content, item.queueMode, item.clientMessageId, item.runId, item.images, item.hiddenUserInput);
@@ -3595,6 +3608,28 @@ class Agent {
         this.loadWorkspaceConversationState();
         return selected;
     }
+    refreshWorkspaceRegistryFromStorage() {
+        const before = JSON.stringify({
+            internal: this.workspace.internal,
+            external: this.workspace.external,
+            current: this.workspace.current,
+        });
+        const selected = this.workspace.reloadFromStorage();
+        const after = JSON.stringify({
+            internal: this.workspace.internal,
+            external: this.workspace.external,
+            current: this.workspace.current,
+        });
+        if (before === after)
+            return selected;
+        if (selected)
+            this.config.loadWorkspaceConfig(selected.path);
+        else
+            this.config.clearWorkspaceOverrides();
+        this.workspaceConversations.clear();
+        this.loadWorkspaceConversationState();
+        return selected;
+    }
     setConversation(id) {
         const clean = this.safeConversationId(id || 'default');
         // Conversation runners may bind a target workspace directly before their
@@ -4663,29 +4698,52 @@ class Agent {
         this.saveWorkspaceConversationState(true);
         return { text, hiddenUserInput: true, goalContinuation: true };
     }
-    writeSessionArchive(messages, mode, model) {
+    buildSessionArchive(messages, mode, model, archiveDir) {
         const stamp = new Date().toISOString().replace(/[:.]/g, '').replace('T', '_').replace('Z', '');
-        const archiveDir = this.archiveDir();
-        fs.mkdirSync(archiveDir, { recursive: true });
-        const filename = `session_${stamp}.md`;
-        const outPath = path.join(archiveDir, filename);
-        let md = `# Newmark Session — ${stamp}\n\n`;
-        md += `**Mode**: ${mode}\n**Model**: ${model}\n`;
-        md += `**Messages**: ${messages.length}\n\n---\n\n`;
+        // Millisecond-only names collide when a user clicks several archive
+        // buttons in one event-loop turn. Keep the readable timestamp and add a
+        // cryptographic suffix so every request owns an independent file.
+        const filename = `session_${stamp}_${crypto.randomUUID().slice(0, 8)}.md`;
+        let markdown = `# Newmark Session — ${stamp}\n\n`;
+        markdown += `**Mode**: ${mode}\n**Model**: ${model}\n`;
+        markdown += `**Messages**: ${messages.length}\n\n---\n\n`;
         if (this.goal)
-            md += `**Goal**: ${this.goal.objective}\n\n`;
+            markdown += `**Goal**: ${this.goal.objective}\n\n`;
         for (const msg of messages) {
-            md += `**[${msg.role}] ${msg.timestamp}**\n\n${msg.content}\n\n`;
+            markdown += `**[${msg.role}] ${msg.timestamp}**\n\n${msg.content}\n\n`;
             for (const attachment of (0, conversationAttachments_1.hydrateConversationImageAttachments)(this.rootPath, msg.attachments)) {
                 const archived = (0, conversationAttachments_1.archiveConversationImageAttachment)(this.rootPath, archiveDir, attachment);
                 if (!archived)
                     continue;
                 const alt = archived.name.replace(/[\]\r\n]/g, ' ').trim() || 'Submitted image';
-                md += `![${alt}](${archived.relativePath})\n\n`;
+                markdown += `![${alt}](${archived.relativePath})\n\n`;
             }
         }
-        fs.writeFileSync(outPath, md, 'utf-8');
-        return filename;
+        return { filename, markdown };
+    }
+    writeSessionArchive(messages, mode, model) {
+        const archiveDir = this.archiveDir();
+        fs.mkdirSync(archiveDir, { recursive: true });
+        const archive = this.buildSessionArchive(messages, mode, model, archiveDir);
+        fs.writeFileSync(path.join(archiveDir, archive.filename), archive.markdown, 'utf-8');
+        return archive.filename;
+    }
+    async writeSessionArchiveAsync(messages, mode, model, archiveDir = this.archiveDir()) {
+        const archive = this.buildSessionArchive(messages, mode, model, archiveDir);
+        await fs.promises.mkdir(archiveDir, { recursive: true });
+        const outPath = path.join(archiveDir, archive.filename);
+        const tempPath = `${outPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        try {
+            await fs.promises.writeFile(tempPath, archive.markdown, 'utf-8');
+            await fs.promises.rename(tempPath, outPath);
+        }
+        finally {
+            try {
+                await fs.promises.unlink(tempPath);
+            }
+            catch { }
+        }
+        return archive.filename;
     }
     archiveSession() {
         return this.writeSessionArchive(this.chatMessages, this.modeName(), this.model);
@@ -4759,6 +4817,111 @@ class Agent {
         }
         return filename;
     }
+    /**
+     * Non-blocking archive writer used by the desktop IPC path. The conversation
+     * state merge remains synchronous and lock-protected, but the potentially
+     * large markdown payload and manifest use promise-based filesystem I/O so
+     * independent workspaces can archive in parallel without freezing Electron.
+     */
+    async archiveConversationAsync(conversationId) {
+        // Archive payloads intentionally start in parallel. The final state
+        // mutation below operates on the latest locked disk snapshot, so no
+        // JavaScript queue is needed for independent targets in one workspace.
+        return await this.archiveConversationAsyncUnlocked(conversationId);
+    }
+    async archiveConversationAsyncUnlocked(conversationId) {
+        const ws = this.workspace.current;
+        if (!ws)
+            return null;
+        const clean = this.safeConversationId(conversationId || 'default');
+        const stateKey = this.workspaceConversationStateKey(clean);
+        if (!stateKey)
+            return null;
+        const memoryKey = `${ws.isInternal ? 'internal' : 'external'}:${path.resolve(ws.path)}::conversation:${clean}`;
+        const archiveDir = path.join(ws.path, 'archive');
+        const workspacePrefix = this.workspaceConversationPrefix() || '';
+        const archiveMode = this.modeName();
+        const archiveModel = this.model;
+        // readStoredConversationState returns a cache object. Clone it before any
+        // asynchronous gap so concurrent archive requests cannot mutate one
+        // another's source snapshot.
+        const cachedStored = this.readStoredConversationState(ws);
+        const stored = JSON.parse(JSON.stringify(cachedStored || {}));
+        const persisted = stored.conversations?.[stateKey];
+        if (persisted)
+            this.normalizeConversationTree(persisted);
+        const memory = this.workspaceConversations.get(memoryKey);
+        const persistedMessagesAvailable = persisted?.chatMessages !== undefined;
+        const sourceMessages = persisted?.chatMessages ?? memory?.chatMessages ?? [];
+        const sourceHistory = persistedMessagesAvailable
+            ? (persisted?.history ?? [])
+            : (memory?.history ?? persisted?.history ?? []);
+        const messages = this.normalizeConversationChatMessages(sourceMessages, sourceHistory);
+        const filename = await this.writeSessionArchiveAsync(messages, archiveMode, archiveModel, archiveDir);
+        const archiveEntry = persisted ? JSON.parse(JSON.stringify(persisted)) : {
+            title: this.titleFromMessages(messages, clean),
+            chatMessages: messages,
+            history: sourceHistory,
+            plan: memory?.plan,
+            linkedPlan: memory?.linkedPlan,
+            subagentState: memory?.subagentState,
+            workRuns: memory?.workRuns,
+            continuations: memory?.continuations,
+            updatedAt: new Date().toISOString(),
+        };
+        const manifest = {
+            version: 2,
+            kind: 'newmark-conversation-archive',
+            archivedAt: new Date().toISOString(),
+            conversationId: clean,
+            workspaceId: ws.id,
+            workspaceName: ws.name,
+            workspacePath: ws.path,
+            workspaceInternal: ws.isInternal,
+            statePrefix: workspacePrefix,
+            entry: this.conversationEntryForDisk(archiveEntry),
+        };
+        const manifestPath = this.archiveManifestPath(path.join(archiveDir, filename));
+        const manifestTempPath = `${manifestPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        try {
+            await fs.promises.writeFile(manifestTempPath, JSON.stringify(manifest, null, 2), 'utf-8');
+            await fs.promises.rename(manifestTempPath, manifestPath);
+        }
+        finally {
+            try {
+                await fs.promises.unlink(manifestTempPath);
+            }
+            catch { }
+        }
+        this.finalizeAsyncConversationArchive(clean, stateKey, memoryKey, ws);
+        return filename;
+    }
+    finalizeAsyncConversationArchive(clean, stateKey, memoryKey, ws) {
+        let nextActiveId = '';
+        this.mutateStoredConversationState(ws, latest => {
+            latest.conversations = latest.conversations || {};
+            delete latest.conversations[stateKey];
+            // Derive the target prefix from the captured state key rather than the
+            // Agent's possibly changed foreground workspace.
+            const prefix = stateKey.slice(0, Math.max(0, stateKey.length - clean.length - 1)) + '-';
+            const remaining = Object.keys(latest.conversations)
+                .filter(key => !prefix || key.startsWith(prefix))
+                .map(key => key.slice(prefix.length))
+                .filter(Boolean);
+            const currentActiveId = this.safeConversationId(latest.activeConversationId || this.activeConversationId || 'default');
+            if (clean === currentActiveId)
+                latest.activeConversationId = remaining[0] || 'default';
+            nextActiveId = latest.activeConversationId || remaining[0] || 'default';
+            return latest;
+        });
+        this.workspaceConversations.delete(memoryKey);
+        const duplicateMemoryKey = `${ws.isInternal ? 'internal' : 'external'}:${path.resolve(ws.path)}::conversation:${clean}`;
+        this.workspaceConversations.delete(duplicateMemoryKey);
+        if (clean === this.safeConversationId(this.activeConversationId || 'default')) {
+            this.activeConversationId = nextActiveId || 'default';
+            this.loadWorkspaceConversationState();
+        }
+    }
     listStoredConversationIds(stored) {
         const prefix = `${this.workspaceConversationPrefix() || ''}-`;
         return Object.keys(stored.conversations || {})
@@ -5393,10 +5556,10 @@ class Agent {
         const provider = this.config.findProvider(providerId);
         return all.filter(m => m.provider_id === (provider?.id || providerId));
     }
-    async validateModels(selectedNames) {
+    async validateModels(selectedNames, options = {}) {
         if (this.modelValidationPromise)
             return this.modelValidationPromise;
-        const validation = this.runModelValidation(selectedNames);
+        const validation = this.runModelValidation(selectedNames, options.persist !== false);
         this.modelValidationPromise = validation;
         try {
             return await validation;
@@ -5416,7 +5579,7 @@ class Agent {
             recentChecks: this.modelValidationProgress.recentChecks.map(item => ({ ...item })),
         };
     }
-    async runModelValidation(selectedNames) {
+    async runModelValidation(selectedNames, persist = true) {
         const selectedModels = this.config.modelsForSelections(selectedNames);
         if (!selectedModels.length) {
             this.modelValidationProgress = {
@@ -5427,7 +5590,10 @@ class Agent {
         }
         const results = [];
         const catalogByProvider = new Map();
-        const cache = new modelValidationStore_1.FileModelValidationCache(this.rootPath);
+        // Read-only CLI validation may reuse already persisted, redacted evidence
+        // without rewriting it. This keeps the no-mutation contract while making
+        // repeated release/user checks local when the seven-day record is fresh.
+        const cache = new modelValidationStore_1.FileModelValidationCache(this.rootPath, { readOnly: !persist });
         const checksPerModel = 11;
         let currentModel = '';
         let currentModelChecks = 0;
@@ -5568,7 +5734,8 @@ class Agent {
                 completedModels: this.modelValidationProgress.completedModels + 1,
             };
         }
-        this.config.save();
+        if (persist)
+            this.config.save();
         this.modelValidationProgress = {
             ...this.modelValidationProgress,
             running: false,
@@ -5851,7 +6018,14 @@ class Agent {
             const text = typeof input === 'string' ? input : String(input.text || '');
             const inputEnvelope = typeof input === 'string' ? null : input;
             const hiddenUserInput = inputEnvelope?.hiddenUserInput === true;
-            this.ensureUsableModelSelection();
+            // An empty selection may be repaired to the configured default, but an
+            // explicitly requested fixed model must remain visible to the
+            // fail-closed availability check below. Otherwise a typo such as
+            // provider-that-does-not-exist/missing-model silently becomes the first
+            // configured fixture/default deployment.
+            const explicitFixedModel = this.model !== '' && this.model !== 'auto';
+            if (!explicitFixedModel)
+                this.ensureUsableModelSelection();
             const clientMessageId = String(inputEnvelope?.clientMessageId || '').trim();
             const inputRunId = String(inputEnvelope?.runId || this.activeWorkRunId || '').trim();
             const rawImages = typeof input === 'string' ? [] : (Array.isArray(input.images) ? input.images : []);
@@ -5949,7 +6123,16 @@ class Agent {
                 await this.evaluateAndSwitch(displayText, inputEnvelope?.routePolicy);
             }
             if (this.model && this.modelIsUnavailable(this.model)) {
+                const requestedModel = this.model;
                 this.switchToFallbackModel();
+                if (this.modelIsUnavailable(this.model)) {
+                    const message = `[Error] Model '${requestedModel || 'unknown'}' is unavailable or not configured. Select a configured model or enable a valid provider before sending.`;
+                    this.status = 'error';
+                    // Do not return an error token as if it were a successful assistant
+                    // response. The normal catch/finalizer path must publish an error
+                    // terminal event and keep the work run out of completed state.
+                    throw new Error(message);
+                }
             }
             // Use external opencode CLI engine
             if (this.engine === 'opencode') {
@@ -7059,13 +7242,13 @@ class Agent {
     }
     async maybeCompress(msgs, provider, signal, compressionModel, force = false) {
         if (signal?.aborted)
-            return;
+            return false;
         if (!this.config.getBool('context', 'auto_compress'))
-            return;
+            return false;
         const total = msgs.reduce((sum, m) => sum + (typeof m.content === 'string' ? m.content.length : JSON.stringify(m.content || '').length), 0);
         const budget = this.compressionBudget(msgs);
         if (budget.estimatedTokens < budget.triggerTokens && !force)
-            return;
+            return false;
         if (!force && this.lastCompression && String(msgs[0]?.content || '').includes(this.lastCompression.summary)) {
             const baselineChars = Math.max(0, Number(this.lastCompression.compressedChars || 0));
             const baselineTokens = Math.max(0, Number(this.lastCompression.compressedTokens || 0));
@@ -7074,12 +7257,12 @@ class Agent {
             const minCharGrowth = Math.max(12_000, Math.floor(baselineChars * 0.25));
             const minTokenGrowth = Math.max(1_024, Math.floor(budget.triggerTokens * 0.2));
             if (charGrowth < minCharGrowth && tokenGrowth < minTokenGrowth)
-                return;
+                return false;
         }
         const originalMessageCount = msgs.length;
         const configuredKeepLast = this.config.getNum('context', 'keep_recent_messages') || 10;
         if (msgs.length <= 1)
-            return;
+            return false;
         // Reserve room for the one-time post-compression continuation anchor so
         // adding it cannot push a near-limit request back over the target budget.
         const continuationAnchorTokens = this.estimateContextTokens([this.postCompressionContinuationMessage()]);
@@ -7087,7 +7270,7 @@ class Agent {
         const recent = this.recentContextSuffix(msgs, configuredKeepLast, recentBudget);
         const recentStart = Math.max(0, msgs.length - recent.length);
         if (recentStart <= 0)
-            return;
+            return false;
         // The first history item is usually the first user task, not foundational
         // context. Keeping it forever makes an old task more salient after every
         // compaction. Foundational rules are rebuilt by buildSystemPrompt(); the
@@ -7096,7 +7279,7 @@ class Agent {
         const currentInstruction = this.latestUserHistoryText(recent);
         const compression = await this.buildCompressionSummary(middle, total, budget, provider, signal, compressionModel || this.activeModelName(), currentInstruction);
         if (signal?.aborted)
-            return;
+            return false;
         const compressed = [{
                 role: 'system',
                 content: compression.summary,
@@ -7123,6 +7306,7 @@ class Agent {
         };
         this.pushCompressionCacheEntry(compression.summary, middle, compression.model, compression.fallback);
         this.persistCompressedHistory(compression.summary, recent.length, msgs);
+        return true;
     }
     async buildCompressionSummary(middle, totalChars, budget, provider, signal, compressionModel, currentInstruction = '') {
         const workspacePath = this.workspace.current?.path || this.rootPath;
@@ -8045,10 +8229,28 @@ class GoalStateImpl {
         return s;
     }
     checkComplete(response) {
-        const lower = response.toLowerCase();
-        return lower.includes('goal complete') || lower.includes('objective achieved')
-            || lower.includes('task finished') || lower.includes('all done')
-            || lower.includes('goal accomplished');
+        const lines = String(response || '').replace(/\r\n?/g, '\n').split('\n');
+        const completionMarkers = '(?:goal\\s+complete|objective\\s+achieved|task\\s+finished|all\\s+done|goal\\s+accomplished)';
+        const explicitLinePatterns = [
+            new RegExp(`^\\s*(?:[*#_~\\-]+\\s*)*(?:\\[\\s*)?${completionMarkers}(?:\\s*\\])?(?=\\s|[!.,:;]|$)`, 'i'),
+            /^\s*(?:[*#_~\-]+\s*)*(?:i|we)\s+(?:have\s+)?(?:now\s+)?(?:fully\s+)?(?:completed|finished|achieved|accomplished)\s+(?:the\s+)?(?:goal|objective|task)\b/i,
+            /^\s*(?:[*#_~\-]+\s*)*(?:the\s+)?(?:goal|objective|task)\s+(?:is|was)\s+(?:now\s+)?(?:complete|achieved|finished|accomplished)\b/i,
+        ];
+        const completionContext = new RegExp(completionMarkers, 'i');
+        const deferredBefore = new RegExp(`\\b(?:must|will|should|would|can|could)\\s+(?:still\\s+)?(?:contain(?:s|ed)?|include(?:s|d)?|say|state|use|write|appear)\\b.{0,180}${completionMarkers}`, 'i');
+        const negatedBefore = new RegExp(`\\b(?:not|isn't|is not|never|don't|do not|won't|will not)\\b.{0,180}${completionMarkers}`, 'i');
+        const pendingBefore = new RegExp(`\\b(?:one\\s+step\\s+remains|still\\s+required|one\\s+more\\s+(?:step|call|turn)|not\\s+(?:the\\s+)?final)\\b.{0,180}${completionMarkers}`, 'i');
+        const deferredAfter = new RegExp(`${completionMarkers}.{0,180}\\b(?:not\\s+(?:the\\s+)?final|not\\s+yet|one\\s+more\\s+model\\s+call|next\\s+(?:call|step)|not\\s+done)\\b`, 'i');
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            if (!explicitLinePatterns.some(pattern => pattern.test(line)))
+                continue;
+            const context = lines.slice(Math.max(0, index - 2), Math.min(lines.length, index + 3)).join(' ');
+            if (completionContext.test(context) && (deferredBefore.test(context) || negatedBefore.test(context) || pendingBefore.test(context) || deferredAfter.test(context)))
+                continue;
+            return true;
+        }
+        return false;
     }
 }
 //# sourceMappingURL=agent.js.map

package/dist/core/agentKernelRunner.js

@@ -205,6 +205,9 @@ class ProviderRunError extends Error {
 function kernelTurnFailed(agent, turn) {
     return turn.stopReason === 'error' || agent.isLlmErrorText(turn.text);
 }
+function providerTurnIsEmpty(turn) {
+    return /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
+}
 function removeTrailingFailedAssistant(agent, messages) {
     const last = messages[messages.length - 1];
     if (last?.role !== 'assistant')
@@ -255,17 +258,40 @@ function normalizePublicProviderError(error, secrets = []) {
     }
     return raw.slice(0, 1_200);
 }
+function throwIfKernelAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        reason.name = 'AbortError';
+        throw reason;
+    }
+    const error = new Error(reason ? String(reason) : 'Agent run aborted');
+    error.name = 'AbortError';
+    throw error;
+}
 async function runAgentKernel(agent) {
     const stopContextTimer = (0, performanceDiagnostics_1.performanceTimer)('context_prepare', { conversationId: agent.activeConversationId });
+    const processSignal = agent.activeProcessSignal();
+    if (processSignal?.aborted) {
+        stopContextTimer();
+        throwIfKernelAborted(processSignal);
+    }
     if (!agent.engineModel()) {
+        const message = 'No LLM configured. Add provider in Settings > Models.';
         agent.status = 'error';
         agent.saveWorkspaceConversationState();
-        return [{ type: 'text', text: '[Error] No LLM configured. Add provider in Settings > Models.' }];
+        // A missing provider is a terminal run failure, not a visible assistant
+        // response. Throwing here lets Agent.process and ConversationKernel share
+        // the normal error finalization path, so GUI/TUI/CLI cannot turn this into
+        // a synthetic successful Build with an empty final summary.
+        throw new Error(message);
     }
     const [{ Agent: NativeAgent }, KernelStreamCompat] = await Promise.all([
         import('./agentKernel/index.js'),
         import('./agentKernel/stream-types.js'),
     ]);
+    throwIfKernelAborted(processSignal);
     const toolProvisioning = new ToolProvisionSession([], []);
     let activeToolSurfaceIdentity = '';
     let activeToolSurfaceNotice = '';
@@ -297,6 +323,7 @@ async function runAgentKernel(agent) {
     const initialToolSurface = refreshToolSurface(true);
     const assembledContext = agent.assembleContextV2(initialToolSurface.systemPromptNotice);
     const systemPrompt = assembledContext.text;
+    throwIfKernelAborted(processSignal);
     let providerRequestCount = 0;
     let bootstrappedCompressionAt = agent.lastCompression?.at || '';
     stopContextTimer();
@@ -317,6 +344,28 @@ async function runAgentKernel(agent) {
     kernel.state.tools = toKernelTools(agent, initialToolSurface.definitions, toolProvisioning);
     kernel.state.messages = toKernelMessages(agent);
     agent.attachAgentKernelRuntime(kernel);
+    let detachProcessAbort = () => { };
+    if (processSignal) {
+        const abortKernel = () => kernel.abort();
+        if (processSignal.aborted) {
+            kernel.abort();
+        }
+        else {
+            processSignal.addEventListener('abort', abortKernel, { once: true });
+            detachProcessAbort = () => processSignal.removeEventListener('abort', abortKernel);
+        }
+    }
+    try {
+        // abort() cannot cancel a NativeAgent before its internal run exists. The
+        // explicit check closes the remaining handoff window between attaching the
+        // kernel and entering kernel.prompt().
+        throwIfKernelAborted(processSignal);
+    }
+    catch (error) {
+        detachProcessAbort();
+        agent.attachAgentKernelRuntime(null);
+        throw error;
+    }
     const tokens = [];
     const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
         let lastAssistant = null;
@@ -338,10 +387,14 @@ async function runAgentKernel(agent) {
             }
             await kernel.prompt(promptMessages);
             const assistant = lastAssistant;
+            const text = assistant ? KernelMessageText(assistant) : '';
+            const hasToolCall = !!assistant?.content?.some(content => content.type === 'toolCall');
+            const emptyResponse = !assistant
+                || (!text.trim() && !hasToolCall && String(assistant?.stopReason || '') !== 'aborted');
             return {
-                text: assistant ? KernelMessageText(assistant) : '',
+                text: emptyResponse ? '[Error] Provider returned an empty response.' : text,
                 stopReason: String(assistant?.stopReason || ''),
-                errorMessage: String(assistant?.errorMessage || ''),
+                errorMessage: String(assistant?.errorMessage || (emptyResponse ? 'Provider returned an empty response.' : '')),
             };
         }
         finally {
@@ -380,6 +433,16 @@ async function runAgentKernel(agent) {
         if (modelBeforeKernelRun && modelBeforeKernelRun !== agent.model && !tokens.some(t => t.text?.includes('[Model fallback]'))) {
             tokens.unshift({ type: 'text', text: `[Model fallback] ${modelBeforeKernelRun} unavailable; switched to ${agent.model}.` });
         }
+        let emptyResponseRetries = 0;
+        while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+            removeTrailingFailedAssistant(agent, kernel.state.messages);
+            emptyResponseRetries += 1;
+            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+            tokens.push({ type: 'text', text: notice });
+            agent.recordWorkStatus(notice);
+            await agent.waitForPlannedRouteRetry();
+            lastTurn = await runWithCompressionResume([], false);
+        }
         let routeRetries = 0;
         while (kernelTurnFailed(agent, lastTurn) && routeRetries < 2) {
             const previous = agent.switchToFallbackModel(lastTurn.errorMessage || lastTurn.text);
@@ -416,6 +479,7 @@ async function runAgentKernel(agent) {
         }
     }
     finally {
+        detachProcessAbort();
         agent.attachAgentKernelRuntime(null);
     }
     agent.status = 'idle';
@@ -597,14 +661,12 @@ async function transformContext(agent, messages, signal) {
     // projection so the internal broker call/result and its compact catalog can
     // never be written into conversation state or revived after a reload.
     const newmarkMessages = publicHistoryFromKernelMessages(messages);
-    const beforeCompression = JSON.stringify(newmarkMessages);
     const compressionAt = agent.lastCompression?.at || '';
-    await agent.maybeCompress(newmarkMessages, provider, processSignal, compressionModel);
+    let compressed = await agent.maybeCompress(newmarkMessages, provider, processSignal, compressionModel);
     if (processSignal?.aborted)
         return messages;
-    const primaryCompressed = JSON.stringify(newmarkMessages) !== beforeCompression;
-    if (primaryCompressed && agent.estimateContextTokens(newmarkMessages) >= Math.floor(agent.contextWindow(compressionModel).maxTokens * 0.82)) {
-        await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true);
+    if (compressed && agent.estimateContextTokens(newmarkMessages) >= Math.floor(agent.contextWindow(compressionModel).maxTokens * 0.82)) {
+        compressed = (await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true)) || compressed;
     }
     // Hard safety net: even a conservative worst-case token estimate must never
     // leave a request that could exceed the model's context window. The improved
@@ -614,9 +676,9 @@ async function transformContext(agent, messages, signal) {
     const windowMax = agent.contextWindow(compressionModel).maxTokens;
     const conservativeTokens = agent.estimateContextTokens(newmarkMessages);
     if (conservativeTokens >= Math.floor(windowMax * 0.9) && !processSignal?.aborted) {
-        await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true);
+        compressed = (await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true)) || compressed;
     }
-    if (JSON.stringify(newmarkMessages) === beforeCompression)
+    if (!compressed)
         return messages;
     const durableMessages = toKernelMessagesFromHistory(newmarkMessages, agent);
     if (agent.lastCompression?.at && agent.lastCompression.at !== compressionAt) {