newmark-agent 0.3.6 → 0.3.8

package/dist/core/agent.js

@@ -191,6 +191,8 @@ class Agent {
     continuations = [];
     activeConversationId = 'default';
     lastCompression = null;
+    compressionCache = [];
+    nextCompressionCacheId = 1;
     workspaceConversations = new Map();
     isSubagentRuntime = false;
     subagentName = '';
@@ -3109,6 +3111,7 @@ class Agent {
         this.workspaceConversations.set(key, {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
@@ -3138,6 +3141,7 @@ class Agent {
             title,
             chatMessages: [...this.chatMessages],
             history: [...this.history],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
@@ -3167,6 +3171,8 @@ class Agent {
         if (!key) {
             this.chatMessages = [];
             this.history = [];
+            this.compressionCache = [];
+            this.nextCompressionCacheId = 1;
             this.conversationPlan = { items: [] };
             this.linkedPlan = { markdown: '', revision: 0 };
             this.workRuns = [];
@@ -3183,6 +3189,8 @@ class Agent {
         const saved = this.workspaceConversations.get(key);
         if (saved) {
             this.history = [...saved.history];
+            this.compressionCache = saved.compressionCache ? saved.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+            this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
             this.chatMessages = this.normalizeConversationChatMessages(saved.chatMessages, this.history);
             this.conversationPlan = this.normalizeConversationPlan(saved.plan);
             this.linkedPlan = this.normalizeLinkedPlan(saved.linkedPlan);
@@ -3202,6 +3210,8 @@ class Agent {
         const stateKey = this.workspaceConversationStateKey();
         const persisted = stateKey && stored.conversations ? stored.conversations[stateKey] : null;
         this.history = persisted?.history ? [...persisted.history] : [];
+        this.compressionCache = persisted?.compressionCache ? persisted.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+        this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
         this.chatMessages = this.normalizeConversationChatMessages(persisted?.chatMessages || [], this.history);
         this.conversationPlan = this.normalizeConversationPlan(persisted?.plan);
         this.linkedPlan = this.normalizeLinkedPlan(persisted?.linkedPlan);
@@ -3219,6 +3229,7 @@ class Agent {
         this.workspaceConversations.set(key, {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
+            compressionCache: [...this.compressionCache],
             plan: this.normalizeConversationPlan(this.conversationPlan),
             linkedPlan: this.normalizeLinkedPlan(this.linkedPlan),
             subagentState: this.subagents.serialize(),
@@ -3417,6 +3428,257 @@ class Agent {
             truncatedActivities: Math.max(0, publicEvents.length - activities.length),
         });
     }
+    async handleContextCompress(args, signal) {
+        let input = {};
+        try {
+            input = JSON.parse(args || '{}');
+        }
+        catch { }
+        if (this.history.length <= 1)
+            return { ok: false, output: '[context_compress] No context to compress.', error: 'No context to compress.' };
+        const previousKeepLast = this.config.getNum('context', 'keep_recent_messages');
+        const keepRecent = Math.max(2, Math.min(60, Math.floor(Number(input.keep_recent) || previousKeepLast || 10)));
+        const force = Boolean(input.force);
+        try {
+            this.config.set('context', 'keep_recent_messages', keepRecent);
+            const msgs = this.history.map(message => ({ ...message }));
+            const provider = this.engineModel();
+            await this.maybeCompress(msgs, provider, signal, this.activeModelName(), force);
+            if (this.history.length <= 1)
+                return { ok: false, output: '[context_compress] Compression skipped: context unchanged.', error: 'Compression skipped.' };
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    compressed: true,
+                    at: this.lastCompression?.at,
+                    originalMessages: this.lastCompression?.originalMessages,
+                    compressedMessages: this.lastCompression?.compressedMessages,
+                    originalChars: this.lastCompression?.originalChars,
+                    compressedChars: this.lastCompression?.compressedChars,
+                    estimatedTokens: this.lastCompression?.compressedTokens,
+                    summary: this.lastCompression?.summary?.slice(0, 2000),
+                    model: this.lastCompression?.model,
+                    fallback: this.lastCompression?.fallback,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-compress' },
+            };
+        }
+        finally {
+            this.config.set('context', 'keep_recent_messages', previousKeepLast);
+        }
+    }
+    handleContextHistoryManage(args) {
+        let input = {};
+        try {
+            input = JSON.parse(args || '{}');
+        }
+        catch { }
+        const action = String(input.action || '').trim();
+        if (!action)
+            return { ok: false, output: '[context_history_manage] action is required (list|remove|summarize|restore|search|status).', error: 'action is required.' };
+        if (action === 'list') {
+            const limit = Math.max(5, Math.min(400, Math.floor(Number(input.limit || 200))));
+            const entries = this.history.slice(0, limit).map((message, index) => ({
+                position: index,
+                role: String(message.role || ''),
+                name: String(message.name || ''),
+                chars: typeof message.content === 'string' ? message.content.length : JSON.stringify(message.content || '').length,
+                preview: this.compressionHistoryContent(message.content || '').slice(0, 160),
+            }));
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'list',
+                    entryCount: this.history.length,
+                    listed: entries.length,
+                    entries,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-list' },
+            };
+        }
+        const protectedZone = this.contextHistoryProtectedZone();
+        if (action === 'remove') {
+            const position = Math.floor(Number(input.position));
+            if (!Number.isFinite(position) || position < 0 || position >= this.history.length) {
+                return { ok: false, output: `[context_history_manage] remove position ${position} out of range (0..${this.history.length - 1}).`, error: 'remove position out of range.' };
+            }
+            if (protectedZone.has(position) && !Boolean(input.dangerous)) {
+                return {
+                    ok: false,
+                    output: `[context_history_manage] remove position ${position} is protected (recent context tail or the last user message). Pass dangerous: true to override.`,
+                    error: 'remove position is in the protected context zone.',
+                };
+            }
+            const removed = this.history.splice(position, 1)[0];
+            this.saveWorkspaceConversationState(true);
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'remove',
+                    removedPosition: position,
+                    removedRole: String(removed?.role || ''),
+                    remaining: this.history.length,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-remove' },
+            };
+        }
+        if (action === 'summarize') {
+            const from = Math.max(0, Math.floor(Number(input.position || 0)));
+            const toRaw = Math.floor(Number(input.to ?? input.position));
+            const to = Number.isFinite(toRaw) ? Math.min(this.history.length - 1, Math.max(from, toRaw)) : from;
+            if (from >= this.history.length)
+                return { ok: false, output: `[context_history_manage] summarize position ${from} out of range (0..${this.history.length - 1}).`, error: 'summarize position out of range.' };
+            if (to - from < 1)
+                return { ok: false, output: '[context_history_manage] summarize requires at least two entries in range.', error: 'summarize requires a range of at least two entries.' };
+            const protectedHit = this.history.slice(from, to + 1).some((_, index) => protectedZone.has(from + index));
+            if (protectedHit && !Boolean(input.dangerous)) {
+                return {
+                    ok: false,
+                    output: '[context_history_manage] summarize range includes protected entries (recent context tail or the last user message). Pass dangerous: true to override.',
+                    error: 'summarize range overlaps the protected context zone.',
+                };
+            }
+            const segment = this.history.slice(from, to + 1);
+            const chars = segment.reduce((sum, message) => sum + (typeof message.content === 'string' ? message.content.length : JSON.stringify(message.content || '').length), 0);
+            const summary = this.localCompressionSummary(`Workspace: ${this.workspace.current?.path || this.rootPath}\nMode: ${this.modeName()}`, segment.map((message, i) => `#${i + 1} [${String(message.role || 'unknown')}${message.name ? ` ${String(message.name)}` : ''}]\n${this.compressionHistoryContent(message.content || '')}`).join('\n\n').slice(0, 20000), segment.length, chars);
+            const replacement = { role: 'system', content: `[Context History Summary]\n${summary}` };
+            this.history.splice(from, to - from + 1, replacement);
+            this.pushCompressionCacheEntry(`[Context History Summary]\n${summary}`, segment, 'local-summarize', true);
+            this.saveWorkspaceConversationState(true);
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'summarize',
+                    foldedFrom: from,
+                    foldedTo: to,
+                    foldedEntries: to - from + 1,
+                    foldedChars: chars,
+                    remaining: this.history.length,
+                    summary: summary.slice(0, 2000),
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-summarize' },
+            };
+        }
+        if (action === 'restore') {
+            const restoreId = String(input.restore_id || '').trim();
+            const entry = this.compressionCache.find(item => item.id === restoreId);
+            if (!entry)
+                return { ok: false, output: `[context_history_manage] restore unknown restore_id: ${restoreId}.`, error: 'restore_id not found.' };
+            const summaryHeader = entry.summary.startsWith('[Context Compression') ? '[Context Compression' : '[Context History Summary]';
+            const markerIndex = this.history.findIndex(message => String(message.role || '') === 'system' && String(message.content || '').includes(summaryHeader) && String(message.content || '').includes(entry.summary.slice(0, 200)));
+            if (markerIndex < 0) {
+                return { ok: false, output: '[context_history_manage] restore failed: the folded summary is no longer present in context history (already re-folded or removed).', error: 'restore target summary not found in history.' };
+            }
+            this.history.splice(markerIndex, 1, ...entry.messages.map(message => ({ ...message })));
+            this.compressionCache = this.compressionCache.filter(item => item.id !== entry.id);
+            this.saveWorkspaceConversationState(true);
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'restore',
+                    restoreId: entry.id,
+                    restoredEntries: entry.messages.length,
+                    restoredChars: entry.foldedChars,
+                    cacheRemaining: this.compressionCache.length,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-restore' },
+            };
+        }
+        if (action === 'search') {
+            const query = String(input.query || '').trim().toLowerCase();
+            const limit = Math.max(1, Math.min(200, Math.floor(Number(input.limit || 20))));
+            if (!query)
+                return { ok: false, output: '[context_history_manage] search requires query.', error: 'search requires query.' };
+            const matches = [];
+            for (const entry of this.compressionCache) {
+                if (matches.length >= limit)
+                    break;
+                const hit = { cacheId: entry.id, at: entry.at, summary: entry.summary.slice(0, 500), matches: [] };
+                if (entry.summary.toLowerCase().includes(query)) {
+                    hit.matches.push({ index: -1, snippet: this.snippetAround(entry.summary, query) });
+                }
+                entry.messages.forEach((message, index) => {
+                    if (matches.length >= limit || hit.matches.length >= 40)
+                        return;
+                    const content = this.compressionHistoryContent(message.content || message.reasoning_content || '');
+                    if (content.toLowerCase().includes(query)) {
+                        hit.matches.push({ index, snippet: this.snippetAround(content, query) });
+                    }
+                });
+                if (hit.matches.length)
+                    matches.push(hit);
+            }
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'search',
+                    query: String(input.query || ''),
+                    cacheEntries: this.compressionCache.length,
+                    matches,
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-search' },
+            };
+        }
+        if (action === 'status') {
+            const budget = this.compressionBudget(this.history);
+            const estimatedTokens = this.estimateContextTokens(this.history);
+            const maxTokens = this.contextMaxTokens();
+            const protectedStartIndex = this.contextHistoryProtectedStartIndex();
+            const lastUserIndex = this.history.map(message => String(message.role || '')).lastIndexOf('user');
+            return {
+                ok: true,
+                output: JSON.stringify({
+                    ok: true,
+                    action: 'status',
+                    historyLength: this.history.length,
+                    chatMessages: this.chatMessages.length,
+                    estimatedTokens,
+                    maxTokens,
+                    triggerTokens: budget.triggerTokens,
+                    targetTokens: budget.targetTokens,
+                    summaryTokens: budget.summaryTokens,
+                    usagePercent: maxTokens > 0 ? Math.round((estimatedTokens / maxTokens) * 1000) / 10 : 0,
+                    thresholdReached: budget.triggerTokens > 0 && estimatedTokens >= budget.triggerTokens,
+                    keepRecentMessages: this.config.getNum('context', 'keep_recent_messages') || 10,
+                    lastCompression: this.lastCompression ? {
+                        at: this.lastCompression.at,
+                        originalMessages: this.lastCompression.originalMessages,
+                        compressedMessages: this.lastCompression.compressedMessages,
+                        compressedTokens: this.lastCompression.compressedTokens,
+                        model: this.lastCompression.model,
+                        fallback: this.lastCompression.fallback,
+                    } : null,
+                    cache: {
+                        entries: this.compressionCache.length,
+                        totalFoldedEntries: this.compressionCache.reduce((sum, item) => sum + item.foldedEntries, 0),
+                        totalFoldedChars: this.compressionCache.reduce((sum, item) => sum + item.foldedChars, 0),
+                        ids: this.compressionCache.map(item => item.id),
+                    },
+                    protectedZone: {
+                        preserveRecentMessages: this.config.getNum('context', 'preserve_recent_messages') || 5,
+                        protectedStartIndex,
+                        lastUserMessageIndex: lastUserIndex,
+                        protectedCount: protectedStartIndex >= 0 ? this.history.length - protectedStartIndex : 0,
+                    },
+                    displayHistory: { untouched: true, messageCount: this.chatMessages.length },
+                }, null, 2),
+                metadata: { kind: 'context-history-status' },
+            };
+        }
+        return { ok: false, output: `[context_history_manage] Unknown action: ${action}`, error: `Unknown action: ${action}` };
+    }
     recordContextCompressionStep() {
         const runId = this.currentWorkRunId();
         if (!runId)
@@ -3856,6 +4118,7 @@ class Agent {
                     model: fallbackUsed ? 'model-switch-segmented-with-fallback' : modelName,
                     fallback: fallbackUsed,
                 };
+                this.pushCompressionCacheEntry(summary, originalMessages.slice(0, recentStart), 'model-switch', fallbackUsed);
                 this.persistCompressedHistory(summary, recent.length, candidate);
                 this.saveWorkspaceConversationState(true);
                 return { compressed: true, rounds, segments, droppedMessages: 0, estimatedTokens: this.estimateContextTokens(candidate), maxTokens };
@@ -3892,6 +4155,7 @@ class Agent {
             model: fallbackUsed ? 'model-switch-segmented-with-fallback' : modelName,
             fallback: fallbackUsed || droppedMessages > 0,
         };
+        this.pushCompressionCacheEntry(summary, originalMessages.slice(0, recentStart), 'model-switch', fallbackUsed || droppedMessages > 0);
         this.persistCompressedHistory(summary, recent.length, candidate);
         this.saveWorkspaceConversationState(true);
         return { compressed: true, rounds, segments, droppedMessages, estimatedTokens: this.estimateContextTokens(candidate), maxTokens };
@@ -5496,7 +5760,7 @@ class Agent {
             if (!sa)
                 return { ok: false, output: `[Subagent] Not found: ${name}`, error: `Not found: ${name}` };
             const transcript = sa.messages.map(m => `[${m.role}] ${m.content}`).join('\n');
-            return this.subagents.toToolResult(sa.id, `get.subagent("${sa.name}")\nStatus: ${sa.status}\nModel: ${sa.model}\nMode: ${sa.agentMode}\n\nResult:\n${sa.result || ''}\n\nConversation:\n${transcript}`, true);
+            return this.subagents.toToolResult(sa.id, `get.subagent("${sa.name}", id="${sa.id}")\nStatus: ${sa.status}\nModel: ${sa.model}\nMode: ${sa.agentMode}\n\nResult:\n${sa.result || ''}\n\nConversation:\n${transcript}`, true);
         }
         catch {
             return { ok: false, output: '[Subagent] Invalid result arguments.', error: 'Invalid result arguments.' };
@@ -6393,7 +6657,7 @@ class Agent {
             return;
         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)
+        if (budget.estimatedTokens < budget.triggerTokens && !force)
             return;
         if (!force && this.lastCompression && String(msgs[0]?.content || '').includes(this.lastCompression.summary)) {
             const baselineChars = Math.max(0, Number(this.lastCompression.compressedChars || 0));
@@ -6450,6 +6714,7 @@ class Agent {
             model: compression.model,
             fallback: compression.fallback,
         };
+        this.pushCompressionCacheEntry(compression.summary, middle, compression.model, compression.fallback);
         this.persistCompressedHistory(compression.summary, recent.length, msgs);
     }
     async buildCompressionSummary(middle, totalChars, budget, provider, signal, compressionModel, currentInstruction = '') {
@@ -6607,6 +6872,56 @@ class Agent {
         if (this.isSubagentRuntime)
             this.subagentContextPersist?.(this.history.map(message => ({ ...message })), this.lastCompression);
     }
+    pushCompressionCacheEntry(summary, messages, model, fallback) {
+        if (!messages.length)
+            return;
+        const foldedChars = messages.reduce((sum, message) => sum + (typeof message.content === 'string'
+            ? message.content.length
+            : JSON.stringify(message.content || '').length), 0);
+        this.compressionCache.push({
+            id: `ctx-cache-${this.nextCompressionCacheId}`,
+            at: new Date().toISOString(),
+            summary,
+            messages: messages.map(message => ({ ...message })),
+            foldedEntries: messages.length,
+            foldedChars,
+            model,
+            fallback,
+        });
+        this.nextCompressionCacheId += 1;
+        const maxEntries = Math.max(0, Math.floor(this.config.getNum('context', 'compression_cache_max') || 8));
+        if (this.compressionCache.length > maxEntries) {
+            this.compressionCache = this.compressionCache.slice(this.compressionCache.length - maxEntries);
+        }
+        this.saveWorkspaceConversationState(true);
+    }
+    contextHistoryProtectedStartIndex() {
+        const preserve = Math.max(0, Math.floor(this.config.getNum('context', 'preserve_recent_messages') || 5));
+        const lastUserIndex = this.history.map(message => String(message.role || '')).lastIndexOf('user');
+        const candidates = [];
+        if (preserve > 0 && this.history.length > 0)
+            candidates.push(Math.max(0, this.history.length - preserve));
+        if (lastUserIndex >= 0)
+            candidates.push(lastUserIndex);
+        return candidates.length ? Math.min(...candidates) : -1;
+    }
+    contextHistoryProtectedZone() {
+        const start = this.contextHistoryProtectedStartIndex();
+        const zone = new Set();
+        if (start >= 0)
+            for (let i = start; i < this.history.length; i += 1)
+                zone.add(i);
+        return zone;
+    }
+    snippetAround(content, query, radius = 150) {
+        const text = String(content || '');
+        const index = text.toLowerCase().indexOf(query.toLowerCase());
+        if (index < 0)
+            return text.slice(0, radius * 2);
+        const from = Math.max(0, index - radius);
+        const to = Math.min(text.length, index + query.length + radius);
+        return `${from > 0 ? '…' : ''}${text.slice(from, to).trim()}${to < text.length ? '…' : ''}`;
+    }
     buildSystemPrompt() {
         const cwd = this.workspace.current?.path || this.rootPath;
         const enabledSkills = this.skills.active();

package/dist/core/agentKernelRunner.js

@@ -1470,6 +1470,10 @@ async function executeNewmarkTool(agent, name, args, inputSchema, signal) {
             return agent.handleLinkedPlanTool(args);
         if (name === 'build_history_query')
             return agent.handleBuildHistoryQuery(args);
+        if (name === 'context_compress')
+            return (await agent.handleContextCompress(args, signal)).output;
+        if (name === 'context_history_manage')
+            return agent.handleContextHistoryManage(args).output;
         if (name === 'question') {
             if (agent.config.getStr('agent', 'option_feedback') === 'fully_autonomous')
                 return '[question] Disabled by fully_autonomous option feedback.';

package/dist/core/config.js

@@ -911,6 +911,8 @@ 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 },
             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/subagent.d.ts

@@ -111,6 +111,7 @@ export interface SubagentReadSnapshot {
         natureSlug: string;
         displayName: string;
         qualifiedName: string;
+        name: string;
         createdByAgentId: string;
         status: SubagentStatus;
         active: boolean;

package/dist/core/subagent.js

@@ -119,6 +119,10 @@ class SubagentManager {
         const id = (0, crypto_1.randomUUID)();
         const shortId = id.replace(/-/g, '').slice(0, 8);
         const slug = natureSlug(name);
+        // The Agent-facing name is the caller's stable, human-readable label and is
+        // deliberately decoupled from the identity. The UUID and its short form are
+        // the only identity-bearing fields; the UI renders the short-id-qualified
+        // display name while Agent tool interactions accept both name and id.
         const displayName = `${slug}-${shortId}`;
         const qualifiedName = `${displayName}--${id}`;
         const stamp = now();
@@ -128,7 +132,7 @@ class SubagentManager {
             natureSlug: slug,
             displayName,
             qualifiedName,
-            name: qualifiedName,
+            name: slug,
             conversationId: this.conversationId,
             createdByAgentId,
             prompt,
@@ -139,7 +143,7 @@ class SubagentManager {
             flowName: flowName || undefined,
             flowPc: Math.max(0, Math.floor(Number(flowPc) || 0)),
             status: 'queued',
-            messages: [{ role: 'system', content: `Peer agent '${qualifiedName}': ${prompt}` }, { role: 'user', content: prompt, hidden_user_input: true }],
+            messages: [{ role: 'system', content: `Peer agent '${slug}' (${id}): ${prompt}` }, { role: 'user', content: prompt, hidden_user_input: true }],
             result: null,
             createdAt: stamp,
             updatedAt: stamp,
@@ -152,7 +156,14 @@ class SubagentManager {
         return id;
     }
     get(id) {
-        return this.subs.get(id) || [...this.subs.values()].find(item => item.name === id || item.qualifiedName === id || item.displayName === id || item.shortId === id || item.natureSlug === natureSlug(id));
+        if (this.subs.has(id))
+            return this.subs.get(id);
+        const exact = [...this.subs.values()].find(item => item.id === id || item.qualifiedName === id);
+        if (exact)
+            return exact;
+        // name is now caller-supplied and not identity-bearing, so it is a
+        // convenience lookup only; the id/shortId/displayName paths stay exact.
+        return [...this.subs.values()].find(item => item.name === id || item.displayName === id || item.shortId === id || item.natureSlug === natureSlug(id));
     }
     send(id, prompt) {
         const target = this.get(id);
@@ -321,6 +332,7 @@ class SubagentManager {
                     natureSlug: record.natureSlug,
                     displayName: record.displayName,
                     qualifiedName: record.qualifiedName,
+                    name: record.name,
                     createdByAgentId: record.createdByAgentId,
                     status: record.status,
                     active: record.status !== 'closed',

package/dist/core/toolPolicy.js

@@ -14,6 +14,8 @@ const MODE_SCOPED_TOOLS = new Set([
     'pdf_read',
     'linked_plan',
     'build_history_query',
+    'context_compress',
+    'context_history_manage',
     'question',
     'task',
     'subagent_list',

package/dist/tools/index.js

@@ -365,14 +365,24 @@ class ToolExecutor {
                 remote_root: { type: 'string' },
                 remote_path: { type: 'string' },
             }, ['action']),
-            t('task', 'Create a same-conversation peer agent and return immediately. The peer has a nature slug, short id, and canonical UUID-qualified name. Pass model to select an exact configured model deployment (deployment:providerId:modelId or an unambiguous provider/model name). When model is omitted, the peer inherits the parent Agent\'s currently resolved model deployment. Plan mode peers are forced to Plan.', { nature: { type: 'string' }, name: { type: 'string', description: 'Legacy alias for nature.' }, prompt: { type: 'string' }, preset: { type: 'string' }, agent: { type: 'string' }, model: { type: 'string', description: 'Optional exact model deployment. Omit to inherit the parent Agent resolved model.' }, mode: { type: 'string' }, input_mode: { type: 'string' }, flow: { type: 'string' } }, ['prompt']),
-            t('subagent_list', 'List flat same-conversation peer agents, optionally filtered by status.', { status: { type: 'string', enum: ['idle', 'queued', 'working', 'completed', 'error', 'closed'] } }, []),
-            t('subagent_read', 'Read one same-conversation peer status, queue/mailbox summary, latest bounded feedback, and result. Available for running, queued, completed, error, and closed peers.', { id: { type: 'string' }, name: { type: 'string' }, max_chars: { type: 'number', description: 'Bounded result size from 2000 to 32000 characters.' } }, []),
-            t('subagent_send', 'Persist a mailbox message to a same-conversation peer agent.', { id: { type: 'string' }, name: { type: 'string' }, message: { type: 'string' }, prompt: { type: 'string', description: 'Legacy alias for message.' }, kind: { type: 'string', enum: ['directive', 'question', 'result', 'handoff'] }, reply_to: { type: 'string' }, correlation_id: { type: 'string' } }, []),
-            t('subagent_result', 'Return the persisted transcript, mailbox summary, status, and latest result for a peer agent.', { id: { type: 'string' }, name: { type: 'string' } }, []),
-            t('subagent_close', 'Close a same-conversation peer. Root can close any peer; a peer can close only itself.', { id: { type: 'string' }, name: { type: 'string' } }, []),
+            t('task', 'Create a same-conversation peer agent and return immediately. The peer has a stable human-readable name, a short id, and a canonical UUID-qualified identity. The peer name is decoupled from its id: pass name for readable references and id for exact targeting. Pass model to select an exact configured model deployment (deployment:providerId:modelId or an unambiguous provider/model name). When model is omitted, the peer inherits the parent Agent\'s currently resolved model deployment. Plan mode peers are forced to Plan.', { nature: { type: 'string' }, name: { type: 'string', description: 'Legacy alias for nature.' }, prompt: { type: 'string' }, preset: { type: 'string' }, agent: { type: 'string' }, model: { type: 'string', description: 'Optional exact model deployment. Omit to inherit the parent Agent resolved model.' }, mode: { type: 'string' }, input_mode: { type: 'string' }, flow: { type: 'string' } }, ['prompt']),
+            t('subagent_list', 'List flat same-conversation peer agents, optionally filtered by status. Each entry exposes both the stable name and the exact id; use the id for any subsequent targeting.', { status: { type: 'string', enum: ['idle', 'queued', 'working', 'completed', 'error', 'closed'] } }, []),
+            t('subagent_read', 'Read one same-conversation peer status, queue/mailbox summary, latest bounded feedback, and result. Available for running, queued, completed, error, and closed peers. Pass the exact id returned by subagent_list, or a name for convenience lookup.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name; ambiguous names resolve to the first match.' }, max_chars: { type: 'number', description: 'Bounded result size from 2000 to 32000 characters.' } }, []),
+            t('subagent_send', 'Persist a mailbox message to a same-conversation peer agent. Target by exact id (preferred) or name.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name.' }, message: { type: 'string' }, prompt: { type: 'string', description: 'Legacy alias for message.' }, kind: { type: 'string', enum: ['directive', 'question', 'result', 'handoff'] }, reply_to: { type: 'string' }, correlation_id: { type: 'string' } }, []),
+            t('subagent_result', 'Return the persisted transcript, mailbox summary, status, and latest result for a peer agent. Target by exact id (preferred) or name.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name.' } }, []),
+            t('subagent_close', 'Close a same-conversation peer. Root can close any peer; a peer can close only itself. Target by exact id (preferred) or name.', { id: { type: 'string', description: 'Exact peer id from subagent_list.' }, name: { type: 'string', description: 'Convenience peer name.' } }, []),
             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; restore reinserts the original messages of a folded segment from the compression cache using restore_id; search finds which cached folded segments contain a query (and the matching lines); status reports usage vs trigger/target budgets, the last compression, the compression cache, and the protected recent-message zone. The displayed conversation history (what the user sees) is never modified by any action. The recent context tail and the last user message are protected from remove/summarize unless dangerous is true.', {
+                action: { type: 'string', enum: ['list', 'remove', 'summarize', 'restore', 'search', 'status'], description: 'list: index context entries. remove: delete the entry at position. summarize: fold entries [from, to] into one summary entry. restore: reinsert cached original messages by restore_id. search: find folded cache entries containing query. status: report context usage, budgets, cache, and protected zone.' },
+                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 (default 200), or search matches to return (default 20).' },
+                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.' },
+                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']),
             t('skill', 'Search enabled skill metadata or load one exact skill body on demand. Use query when unsure, then name to load the selected skill.', { query: { type: 'string', maxLength: 200 }, name: { type: 'string', maxLength: 200 } }, []),

package/dist/tools/nativeTools.js

@@ -40,6 +40,8 @@ exports.NATIVE_TOOL_CATALOG = [
     { name: 'subagent_close', label: 'Subagent close', description: 'Close a same-conversation peer agent.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { 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: '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' },

package/dist/ui/index.html

@@ -2959,6 +2959,10 @@ button:focus, select:focus, input:focus, textarea:focus, [contenteditable]:focus
 .work-review-btn { height:28px; padding:0 10px; border:1px solid var(--glass-border-2); border-radius:6px; background:transparent; color:var(--text); cursor:pointer; font:600 11px var(--font); }
 .work-review-btn:hover { background:var(--control-hover-bg); border-color:var(--border-hover); }
 .work-review-list { border-top:1px solid var(--glass-border-1); }
+.work-review.collapsed .work-review-list { display: none; }
+.work-review-head { cursor: pointer; }
+.work-review-chevron { width:8px; height:8px; flex:0 0 auto; border-right:1px solid var(--text-dim); border-bottom:1px solid var(--text-dim); transform:rotate(-45deg); transition:transform 150ms ease; }
+.work-review.collapsed .work-review-chevron { transform:rotate(45deg); }
 .work-review-file { min-height:34px; display:grid; grid-template-columns:minmax(0,1fr) auto; align-items:center; gap:12px; padding:0 12px; color:var(--text); }
 .work-review-file:hover { background:var(--review-row-hover); }
 .work-review-path { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font:11px var(--font-mono); }
@@ -8208,6 +8212,12 @@ function normalizeWorkReviewDiffs(diffs) {
   return Object.keys(byPath).map(function(key) { return byPath[key]; });
 }
 
+window.toggleWorkReview = function(head) {
+  var review = head && head.closest ? head.closest('.work-review') : null;
+  if (!review) return;
+  review.classList.toggle('collapsed');
+};
+
 window.toggleWorkReviewFiles = function(button) {
   var review = button && button.closest ? button.closest('.work-review') : null;
   if (!review) return;
@@ -8301,15 +8311,16 @@ function addWorkReview(diffs) {
   var added = files.reduce(function(total, file) { return total + file.added; }, 0);
   var deleted = files.reduce(function(total, file) { return total + file.deleted; }, 0);
   var review = document.createElement('div');
-  review.className = 'work-review';
+  review.className = 'work-review collapsed';
   review.setAttribute('data-files', JSON.stringify(files));
   var rows = files.map(function(file, index) {
     return '<div class="work-review-file"' + (index >= 3 ? ' style="display:none"' : '') + '><span class="work-review-path">' + esc(file.path) + '</span><span><span class="work-review-add">+' + file.added + '</span><span class="work-review-del">-' + file.deleted + '</span></span></div>';
   }).join('');
   var editedLabel = files.length === 1 ? t('review.editedOne') : t('review.editedMany').replace('{count}', files.length);
-  review.innerHTML = '<div class="work-review-head"><div class="work-review-mark">' + iconSvg('file-diff', t('review.fileChanges'), 'small') + '</div>' +
+  review.innerHTML = '<div class="work-review-head" onclick="window.toggleWorkReview(this)"><div class="work-review-mark">' + iconSvg('file-diff', t('review.fileChanges'), 'small') + '</div>' +
     '<div><div class="work-review-title">' + esc(editedLabel) + '</div><div class="work-review-stats"><span class="work-review-add">+' + added + '</span><span class="work-review-del">-' + deleted + '</span></div></div>' +
-    '<div class="work-review-actions"><button class="work-review-btn" onclick="window.openWorkReview(this)">' + esc(t('review.open')) + '</button></div></div>' +
+    '<div class="work-review-actions"><button class="work-review-btn" onclick="window.openWorkReview(this);event.stopPropagation()">' + esc(t('review.open')) + '</button>' +
+    '<span class="work-review-chevron" aria-hidden="true"></span></div></div>' +
     '<div class="work-review-list">' + rows + (files.length > 3 ? '<button class="work-review-more" onclick="window.toggleWorkReviewFiles(this)">' + esc(t('review.showMore').replace('{count}', files.length - 3)) + '</button>' : '') + '</div>';
   els['chat-area'].appendChild(review);
   autoScrollIfAtBottom();
@@ -9112,7 +9123,7 @@ function workToolActivity(event) {
   if (name === 'task' || name.indexOf('subagent_') === 0) return { key: 'subagents', type: 'tool_subagent' };
   if (name === 'skill' || name === 'skill_load' || name === 'skill_read' || name === 'skill_download') return { key: 'skills', type: 'tool_skill' };
   if (name === 'mcp' || name.indexOf('mcp__') === 0 || /^mcp[:._-]/.test(name) || /[:._-]mcp[:._-]/.test(name)) return { key: 'mcp', type: 'tool_mcp' };
-  if (name === 'context_compression') return { key: 'context_compression', type: 'tool_context_compression' };
+  if (name === 'context_compression' || name === 'context_compress' || name === 'context_history_manage') return { key: 'context_compression', type: 'tool_context_compression' };
   if (name === 'memory_lab_update' || name === 'memory_lab_reindex') return { key: 'memory_lab', type: 'tool_memory_lab' };
   if (name === 'image_inspect' || name === 'computer_use') return { key: 'images', type: 'tool_images' };
   if (name === 'write' || name === 'edit') return { key: 'files', type: 'tool_files' };