newmark-agent 0.4.5 → 0.4.7

package/dist/core/agent.d.ts

@@ -474,7 +474,9 @@ export declare class Agent {
     private workspaceConversationKey;
     private workspaceConversationStorePath;
     private workspaceConversationStateKey;
+    private workspaceConversationStateKeyFor;
     private workspaceConversationPrefix;
+    private workspaceConversationPrefixFor;
     private safeConversationId;
     subscribeWorkEvents(fn: (event: AgentWorkEvent) => void): () => void;
     subscribePeerWorkEvents(fn: (event: AgentWorkEvent) => void): () => void;
@@ -620,6 +622,30 @@ export declare class Agent {
         order: number;
         branchCommunication: boolean;
     }>;
+    private subagentConcurrencyLimit;
+    /** 当前工作区使用内存中的前台选择；后台工作区从各自持久化状态读取 active id。 */
+    activeConversationIdForWorkspace(ws: WorkspaceInfo | null): string;
+    /**
+     * 持久化的完整 work run 记录（含 interrupted/force_interrupted）。
+     * 不依赖运行时内存（run 结束后内存清空，state 端点曾因此丢失被中断的构建记录），
+     * 供 mobile 端点稳定透出完整对话信息；移动端按同一格式解析。
+     */
+    getPersistedConversationWorkRuns(conversationId: string, ws?: WorkspaceInfo | null): ConversationWorkRun[];
+    /** Exact membership check against the raw persisted state key, before UI content deduplication. */
+    hasConversationInWorkspace(conversationId: string, ws: WorkspaceInfo | null): boolean;
+    /** 按工作区列对话（任意 ws，key 前缀 = kind-sha256(path).slice(0,16)）；供 mobile API 透出工作区从属对话 */
+    listWorkspaceConversationStates(ws: WorkspaceInfo | null): Array<{
+        id: string;
+        key: string;
+        title: string;
+        messageCount: number;
+        historyCount: number;
+        updatedAt: string;
+        pinned: boolean;
+        pinnedAt: string;
+        order: number;
+        branchCommunication: boolean;
+    }>;
     private normalizeLinkedPlan;
     private subagentManagerKey;
     private bindConversationSubagents;
@@ -632,6 +658,7 @@ export declare class Agent {
     getConversationSnapshot(conversationId?: string, options?: {
         window?: number;
         before?: number;
+        workspace?: WorkspaceInfo | null;
     }): ConversationSnapshot;
     inspectConversationBranch(conversationId: string, branchId: string, branchGroupId?: string): ConversationSnapshot;
     ensureConversationSnapshot(conversationId?: string): ConversationSnapshot;
@@ -640,8 +667,13 @@ export declare class Agent {
     setBranchCommunication(enabled: boolean): boolean;
     isBranchCommunicationEnabled(): boolean;
     switchConversationBranch(conversationId: string, branchId: string, branchGroupId?: string): ConversationSnapshot;
-    setConversationPinned(id: string, pinned: boolean): boolean;
-    renameConversation(id: string, title: string): boolean;
+    setConversationPinned(id: string, pinned: boolean, ws?: WorkspaceInfo | null): boolean;
+    renameConversation(id: string, title: string, ws?: WorkspaceInfo | null): boolean;
+    /** 为指定工作区创建空白对话，不临时切换全局前台工作区。 */
+    createConversationInWorkspace(ws: WorkspaceInfo, title?: string): {
+        id: string;
+        title: string;
+    };
     /**
      * 首 Build 命名判定：仅当 (1) 当前对话尚无历史 Build（排除当前 run）且
      * (2) 其持久化 title 仍是自动生成（含为空）时返回 true。dev-0.4.3 起不再
@@ -675,6 +707,8 @@ export declare class Agent {
      */
     private maybeAutoRenameConversationFromRun;
     reorderConversations(ids: string[]): boolean;
+    /** Reorder one pinned group inside an explicit workspace without changing membership. */
+    reorderWorkspaceConversationGroup(ids: string[], ws: WorkspaceInfo | null): boolean;
     flushConversationState(): void;
     private titleFromMessages;
     private hasUserConversationTitle;
@@ -892,7 +926,7 @@ export declare class Agent {
      * 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>;
+    archiveConversationAsync(conversationId: string, ws?: WorkspaceInfo | null): Promise<string | null>;
     private archiveConversationAsyncUnlocked;
     private finalizeAsyncConversationArchive;
     private listStoredConversationIds;
@@ -997,7 +1031,7 @@ export declare class Agent {
     private withTimeout;
     private normalizeSubagentModelSelection;
     handleSubagent(args: string): Promise<string>;
-    handleSubagentEnvelope(args: string): Promise<NewmarkSubagentToolResult>;
+    handleSubagentEnvelope(args: string, requireRunningBuild?: boolean): Promise<NewmarkSubagentToolResult>;
     private resolveSubagentPreset;
     private buildSubagentPrompt;
     handleSubagentContinue(args: string): Promise<string>;

package/dist/core/agent.js

@@ -380,7 +380,7 @@ class Agent {
         this.tools = new index_1.ToolExecutor(rootPath, this.config, this.ssh, this.workspace);
         this.skills = new skills_1.SkillsManager(rootPath);
         this.memoryLab = new memoryLab_1.MemoryLabManager(rootPath, this.config.getStr('general', 'language'));
-        this.subagents = new subagent_1.SubagentManager({ rootAgentId: this.runtimeActorId });
+        this.subagents = new subagent_1.SubagentManager({ rootAgentId: this.runtimeActorId, concurrency: this.subagentConcurrencyLimit() });
         if (this.mode === 'goal' && !this.goal) {
             this.goal = new GoalStateImpl('Set your objective');
         }
@@ -925,6 +925,7 @@ class Agent {
     }
     setIntelligence(tier, persist = false) {
         this.intelligence = normalizeIntelligenceTier(tier);
+        this.subagents?.setConcurrencyLimit(this.subagentConcurrencyLimit());
         if (persist) {
             this.config.set('models', 'default_intelligence', this.intelligence);
             this.config.save();
@@ -1158,13 +1159,18 @@ class Agent {
         return path.join(ws.path, 'conversations', 'state.json');
     }
     workspaceConversationStateKey(conversationId = this.activeConversationId) {
-        const prefix = this.workspaceConversationPrefix();
+        return this.workspaceConversationStateKeyFor(conversationId, this.workspace.current);
+    }
+    workspaceConversationStateKeyFor(conversationId, ws) {
+        const prefix = this.workspaceConversationPrefixFor(ws);
         if (!prefix)
             return null;
         return `${prefix}-${this.safeConversationId(conversationId)}`;
     }
     workspaceConversationPrefix() {
-        const ws = this.workspace.current;
+        return this.workspaceConversationPrefixFor(this.workspace.current);
+    }
+    workspaceConversationPrefixFor(ws) {
         if (!ws)
             return null;
         const supplied = String(ws.conversationStatePrefix || '').trim();
@@ -2851,8 +2857,54 @@ class Agent {
         }
     }
     listConversationStates() {
-        const stored = this.readStoredConversationState();
-        const prefix = this.workspaceConversationPrefix() || '';
+        return this.listWorkspaceConversationStates(this.workspace.current);
+    }
+    subagentConcurrencyLimit() {
+        return this.intelligence === 'ultra' ? 16 : 4;
+    }
+    /** 当前工作区使用内存中的前台选择；后台工作区从各自持久化状态读取 active id。 */
+    activeConversationIdForWorkspace(ws) {
+        const targetWs = ws || this.workspace.current;
+        if (!targetWs)
+            return 'default';
+        const currentWs = this.workspace.current;
+        const isCurrent = !!currentWs && path.resolve(currentWs.path) === path.resolve(targetWs.path);
+        if (isCurrent)
+            return this.safeConversationId(this.activeConversationId || 'default');
+        const stored = this.readStoredConversationState(targetWs);
+        return this.safeConversationId(stored.activeConversationId || 'default');
+    }
+    /**
+     * 持久化的完整 work run 记录（含 interrupted/force_interrupted）。
+     * 不依赖运行时内存（run 结束后内存清空，state 端点曾因此丢失被中断的构建记录），
+     * 供 mobile 端点稳定透出完整对话信息；移动端按同一格式解析。
+     */
+    getPersistedConversationWorkRuns(conversationId, ws = null) {
+        const targetWs = ws || this.workspace.current;
+        const clean = this.safeConversationId(conversationId || 'default');
+        const stateKey = this.workspaceConversationStateKeyFor(clean, targetWs);
+        const stored = this.readStoredConversationState(targetWs);
+        const persisted = stateKey && stored.conversations ? stored.conversations[stateKey] : undefined;
+        const tree = persisted ? this.normalizeConversationTree(persisted) : null;
+        const runtimeNodeId = String(tree?.activeNodeId || '');
+        const viewedNodeId = tree
+            ? this.resolveConversationTreePath(tree, this.storedConversationTreePath(tree, persisted?.viewedBranchNodePath, runtimeNodeId))
+            : '';
+        const viewedNode = tree?.nodes[viewedNodeId];
+        return this.normalizeWorkRuns(viewedNode?.workRuns || persisted?.workRuns);
+    }
+    /** Exact membership check against the raw persisted state key, before UI content deduplication. */
+    hasConversationInWorkspace(conversationId, ws) {
+        const targetWs = ws || this.workspace.current;
+        const stateKey = this.workspaceConversationStateKeyFor(this.safeConversationId(conversationId || 'default'), targetWs);
+        if (!stateKey)
+            return false;
+        return Object.prototype.hasOwnProperty.call(this.readStoredConversationState(targetWs).conversations || {}, stateKey);
+    }
+    /** 按工作区列对话（任意 ws，key 前缀 = kind-sha256(path).slice(0,16)）；供 mobile API 透出工作区从属对话 */
+    listWorkspaceConversationStates(ws) {
+        const stored = this.readStoredConversationState(ws);
+        const prefix = this.workspaceConversationPrefixFor(ws) || '';
         const scopedEntries = Object.entries(stored.conversations || {}).filter(([key]) => !prefix || key.startsWith(prefix));
         if (scopedEntries.some(([, value]) => !Number.isFinite(value.order))) {
             const legacyOrder = [...scopedEntries].sort(([, a], [, b]) => {
@@ -2863,7 +2915,7 @@ class Agent {
                 return String(b.updatedAt || '').localeCompare(String(a.updatedAt || ''));
             });
             legacyOrder.forEach(([, value], index) => { value.order = index; });
-            this.writeStoredConversationState(stored);
+            this.writeStoredConversationState(stored, ws);
         }
         const rows = [];
         for (const [key, value] of Object.entries(stored.conversations || {})) {
@@ -2922,6 +2974,7 @@ class Agent {
         this.subagents = (0, subagent_1.sharedSubagentManager)(this.subagentManagerKey(clean), {
             conversationId: clean,
             rootAgentId: state?.rootAgentId || this.runtimeActorId,
+            concurrency: this.subagentConcurrencyLimit(),
             state,
             executor: job => this.runSubagentJob(job.record.id, job.prompt, job.flowName, job.reason),
             persist: subagentState => this.persistSubagentState(clean, subagentState),
@@ -2995,16 +3048,18 @@ class Agent {
     }
     getConversationSnapshot(conversationId = this.activeConversationId, options = {}) {
         const clean = this.safeConversationId(conversationId || 'default');
-        const isActiveConversation = clean === this.safeConversationId(this.activeConversationId || 'default');
-        const stateKey = this.workspaceConversationStateKey(clean);
-        const memoryKey = (() => {
-            const ws = this.workspace.current;
-            if (!ws)
-                return null;
-            return `${ws.isInternal ? 'internal' : 'external'}:${path.resolve(ws.path)}::conversation:${clean}`;
-        })();
+        const ws = options.workspace || this.workspace.current;
+        const currentWs = this.workspace.current;
+        const isActiveWorkspace = (!ws && !currentWs)
+            || (!!ws && !!currentWs && path.resolve(ws.path) === path.resolve(currentWs.path));
+        const isActiveConversation = isActiveWorkspace
+            && clean === this.safeConversationId(this.activeConversationId || 'default');
+        const stateKey = this.workspaceConversationStateKeyFor(clean, ws);
+        const memoryKey = ws
+            ? `${ws.isInternal ? 'internal' : 'external'}:${path.resolve(ws.path)}::conversation:${clean}`
+            : null;
         const memory = memoryKey ? this.workspaceConversations.get(memoryKey) : undefined;
-        const stored = this.readStoredConversationState();
+        const stored = this.readStoredConversationState(ws);
         const persisted = stateKey && stored.conversations ? stored.conversations[stateKey] : undefined;
         const tree = persisted ? this.normalizeConversationTree(persisted) : null;
         const runtimeNodeId = String(tree?.activeNodeId || '');
@@ -3039,7 +3094,7 @@ class Agent {
         const continuations = this.normalizeContinuations(isActiveConversation && viewingRuntimeNode ? this.continuations : (viewedNode?.continuations || persisted?.continuations || memory?.continuations));
         return {
             conversationId: clean,
-            conversations: this.listConversationStates(),
+            conversations: this.listWorkspaceConversationStates(ws),
             conversationPlan: this.normalizeConversationPlan(isActiveConversation ? this.conversationPlan : (persisted?.plan || memory?.plan)),
             linkedPlan: this.normalizeLinkedPlan(isActiveConversation ? this.linkedPlan : (persisted?.linkedPlan || memory?.linkedPlan)),
             subagents: this.recordsForState(isActiveConversation ? this.subagents.serialize() : (persisted?.subagentState || memory?.subagentState)),
@@ -3051,11 +3106,11 @@ class Agent {
             continuations,
             modelSelection: isActiveConversation
                 ? this.currentConversationModelSelection()
-                : (persisted?.modelSelection || memory?.modelSelection || this.currentConversationModelSelection()),
+                : (persisted?.modelSelection || memory?.modelSelection || { kind: 'auto' }),
             flowSelection: isActiveConversation
                 ? this.currentConversationFlowSelection()
                 : (persisted?.flowSelection || memory?.flowSelection || null),
-            inputMode: this.inputMode,
+            inputMode: isActiveConversation ? this.inputMode : (persisted?.inputMode || memory?.inputMode || 'guide'),
             mode: isActiveConversation ? this.mode : (persisted?.mode || memory?.mode || 'build'),
             goal: isActiveConversation ? this.serializeGoal() : (persisted?.goal || memory?.goal || null),
             branches: this.branchGroupMetadata(tree),
@@ -3388,13 +3443,19 @@ class Agent {
             this.setConversationFromStorage(clean);
         return this.getConversationSnapshot(clean);
     }
-    setConversationPinned(id, pinned) {
+    setConversationPinned(id, pinned, ws = this.workspace.current) {
+        const targetWs = ws || this.workspace.current;
+        if (!targetWs)
+            return false;
         const clean = this.safeConversationId(id || 'default');
-        this.saveWorkspaceConversationState();
-        const stateKey = this.workspaceConversationStateKey(clean);
+        const currentWs = this.workspace.current;
+        const isCurrent = !!currentWs && path.resolve(currentWs.path) === path.resolve(targetWs.path);
+        if (isCurrent)
+            this.saveWorkspaceConversationState();
+        const stateKey = this.workspaceConversationStateKeyFor(clean, targetWs);
         if (!stateKey)
             return false;
-        const stored = this.readStoredConversationState();
+        const stored = this.readStoredConversationState(targetWs);
         stored.conversations = stored.conversations || {};
         const existing = stored.conversations[stateKey];
         if (!existing)
@@ -3406,26 +3467,72 @@ class Agent {
             .map(([, value]) => Number(value.order));
         existing.order = siblingOrders.length ? Math.min(...siblingOrders) - 1 : 0;
         existing.updatedAt = existing.updatedAt || new Date().toISOString();
-        this.writeStoredConversationState(stored);
+        this.writeStoredConversationState(stored, targetWs);
         return true;
     }
-    renameConversation(id, title) {
+    renameConversation(id, title, ws = this.workspace.current) {
+        const targetWs = ws || this.workspace.current;
+        if (!targetWs)
+            return false;
         const clean = this.safeConversationId(id || 'default');
         const nextTitle = String(title || '').replace(/\s+/g, ' ').trim().slice(0, 80);
         if (!nextTitle)
             return false;
-        this.saveWorkspaceConversationState();
-        const stateKey = this.workspaceConversationStateKey(clean);
+        const currentWs = this.workspace.current;
+        const isCurrent = !!currentWs && path.resolve(currentWs.path) === path.resolve(targetWs.path);
+        if (isCurrent)
+            this.saveWorkspaceConversationState();
+        const stateKey = this.workspaceConversationStateKeyFor(clean, targetWs);
         if (!stateKey)
             return false;
-        const stored = this.readStoredConversationState();
+        const stored = this.readStoredConversationState(targetWs);
         const existing = stored.conversations?.[stateKey];
         if (!existing)
             return false;
         existing.title = nextTitle;
-        this.writeStoredConversationState(stored);
+        this.writeStoredConversationState(stored, targetWs);
         return true;
     }
+    /** 为指定工作区创建空白对话，不临时切换全局前台工作区。 */
+    createConversationInWorkspace(ws, title = '') {
+        const existing = this.listWorkspaceConversationStates(ws);
+        const id = this.safeConversationId(`conv-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`);
+        const resolvedTitle = String(title || '').replace(/\s+/g, ' ').trim().slice(0, 80)
+            || `New chat ${existing.length + 1}`;
+        const stateKey = this.workspaceConversationStateKeyFor(id, ws);
+        if (!stateKey)
+            throw new Error('Conversation workspace is unavailable.');
+        const unpinnedOrders = existing.filter(item => !item.pinned).map(item => Number(item.order || 0));
+        const order = unpinnedOrders.length ? Math.min(...unpinnedOrders) - 1 : 0;
+        const now = new Date().toISOString();
+        this.mutateStoredConversationState(ws, latest => {
+            latest.version = 3;
+            latest.activeConversationId = id;
+            latest.conversations = latest.conversations || {};
+            latest.conversations[stateKey] = {
+                title: resolvedTitle,
+                chatMessages: [],
+                history: [],
+                plan: { items: [] },
+                linkedPlan: { markdown: '', revision: 0 },
+                workRuns: [],
+                continuations: [],
+                inputMode: this.defaultInputMode(),
+                mode: 'build',
+                updatedAt: now,
+                pinned: false,
+                pinnedAt: '',
+                order,
+                branchCommunication: false,
+            };
+            return latest;
+        });
+        const currentWs = this.workspace.current;
+        if (currentWs && path.resolve(currentWs.path) === path.resolve(ws.path)) {
+            this.setConversationFromStorage(id);
+        }
+        return { id, title: resolvedTitle };
+    }
     /**
      * 首 Build 命名判定：仅当 (1) 当前对话尚无历史 Build（排除当前 run）且
      * (2) 其持久化 title 仍是自动生成（含为空）时返回 true。dev-0.4.3 起不再
@@ -3560,6 +3667,39 @@ class Agent {
         this.writeStoredConversationState(stored);
         return true;
     }
+    /** Reorder one pinned group inside an explicit workspace without changing membership. */
+    reorderWorkspaceConversationGroup(ids, ws) {
+        const targetWs = ws || this.workspace.current;
+        if (!targetWs || !Array.isArray(ids) || ids.length < 2)
+            return false;
+        const normalized = ids.map(id => this.safeConversationId(String(id || '')));
+        if (normalized.some(id => !id) || new Set(normalized).size !== normalized.length)
+            return false;
+        const currentWs = this.workspace.current;
+        const isCurrent = !!currentWs && path.resolve(currentWs.path) === path.resolve(targetWs.path);
+        if (isCurrent)
+            this.saveWorkspaceConversationState();
+        let accepted = false;
+        this.mutateStoredConversationState(targetWs, latest => {
+            const prefix = this.workspaceConversationPrefixFor(targetWs) || '';
+            const entries = Object.entries(latest.conversations || {})
+                .filter(([key]) => !prefix || key.startsWith(prefix));
+            const entryById = new Map(entries.map(([key, value]) => [key.slice(prefix.length + 1) || key, value]));
+            const requested = normalized.map(id => entryById.get(id));
+            if (requested.some(entry => !entry))
+                return latest;
+            if (new Set(requested.map(entry => !!entry.pinned)).size !== 1)
+                return latest;
+            const orderSlots = requested.map(entry => Number(entry.order));
+            if (orderSlots.some(order => !Number.isFinite(order)))
+                return latest;
+            orderSlots.sort((a, b) => a - b);
+            normalized.forEach((id, index) => { entryById.get(id).order = orderSlots[index]; });
+            accepted = true;
+            return latest;
+        });
+        return accepted;
+    }
     flushConversationState() {
         this.saveWorkspaceConversationState();
     }
@@ -5678,17 +5818,17 @@ class Agent {
         this.saveWorkspaceConversationState(true);
         return { text, hiddenUserInput: true, goalContinuation: true };
     }
-    buildSessionArchive(messages, mode, model, archiveDir) {
+    buildSessionArchive(messages, context, archiveDir) {
         const stamp = new Date().toISOString().replace(/[:.]/g, '').replace('T', '_').replace('Z', '');
         // 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 += `**Mode**: ${context.mode}\n**Model**: ${context.model}\n`;
         markdown += `**Messages**: ${messages.length}\n\n---\n\n`;
-        if (this.goal)
-            markdown += `**Goal**: ${this.goal.objective}\n\n`;
+        if (context.goal?.objective)
+            markdown += `**Goal**: ${context.goal.objective}\n\n`;
         for (const msg of messages) {
             markdown += `**[${msg.role}] ${msg.timestamp}**\n\n${msg.content}\n\n`;
             for (const attachment of (0, conversationAttachments_1.hydrateConversationImageAttachments)(this.rootPath, msg.attachments)) {
@@ -5704,12 +5844,12 @@ class Agent {
     writeSessionArchive(messages, mode, model) {
         const archiveDir = this.archiveDir();
         fs.mkdirSync(archiveDir, { recursive: true });
-        const archive = this.buildSessionArchive(messages, mode, model, archiveDir);
+        const archive = this.buildSessionArchive(messages, { mode, model, goal: this.serializeGoal() }, 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);
+    async writeSessionArchiveAsync(messages, context, archiveDir = this.archiveDir()) {
+        const archive = this.buildSessionArchive(messages, context, archiveDir);
         await fs.promises.mkdir(archiveDir, { recursive: true });
         const outPath = path.join(archiveDir, archive.filename);
         const tempPath = `${outPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
@@ -5803,25 +5943,23 @@ class Agent {
      * large markdown payload and manifest use promise-based filesystem I/O so
      * independent workspaces can archive in parallel without freezing Electron.
      */
-    async archiveConversationAsync(conversationId) {
+    async archiveConversationAsync(conversationId, ws = this.workspace.current) {
         // 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);
+        return await this.archiveConversationAsyncUnlocked(conversationId, ws);
     }
-    async archiveConversationAsyncUnlocked(conversationId) {
-        const ws = this.workspace.current;
+    async archiveConversationAsyncUnlocked(conversationId, targetWorkspace = this.workspace.current) {
+        const ws = targetWorkspace || this.workspace.current;
         if (!ws)
             return null;
         const clean = this.safeConversationId(conversationId || 'default');
-        const stateKey = this.workspaceConversationStateKey(clean);
+        const stateKey = this.workspaceConversationStateKeyFor(clean, ws);
         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;
+        const workspacePrefix = this.workspaceConversationPrefixFor(ws) || '';
         // readStoredConversationState returns a cache object. Clone it before any
         // asynchronous gap so concurrent archive requests cannot mutate one
         // another's source snapshot.
@@ -5831,13 +5969,23 @@ class Agent {
         if (persisted)
             this.normalizeConversationTree(persisted);
         const memory = this.workspaceConversations.get(memoryKey);
+        const archiveMode = persisted?.mode || memory?.mode || 'build';
+        const archiveSelection = persisted?.modelSelection || memory?.modelSelection;
+        const archiveModel = archiveSelection?.kind === 'deployment'
+            ? archiveSelection.modelId
+            : archiveSelection?.kind === 'auto' ? 'auto' : 'auto';
+        const archiveGoal = persisted?.goal || memory?.goal || null;
         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 filename = await this.writeSessionArchiveAsync(messages, {
+            mode: archiveMode,
+            model: archiveModel,
+            goal: archiveGoal,
+        }, archiveDir);
         const archiveEntry = persisted ? JSON.parse(JSON.stringify(persisted)) : {
             title: this.titleFromMessages(messages, clean),
             chatMessages: messages,
@@ -5897,7 +6045,9 @@ class Agent {
         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')) {
+        const currentWs = this.workspace.current;
+        const isCurrentWorkspace = !!currentWs && path.resolve(currentWs.path) === path.resolve(ws.path);
+        if (isCurrentWorkspace && clean === this.safeConversationId(this.activeConversationId || 'default')) {
             this.activeConversationId = nextActiveId || 'default';
             this.loadWorkspaceConversationState();
         }
@@ -7345,7 +7495,7 @@ class Agent {
         const settled = await this.waitForSubagentSettlement(accepted.data.id);
         return `${accepted.output}\n${settled?.result || settled?.error || ''}`.trim();
     }
-    async handleSubagentEnvelope(args) {
+    async handleSubagentEnvelope(args, requireRunningBuild = false) {
         try {
             const params = JSON.parse(args);
             const preset = this.resolveSubagentPreset(params);
@@ -7368,7 +7518,39 @@ class Agent {
                 && requestedModel === activeDeployment.modelId
                 ? `deployment:${encodeURIComponent(activeDeployment.providerId)}:${encodeURIComponent(activeDeployment.modelId)}`
                 : requestedModel;
-            const id = this.subagents.create(name, prompt, peerModel, params.input_mode || params.inputMode || preset?.inputMode || 'guide', peerMode, this.runtimeActorId, peerFlow, peerGoal, Number(params.flow_pc ?? params.flowPc ?? (peerMode === 'flow' ? this.flowPc : 0)));
+            const buildRunId = this.currentWorkRunId();
+            const runningBuild = buildRunId
+                ? this.workRuns.find(run => run.runId === buildRunId && run.status === 'running')
+                : undefined;
+            const limit = this.subagentConcurrencyLimit();
+            if (requireRunningBuild && !runningBuild) {
+                return {
+                    ok: false,
+                    output: '[SubAgent terminated] No running Build Block owns this call; no SubAgent was created.',
+                    error: 'SubAgent tool calls require a running Build Block.',
+                    metadata: { kind: 'subagent', buildRunId: buildRunId || '', limit, terminated: true },
+                };
+            }
+            if (buildRunId && !runningBuild) {
+                return {
+                    ok: false,
+                    output: `[SubAgent terminated] Build Block ${buildRunId} is not running; no SubAgent was created.`,
+                    error: 'SubAgent creation requires a running Build Block.',
+                    metadata: { kind: 'subagent', buildRunId, limit, terminated: true },
+                };
+            }
+            if (runningBuild) {
+                const activeForBuild = this.subagents.activeCountForBuild(buildRunId);
+                if (activeForBuild >= limit) {
+                    return {
+                        ok: false,
+                        output: `[SubAgent terminated] Build Block ${buildRunId} reached the ${this.intelligence === 'ultra' ? 'Ultra' : 'non-Ultra'} hard limit (${limit}); no SubAgent was created or queued.`,
+                        error: `SubAgent hard limit reached for Build Block ${buildRunId}: ${activeForBuild}/${limit}.`,
+                        metadata: { kind: 'subagent', buildRunId, intelligence: this.intelligence, activeForBuild, limit, terminated: true },
+                    };
+                }
+            }
+            const id = this.subagents.create(name, prompt, peerModel, params.input_mode || params.inputMode || preset?.inputMode || 'guide', peerMode, this.runtimeActorId, peerFlow, peerGoal, Number(params.flow_pc ?? params.flowPc ?? (peerMode === 'flow' ? this.flowPc : 0)), runningBuild?.runId || '', this.intelligence);
             const sa = this.subagents.get(id);
             if (sa && preset) {
                 sa.metadata = {
@@ -8830,7 +9012,7 @@ class Agent {
         if (this.intelligence === 'ultra') {
             parts.push([
                 '[Ultra Intelligence – Orchestrator Role]',
-                'You are the lead orchestrator. Actively decompose complex tasks into parallel sub-tasks. Use the `task` tool to create specialized SubAgents for each distinct sub-task. Coordinate the SubAgent team: assign clear responsibilities, merge results, resolve conflicts, and produce a unified final output. SubAgents are your team; delegate aggressively and manage them as a manager, not just a tool caller.',
+                'You are the lead orchestrator. Actively decompose complex tasks into parallel sub-tasks. Use the `SubAgent` tool to create specialized SubAgents for each distinct sub-task. Use `task_create` only for the conversation checklist; it never creates a SubAgent. Coordinate the SubAgent team: assign clear responsibilities, merge results, resolve conflicts, and produce a unified final output. SubAgents are your team; delegate aggressively and manage them as a manager, not just a tool caller.',
                 'Do not attempt to do all the work yourself. Use SubAgents for parallel investigation, verification, implementation, and review.',
             ].join('\n'));
         }
@@ -8937,7 +9119,7 @@ class Agent {
             '- Build history disclosure is two-layered. The request prompt contains only each historical Build Block user input, final summary, and completion status. When the current task continues, fixes, verifies, or depends on earlier Build Blocks, proactively call build_history_query to read the concrete tool activity and results of the relevant block, and reuse that information instead of re-investigating (re-running commands or re-reading files) from scratch. Querying history is read-only and never authorizes resuming that work; do not query merely to answer completion status already shown in the prompt.',
             '- Linked plan disclosure: a durable conversation-linked Markdown plan exists and can be inspected or updated with linked_plan when explicitly needed or required by Plan mode. Its full Markdown and revision are not injected into every model request.',
             '- A memory_lab_update, memory_lab_delete, or memory_lab_reindex call is unfinished until its awaited tool result contains rebuildReceipt.completed=true. The completion receipt is represented by the tool activity inside the current Build block and should not be repeated as a separate completion message.',
-            `- Skills and subagents: skill searches enabled metadata and loads one SKILL.md body on demand; skill_download installs offline skill folders; task creates constrained subagents tracked in agent state.`,
+            `- Skills and subagents: skill searches enabled metadata and loads one SKILL.md body on demand; skill_download installs offline skill folders; SubAgent creates constrained peer agents tracked in agent state. task_create is only for the conversation checklist and never creates a SubAgent.`,
             `- Visible output contract: assistant replies are sanitized before display to remove hidden-reasoning markers. ${visibleOutputContract}`,
             '- During Build work, before the first tool call and between materially different tool phases, emit a concise public progress explanation of what you are checking or changing and why. This is visible commentary, not hidden chain-of-thought. Do not wait until the final answer to explain the work.',
         ].join('\n');

package/dist/core/agentKernelRunner.d.ts

@@ -158,6 +158,9 @@ export declare const agentKernelRunnerInternals: {
     TOOL_PROVISION_NAME: string;
     INITIAL_TOOL_SCHEMA_LIMIT: number;
     SUBAGENT_CORE_TOOL_NAMES: Set<string>;
+    TASK_CHECKLIST_CORE_TOOL_NAMES: Set<string>;
+    BASIC_INITIAL_TOOL_NAMES: Set<string>;
+    ALWAYS_AVAILABLE_AGENT_TOOL_NAMES: Set<string>;
 };
 declare function imageMimeForPath(imagePath: string): string;
 export {};