omniharness-cli 0.1.32 → 0.1.34

package/README.md

@@ -35,6 +35,7 @@ The harness treats the **current working directory** as the workspace.
 |---|---|
 | `OMNIROUTE_URL` | OmniRoute endpoint (default `http://127.0.0.1:20128`, the HTTP API port) |
 | `OMNIROUTE_API_KEY` | OmniRoute API key — `Authorization: Bearer <key>` on every request |
+| `OMNIROUTE_MGMT_TOKEN` | OmniRoute management token (`manage` scope) — when set, OmniRoute's MCP tools are discovered and exposed to the agent |
 
 If `OMNIROUTE_API_KEY` is unset, the harness asks you to paste the key on
 interactive launch and holds it **in memory only** — it is never written to

package/dist/agent/mastraEngine.d.ts

@@ -1,5 +1,6 @@
-import { OmniRouteClient } from '../config/omniRoute.js';
-import type { AgentMode, HarnessState } from '../types/index.js';
+import { type AttachmentInput } from '../attachments.js';
+import { OmniRouteClient, type CompressionInfo, type McpToolDescriptor } from '../config/omniRoute.js';
+import type { AgentMode, HarnessState, TodoItem } from '../types/index.js';
 import { type SystemTools } from '../tools/systemTools.js';
 import { type Skill } from '../skills.js';
 export interface MastraEngineConfig {
@@ -8,6 +9,8 @@ export interface MastraEngineConfig {
     mode?: AgentMode;
     endpoint?: string;
     apiKey?: string;
+    /** OmniRoute management token: when set, OmniRoute MCP tools are discovered and exposed to the agent. */
+    mgmtToken?: string;
     shellAllowed?: boolean;
 }
 export type HarnessEvent = {
@@ -34,9 +37,19 @@ export type HarnessEvent = {
 } | {
     type: 'text';
     content: string;
+    model?: string;
+    compression?: CompressionInfo;
 } | {
     type: 'preview';
     url: string;
+} | {
+    type: 'attach';
+    name: string;
+    kind: AttachmentInput['kind'];
+    size: number;
+} | {
+    type: 'todos';
+    todos: readonly TodoItem[];
 };
 export interface ApprovalAction {
     tool: string;
@@ -47,13 +60,19 @@ export interface MastraEngine {
     readonly tools: SystemTools;
     readonly state: HarnessState;
     readonly skills: readonly Skill[];
+    readonly mcpTools: readonly McpToolDescriptor[];
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     selectModel(model: string): Promise<void>;
+    attach(paths: readonly string[]): Promise<readonly AttachmentInput[]>;
     setApprovalHandler(handler: (action: ApprovalAction) => Promise<boolean>): void;
     run(prompt: string, signal?: AbortSignal): Promise<{
         content: string;
         model: string;
     }>;
+    /** Abort the in-flight run; the turn ends with a 'cancelled' status. */
+    cancel(): void;
+    /** Drop transcript, task queue and persisted session; starts a fresh chat. */
+    clearHistory(): Promise<void>;
     stop(): void;
 }
 export declare function createMastraEngine(config: MastraEngineConfig): Promise<MastraEngine>;

package/dist/agent/mastraEngine.js

@@ -1,8 +1,14 @@
 import { exec, spawn } from 'node:child_process';
+import { appendFile, mkdir, readdir, readFile, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { attachmentBlock, kindFromName } from '../attachments.js';
 import { OmniRouteClient } from '../config/omniRoute.js';
 import { saveActiveCombo } from '../config/settings.js';
 import { createSystemTools } from '../tools/systemTools.js';
 import { loadSkills, renderSkillCommand, skillSchema } from '../skills.js';
+import { chunkText, cosineSimilarity } from '../search.js';
+import { loadSemanticIndex, saveSemanticIndex } from '../semanticStore.js';
+import { loadSession, saveSession, clearSession } from '../sessionStore.js';
 const VERIFY_RULES = '\n\nWORK LOGIC — you MUST follow this discipline when implementing:\n'
     + '1. Read files with read_file before editing them. Never guess at contents.\n'
     + '2. Make the smallest correct change with write_file, then run the relevant checks with run_command '
@@ -18,27 +24,99 @@ const MODE_PROMPT = {
     plan: 'You are in PLAN mode: investigate the workspace, name risks and steps, and produce a concrete plan. Do not edit files or run commands. Use read_file, index_workspace, and git_diff.',
     build: 'You are in BUILD mode: implement the request with minimal, correct changes. The full work discipline below is MANDATORY.',
     research: 'You are in RESEARCH mode: investigate and answer with evidence from the workspace. Use read_file, index_workspace, and git_diff. Do not modify files or run commands.',
+    crazy: 'You are in CRAZY MODE: a fully autonomous agent (OpenClaw/Hermes style) that works continuously without asking for permission — every tool call is auto-approved. Decide your own next steps, keep the visible task queue current with update_todo, persist important facts with write_memory, and keep working until the task is genuinely complete. Verify your own work and iterate.',
 };
-const SYSTEM_FRAME = (endpoint, root, mode, skillNames) => 'You are OmniHarness, an autonomous developer agent running inside the user\'s terminal (OmniHarness CLI, powered by the OmniRoute gateway at '
+const MEMORY_FILE = 'memory.md';
+const SYSTEM_FRAME = (endpoint, root, mode, skillNames, memory) => 'You are OmniHarness, an autonomous developer agent running inside the user\'s terminal (OmniHarness CLI, powered by the OmniRoute gateway at '
     + `${endpoint}). Workspace: ${root}. Act carefully and concretely; use the provided tools rather than guessing at file contents. `
     + MODE_PROMPT[mode]
     + (mode === 'build' ? VERIFY_RULES : '')
+    + (mode === 'crazy' && memory !== '' ? `\n\nPERSISTENT MEMORY (from previous sessions):\n${memory}` : '')
     + (skillNames.length > 0 ? `\nCustom skills available: ${skillNames.map((name) => `\`${name}\``).join(', ')}.` : '');
-const MAX_TURNS = 24;
+const MAX_TURNS = { plan: 12, build: 24, research: 12, crazy: 120 };
 const MAX_OUTPUT = 32_000;
 const RISKY_TOOLS = new Set(['write_file', 'run_command', 'start_preview']);
 export async function createMastraEngine(config) {
-    const client = new OmniRouteClient({ endpoint: config.endpoint, apiKey: config.apiKey });
+    const client = new OmniRouteClient({ endpoint: config.endpoint, apiKey: config.apiKey, mgmtToken: config.mgmtToken });
     const tools = createSystemTools(config.workspaceRoot, config.shellAllowed ?? false);
     const activeModel = config.model ?? 'auto/best-coding';
     const listeners = new Set();
     let preview = null;
     let previewChild = null;
     let approvalHandler = null;
+    let pendingAttachments = [];
+    const semanticCache = await loadSemanticIndex(config.workspaceRoot);
+    let activeRunController = null;
     const state = {
         taskStatus: 'idle', prompt: '', mode: config.mode ?? 'build', activeModel,
         workspace: { root: config.workspaceRoot, indexedAt: null, files: [], contextLocked: false },
-        metrics: client.snapshotMetrics(), messages: [], preview: null,
+        metrics: client.snapshotMetrics(), messages: [], preview: null, taskQueue: [],
+    };
+    // Resume: hydrate the transcript and task queue from the last persisted session.
+    const restored = await loadSession(config.workspaceRoot);
+    if (restored != null && restored.messages.length > 0) {
+        state.messages = restored.messages;
+        state.taskQueue = restored.taskQueue;
+    }
+    const memoryPath = join(state.workspace.root, '.omniharness', MEMORY_FILE);
+    let memory = '';
+    try {
+        memory = (await readFile(memoryPath, 'utf8')).trim();
+    }
+    catch { /* no memory yet */ }
+    const emitTodos = () => {
+        const snapshot = { todos: [...state.taskQueue], updatedAt: new Date().toISOString() };
+        state.lastTodoUpdate = snapshot;
+        emit({ type: 'todos', todos: snapshot.todos });
+    };
+    const applyTodo = (action) => {
+        const queue = [...state.taskQueue];
+        switch (action.action) {
+            case 'add': {
+                const id = `t${Date.now().toString(36)}${queue.length.toString(36)}`;
+                queue.push({ id, title: action.title, status: 'pending' });
+                state.taskQueue = queue;
+                emitTodos();
+                return `todo added: ${action.title}`;
+            }
+            case 'update': {
+                const item = queue.find((entry) => entry.id === action.id);
+                if (!item)
+                    return `error: no todo with id ${action.id}`;
+                item.title = action.title ?? item.title;
+                state.taskQueue = queue;
+                emitTodos();
+                return `todo updated: ${item.title}`;
+            }
+            case 'start': {
+                const target = (action.id ? queue.find((entry) => entry.id === action.id) : undefined) ?? queue.find((entry) => entry.status === 'pending');
+                if (!target)
+                    return 'error: no pending todo to start';
+                for (const entry of queue)
+                    entry.status = entry.id === target.id ? 'active' : entry.status === 'active' ? 'pending' : entry.status;
+                state.taskQueue = queue;
+                emitTodos();
+                return `started: ${target.title}`;
+            }
+            case 'complete': {
+                const target = (action.id ? queue.find((entry) => entry.id === action.id) : undefined) ?? queue.find((entry) => entry.status !== 'done');
+                if (!target)
+                    return 'error: no todo to complete';
+                target.status = 'done';
+                state.taskQueue = queue;
+                emitTodos();
+                return `completed: ${target.title}`;
+            }
+            case 'remove': {
+                const before = queue.length;
+                state.taskQueue = queue.filter((entry) => entry.id !== action.id);
+                if (state.taskQueue.length === before)
+                    return `error: no todo with id ${action.id}`;
+                emitTodos();
+                return `todo removed`;
+            }
+            default: return 'error: unknown todo action';
+        }
     };
     const emit = (event) => { for (const listener of listeners)
         listener(event); };
@@ -73,6 +151,43 @@ export async function createMastraEngine(config) {
             name: 'git_diff', description: tools.gitDiff.description, highRisk: false, parameters: { type: 'object', properties: {} },
             execute: async (_, signal) => { const r = await tools.gitDiff.execute(undefined, signal); return r === '' ? '(no diff)' : r; },
         },
+        semantic_search: {
+            name: 'semantic_search', description: 'Embed the workspace and search it by meaning, returning the most relevant files with matching snippets. Use instead of guessing which file holds a concept.', highRisk: false, parameters: { type: 'object', properties: { query: { type: 'string' }, limit: { type: 'integer' }, refresh: { type: 'boolean' } }, required: ['query'] },
+            execute: async (input, signal) => {
+                const query = String(input.query ?? '').trim();
+                if (query === '')
+                    return 'error: query is required';
+                if (input.refresh === true)
+                    semanticCache.clear();
+                const limit = typeof input.limit === 'number' && input.limit > 0 ? Math.min(input.limit, 10) : 5;
+                const chunks = await indexWorkspaceSemantics(client, semanticCache, state.workspace.root);
+                void saveSemanticIndex(state.workspace.root, semanticCache).catch(() => { });
+                if (chunks.length === 0)
+                    return 'no indexable text files in the workspace';
+                const [queryVector] = await client.embed([query], undefined, signal);
+                const ranked = chunks
+                    .map((chunk) => ({ chunk, score: cosineSimilarity(queryVector, chunk.embedding) }))
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, limit);
+                return ranked.map(({ chunk, score }) => `${chunk.path} (${score.toFixed(3)})\n  ${chunk.text.slice(0, 200)}`).join('\n');
+            },
+        },
+        update_todo: {
+            name: 'update_todo', description: 'Maintain the visible task queue the user watches: add a step, start it, complete it, or remove it. Keep steps small and current as you work.', highRisk: false, parameters: { type: 'object', properties: { action: { type: 'string', enum: ['add', 'update', 'start', 'complete', 'remove'] }, title: { type: 'string' }, id: { type: 'string' } }, required: ['action'] },
+            execute: async (input) => applyTodo(input),
+        },
+        write_memory: {
+            name: 'write_memory', description: 'Persist a fact to long-term memory so future sessions remember it. Use for decisions, learned constraints, and project state worth keeping.', highRisk: false, parameters: { type: 'object', properties: { fact: { type: 'string' } }, required: ['fact'] },
+            execute: async (input) => {
+                const fact = String(input.fact ?? '').trim();
+                if (fact === '')
+                    return 'error: fact is required';
+                await mkdir(join(state.workspace.root, '.omniharness'), { recursive: true });
+                await appendFile(memoryPath, `- ${new Date().toISOString()}: ${fact}\n`, 'utf8');
+                memory = `${memory}${memory === '' ? '' : '\n'}- ${fact}`;
+                return 'memory saved';
+            },
+        },
         start_preview: {
             name: 'start_preview', description: 'Start a local preview server for the workspace and report its URL. Provide the command to run.', highRisk: true, parameters: { type: 'object', properties: { command: { type: 'string' }, args: { type: 'array', items: { type: 'string' } }, port: { type: 'integer' } }, required: ['command'] },
             execute: async (input) => {
@@ -121,6 +236,27 @@ export async function createMastraEngine(config) {
             },
         };
     }
+    // When an OmniRoute management token is configured, discover the gateway's MCP
+    // tools and expose them to the agent. Best-effort: a discovery failure (gateway
+    // down, disabled MCP transport, wrong scopes) simply leaves the built-in tools.
+    let mcpTools = [];
+    if (client.hasMcpToken) {
+        try {
+            mcpTools = await client.listMcpTools();
+            for (const descriptor of mcpTools) {
+                if (systemTools[descriptor.name])
+                    continue; // never shadow a built-in tool
+                systemTools[descriptor.name] = {
+                    name: descriptor.name, description: descriptor.description ?? '', highRisk: false,
+                    parameters: descriptor.inputSchema ?? { type: 'object', properties: {} },
+                    execute: (input, signal) => client.callMcpTool(descriptor.name, input, signal),
+                };
+            }
+        }
+        catch {
+            mcpTools = [];
+        }
+    }
     const toolSchemas = Object.values(systemTools).map((entry) => ({
         type: 'function', function: { name: entry.name, description: entry.description, parameters: entry.parameters },
     }));
@@ -141,7 +277,7 @@ export async function createMastraEngine(config) {
         catch {
             parsed = {};
         }
-        if (approvalHandler && registered.highRisk) {
+        if (state.mode !== 'crazy' && approvalHandler && registered.highRisk) {
             emit({ type: 'approval_requested', tool: call.function.name, input: parsed });
             const approved = await approvalHandler({ tool: call.function.name, input: parsed });
             if (!approved)
@@ -155,7 +291,7 @@ export async function createMastraEngine(config) {
         }
     }
     return {
-        client, tools, state, skills,
+        client, tools, state, skills, mcpTools,
         subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
         setApprovalHandler(handler) { approvalHandler = handler; },
         async selectModel(model) {
@@ -165,119 +301,217 @@ export async function createMastraEngine(config) {
             }
             catch { /* persistence is best-effort */ }
         },
+        async attach(paths) {
+            const loaded = [];
+            const failures = [];
+            for (const raw of paths) {
+                const full = resolve(state.workspace.root, raw);
+                try {
+                    const info = await stat(full);
+                    if (!info.isFile()) {
+                        failures.push(`${raw}: not a file`);
+                        continue;
+                    }
+                    const kind = kindFromName(raw);
+                    const base = { name: raw, size: info.size, kind };
+                    const attachment = base;
+                    if (kind === 'image' && info.size <= 10 * 1024 * 1024) {
+                        const bytes = await readFile(full);
+                        attachment.dataUrl = `data:image/${mimeFromName(raw)};base64,${bytes.toString('base64')}`;
+                    }
+                    loaded.push(attachment);
+                    emit({ type: 'attach', name: raw, kind, size: info.size });
+                }
+                catch (reason) {
+                    failures.push(`${raw}: ${reason instanceof Error ? reason.message : String(reason)}`);
+                }
+            }
+            if (failures.length > 0)
+                throw new Error(`attach failed: ${failures.join('; ')}`);
+            pendingAttachments = loaded;
+            return loaded.map(({ dataUrl: _dataUrl, ...rest }) => rest);
+        },
         stop() { void stopPreviewChild(); listeners.clear(); },
+        cancel() { activeRunController?.abort(); },
+        async clearHistory() {
+            activeRunController?.abort();
+            state.messages = [];
+            state.taskQueue = [];
+            state.prompt = '';
+            try {
+                await clearSession(state.workspace.root);
+            }
+            catch { /* best-effort */ }
+        },
         async run(prompt, signal) {
+            // Abort any still-in-flight run (normally impossible: the UI submits serially)
+            // and register this run's controller so cancel() can abort it.
+            activeRunController?.abort();
+            const controller = new AbortController();
+            activeRunController = controller;
+            if (signal)
+                signal.addEventListener('abort', () => controller.abort(), { once: true });
+            const runSignal = controller.signal;
             state.prompt = prompt;
             state.taskStatus = 'running';
             const userMessage = { role: 'user', content: prompt, createdAt: new Date().toISOString() };
             state.messages = [...state.messages, userMessage];
             const wire = [
-                { role: 'system', content: SYSTEM_FRAME(client.endpoint, state.workspace.root, state.mode, skills.map((skill) => skill.name)) },
+                { role: 'system', content: SYSTEM_FRAME(client.endpoint, state.workspace.root, state.mode, skills.map((skill) => skill.name), memory) },
                 ...state.messages.map(asWireMessage),
             ];
+            if (pendingAttachments.length > 0) {
+                const note = attachmentBlock(pendingAttachments);
+                const images = pendingAttachments
+                    .filter((a) => a.dataUrl !== undefined)
+                    .map((a) => ({ type: 'image_url', image_url: { url: a.dataUrl } }));
+                wire[wire.length - 1] = images.length > 0
+                    ? { role: 'user', content: [{ type: 'text', text: `${note}${prompt}` }, ...images] }
+                    : { role: 'user', content: `${note}${prompt}` };
+                pendingAttachments = [];
+            }
             const results = [];
             let turn = 0;
             let model = activeModel;
             let content = '';
             let reasoning = '';
             let toolCalls = [];
-            const finishRound = async () => {
-                content = '';
-                reasoning = '';
-                toolCalls = [];
-                const result = await client.chatStream(state.activeModel, wire, {
-                    signal, tools: toolSchemas,
-                    onDelta: (delta) => {
-                        if (delta.type === 'reasoning') {
-                            reasoning += delta.delta;
-                            emit({ type: 'thinking_delta', delta: delta.delta });
-                        }
-                        else if (delta.type === 'text') {
-                            content += delta.delta;
-                            emit({ type: 'text_delta', delta: delta.delta });
-                        }
-                        else if (delta.type === 'tool_call') {
-                            if (!toolCalls.some((call) => call.id === delta.call.id)) {
-                                toolCalls.push(delta.call);
+            let compression;
+            try {
+                return await executeRound();
+            }
+            catch (reason) {
+                // An AbortError during streaming or a tool call is a user cancel, not a
+                // failure: report it as a cancelled turn rather than an error.
+                if (runSignal.aborted) {
+                    state.taskStatus = 'cancelled';
+                    emit({ type: 'text', content: '(cancelled)', model: activeModel });
+                    return { content: '(cancelled)', model: activeModel };
+                }
+                throw reason;
+            }
+            async function executeRound() {
+                const finishRound = async () => {
+                    content = '';
+                    reasoning = '';
+                    toolCalls = [];
+                    const result = await client.chatStream(state.activeModel, wire, {
+                        signal: runSignal, tools: toolSchemas,
+                        onDelta: (delta) => {
+                            if (delta.type === 'reasoning') {
+                                reasoning += delta.delta;
+                                emit({ type: 'thinking_delta', delta: delta.delta });
+                            }
+                            else if (delta.type === 'text') {
+                                content += delta.delta;
+                                emit({ type: 'text_delta', delta: delta.delta });
                             }
-                            else {
-                                toolCalls = toolCalls.map((call) => call.id === delta.call.id ? delta.call : call);
+                            else if (delta.type === 'tool_call') {
+                                if (!toolCalls.some((call) => call.id === delta.call.id)) {
+                                    toolCalls.push(delta.call);
+                                }
+                                else {
+                                    toolCalls = toolCalls.map((call) => call.id === delta.call.id ? delta.call : call);
+                                }
                             }
+                        },
+                    });
+                    if (result.model)
+                        model = result.model;
+                    if (result.compression)
+                        compression = result.compression;
+                };
+                await finishRound();
+                while (toolCalls.length > 0) {
+                    if (runSignal.aborted) {
+                        state.taskStatus = 'cancelled';
+                        emit({ type: 'text', content: '(cancelled)', model: activeModel });
+                        return { content: '(cancelled)', model: activeModel };
+                    }
+                    if (reasoning) {
+                        emit({ type: 'thinking', text: reasoning });
+                        state.messages = [...state.messages, { role: 'thought', content: reasoning, createdAt: new Date().toISOString() }];
+                    }
+                    wire.push({ role: 'assistant', content, tool_calls: toolCalls });
+                    let executedAny = false;
+                    for (const call of toolCalls) {
+                        if (runSignal.aborted)
+                            break;
+                        turn += 1;
+                        if (turn > MAX_TURNS[state.mode]) {
+                            const error = `too many tool turns (limit ${MAX_TURNS[state.mode]})`;
+                            state.messages = [...state.messages, { role: 'error', content: error, createdAt: new Date().toISOString() }];
+                            state.taskStatus = 'failed';
+                            return { content: error + '; latest text: ' + content, model: activeModel };
                         }
-                    },
-                });
-                if (result.model)
-                    model = result.model;
-            };
-            await finishRound();
-            while (toolCalls.length > 0) {
+                        emit({ type: 'tool_start', tool: call.function.name, input: undefined });
+                        const output = await runTool(call, runSignal);
+                        const summary = output.split('\n')[0] ?? '';
+                        emit({ type: 'tool_result', tool: call.function.name, summary });
+                        results.push({ call, output });
+                        wire.push({ role: 'tool', tool_call_id: call.id, content: truncate(output) });
+                        executedAny = true;
+                    }
+                    if (!executedAny)
+                        break;
+                    content = '';
+                    reasoning = '';
+                    toolCalls = [];
+                    const next = await client.chatStream(state.activeModel, wire, {
+                        signal: runSignal, tools: toolSchemas,
+                        onDelta: (delta) => {
+                            if (delta.type === 'reasoning') {
+                                reasoning += delta.delta;
+                                emit({ type: 'thinking_delta', delta: delta.delta });
+                            }
+                            else if (delta.type === 'text') {
+                                content += delta.delta;
+                                emit({ type: 'text_delta', delta: delta.delta });
+                            }
+                            else if (delta.type === 'tool_call') {
+                                if (!toolCalls.some((call) => call.id === delta.call.id)) {
+                                    toolCalls.push(delta.call);
+                                }
+                                else {
+                                    toolCalls = toolCalls.map((call) => call.id === delta.call.id ? delta.call : call);
+                                }
+                            }
+                        },
+                    });
+                    if (next.model)
+                        model = next.model;
+                    if (next.compression)
+                        compression = next.compression;
+                }
+                state.taskStatus = 'completed';
+                state.metrics = client.snapshotMetrics();
+                if (state.mode === 'crazy') {
+                    const summary = content.split('\n')[0]?.slice(0, 160) ?? '';
+                    try {
+                        await mkdir(join(state.workspace.root, '.omniharness'), { recursive: true });
+                        await appendFile(memoryPath, `- ${new Date().toISOString()}: ran "${prompt.slice(0, 80)}" → ${summary}\n`, 'utf8');
+                    }
+                    catch { /* memory persistence is best-effort */ }
+                }
+                const answer = content;
                 if (reasoning) {
                     emit({ type: 'thinking', text: reasoning });
                     state.messages = [...state.messages, { role: 'thought', content: reasoning, createdAt: new Date().toISOString() }];
                 }
-                wire.push({ role: 'assistant', content, tool_calls: toolCalls });
-                let executedAny = false;
-                for (const call of toolCalls) {
-                    if (signal?.aborted)
-                        break;
-                    turn += 1;
-                    if (turn > MAX_TURNS) {
-                        const error = `too many tool turns (limit ${MAX_TURNS})`;
-                        state.messages = [...state.messages, { role: 'error', content: error, createdAt: new Date().toISOString() }];
-                        state.taskStatus = 'failed';
-                        return { content: error + '; latest text: ' + content, model: activeModel };
-                    }
-                    emit({ type: 'tool_start', tool: call.function.name, input: undefined });
-                    const output = await runTool(call, signal);
-                    const summary = output.split('\n')[0] ?? '';
-                    emit({ type: 'tool_result', tool: call.function.name, summary });
-                    results.push({ call, output });
-                    wire.push({ role: 'tool', tool_call_id: call.id, content: truncate(output) });
-                    executedAny = true;
+                for (const result of results) {
+                    const tool = result.call.function.name;
+                    state.messages = [...state.messages, { role: 'tool', content: result.output.slice(0, 500), toolName: tool, createdAt: new Date().toISOString() }];
                 }
-                if (!executedAny)
-                    break;
-                content = '';
-                reasoning = '';
-                toolCalls = [];
-                const next = await client.chatStream(state.activeModel, wire, {
-                    signal, tools: toolSchemas,
-                    onDelta: (delta) => {
-                        if (delta.type === 'reasoning') {
-                            reasoning += delta.delta;
-                            emit({ type: 'thinking_delta', delta: delta.delta });
-                        }
-                        else if (delta.type === 'text') {
-                            content += delta.delta;
-                            emit({ type: 'text_delta', delta: delta.delta });
-                        }
-                        else if (delta.type === 'tool_call') {
-                            if (!toolCalls.some((call) => call.id === delta.call.id)) {
-                                toolCalls.push(delta.call);
-                            }
-                            else {
-                                toolCalls = toolCalls.map((call) => call.id === delta.call.id ? delta.call : call);
-                            }
-                        }
-                    },
-                });
-                if (next.model)
-                    model = next.model;
-            }
-            state.taskStatus = 'completed';
-            state.metrics = client.snapshotMetrics();
-            const answer = content;
-            if (reasoning) {
-                emit({ type: 'thinking', text: reasoning });
-                state.messages = [...state.messages, { role: 'thought', content: reasoning, createdAt: new Date().toISOString() }];
-            }
-            for (const result of results) {
-                const tool = result.call.function.name;
-                state.messages = [...state.messages, { role: 'tool', content: result.output.slice(0, 500), toolName: tool, createdAt: new Date().toISOString() }];
+                emit({ type: 'text', content: answer, model, compression });
+                state.messages = [...state.messages, { role: 'assistant', content: answer, model, createdAt: new Date().toISOString() }];
+                try {
+                    await saveSession(state.workspace.root, {
+                        messages: [...state.messages], taskQueue: [...state.taskQueue], savedAt: new Date().toISOString(),
+                    });
+                }
+                catch { /* session persistence is best-effort */ }
+                return { content: answer, model };
             }
-            emit({ type: 'text', content: answer });
-            state.messages = [...state.messages, { role: 'assistant', content: answer, model, createdAt: new Date().toISOString() }];
-            return { content: answer, model };
         },
     };
 }
@@ -286,7 +520,77 @@ function asWireMessage(message) {
         return { role: message.role, content: message.content };
     return { role: 'assistant', content: message.content };
 }
+function mimeFromName(name) {
+    const ext = name.slice(name.lastIndexOf('.') + 1).toLowerCase();
+    return ext === 'jpg' ? 'jpeg' : ext === 'svg' ? 'svg+xml' : ext;
+}
 function truncate(text, max = 4000) {
     return text.length <= max ? text : `${text.slice(0, max)}\n… (truncated ${text.length - max} chars)`;
 }
+const MAX_INDEX_FILES = 200;
+const MAX_INDEX_BYTES = 256 * 1024;
+/** Reuse cached embeddings for unchanged files; embed new/changed ones, batched. */
+async function indexWorkspaceSemantics(client, cache, root) {
+    const files = [];
+    async function walk(directory) {
+        if (files.length >= MAX_INDEX_FILES)
+            return;
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (files.length >= MAX_INDEX_FILES)
+                return;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const target = resolve(directory, entry.name);
+            if (entry.isDirectory())
+                await walk(target);
+            else if (entry.isFile()) {
+                try {
+                    const info = await stat(target);
+                    if (info.size > 0 && info.size <= MAX_INDEX_BYTES)
+                        files.push({ path: target, mtimeMs: info.mtimeMs });
+                }
+                catch { /* unreadable file: skip */ }
+            }
+        }
+    }
+    await walk(root);
+    const results = [];
+    const changed = new Map();
+    for (const file of files) {
+        const cached = cache.get(file.path);
+        if (cached && cached.mtimeMs === file.mtimeMs) {
+            results.push(...cached.chunks);
+            continue;
+        }
+        try {
+            const text = await readFile(file.path, 'utf8');
+            changed.set(file.path, { mtimeMs: file.mtimeMs, chunks: [] });
+            for (const piece of chunkText(text))
+                changed.get(file.path).chunks.push({ path: file.path, text: piece, embedding: [] });
+        }
+        catch { /* binary/unreadable: skip */ }
+    }
+    const toEmbed = [];
+    for (const entry of changed.values())
+        toEmbed.push(...entry.chunks);
+    for (let i = 0; i < toEmbed.length; i += 16) {
+        const batch = toEmbed.slice(i, i + 16);
+        const vectors = await client.embed(batch.map((chunk) => chunk.text));
+        batch.forEach((chunk, index) => { chunk.embedding = vectors[index]; });
+    }
+    for (const file of files) {
+        const entry = changed.get(file.path);
+        if (entry) {
+            cache.set(file.path, entry);
+            results.push(...entry.chunks);
+        }
+    }
+    // Drop cached entries for files no longer present so the persisted index stays clean.
+    const present = new Set(files.map((file) => file.path));
+    for (const path of [...cache.keys()]) {
+        if (!present.has(path))
+            cache.delete(path);
+    }
+    return results;
+}
 //# sourceMappingURL=mastraEngine.js.map