@agent-spaces/server 0.3.0 → 0.3.2

package/dist/adapters/claude-code-runtime/index.js

@@ -36,6 +36,7 @@ export class ClaudeCodeRuntime {
         d(`starting | cwd=${cwd} model=${model ?? 'default'} targetModel=${this.config.model ?? 'default'} provider=${this.config.provider ?? 'default'} baseURL=${baseURL ?? 'default'} permissionMode=${permissionMode} maxTurns=${options?.maxTurns ?? '∞'} tools=claude_code mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillNames.join(',') || '-'} configDir=${configDir ?? 'default'} sandboxDirs=${additionalDirectories.join(',') || '-'} claudeExecutable=${claudeExecutable ?? 'sdk-default'}`);
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         d(`sdk mcp servers | ${sdkMcpServerNames.join(',') || '-'}`);
+        const stderrLines = [];
         try {
             const queryOptions = {
                 cwd,
@@ -48,7 +49,7 @@ export class ClaudeCodeRuntime {
                 managedSettings: {
                     strictPluginOnlyCustomization: ['mcp'],
                 },
-                settingSources: [],
+                settingSources: ['user', 'project', 'local'],
                 strictMcpConfig: true,
                 additionalDirectories,
                 permissionMode,
@@ -57,8 +58,10 @@ export class ClaudeCodeRuntime {
                 env: buildEnv(this.config, configDir, { baseURL, apiKey }),
                 stderr: (data) => {
                     const line = data.trim();
-                    if (line)
+                    if (line) {
+                        stderrLines.push(line);
                         d(`stderr: ${line}`);
+                    }
                 },
             };
             this.activeQuery = query({ prompt, options: queryOptions });
@@ -69,6 +72,7 @@ export class ClaudeCodeRuntime {
             let usageLine = null;
             let usage;
             let costUsd;
+            let sawResult = false;
             const pendingAskUserQuestionToolIds = new Set();
             let waitingForUserAnswer = false;
             for await (const message of this.activeQuery) {
@@ -106,6 +110,7 @@ export class ClaudeCodeRuntime {
                     options?.onEvent?.({ type: 'output', line });
                 }
                 if (message.type === 'result') {
+                    sawResult = true;
                     turns = message.num_turns;
                     tokenCount = countUsageTokens(message.usage);
                     usageLine = formatUsageLine(message.usage);
@@ -122,6 +127,22 @@ export class ClaudeCodeRuntime {
                 }
             }
             const elapsed = Date.now() - startTime;
+            if (!sawResult) {
+                const runtimeError = extractRuntimeError([...stderrLines, ...output])
+                    || 'Claude Code execution stopped before reporting a final result';
+                d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                appendUnique(output, stderrLines);
+                appendUnique(output, [runtimeError]);
+                return {
+                    success: false,
+                    summary: 'Claude Code execution failed',
+                    artifacts: [],
+                    error: runtimeError,
+                    output,
+                    usage,
+                    costUsd,
+                };
+            }
             if (waitingForUserAnswer && (!error || isAskUserQuestionAutoResult(error))) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
                 if (usageLine)
@@ -136,14 +157,16 @@ export class ClaudeCodeRuntime {
                 };
             }
             if (error) {
-                d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${error}`);
+                const runtimeError = extractRuntimeError([error, ...stderrLines, ...output]) || error;
+                d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                appendUnique(output, stderrLines);
                 if (usageLine)
                     output.push(usageLine);
                 return {
                     success: false,
                     summary: 'Claude Code execution failed',
                     artifacts: [],
-                    error,
+                    error: runtimeError,
                     output,
                     usage,
                     costUsd,
@@ -169,10 +192,13 @@ export class ClaudeCodeRuntime {
         catch (err) {
             const elapsed = Date.now() - startTime;
             const message = err instanceof Error ? err.message : String(err);
-            d(`failed ${elapsed}ms | ${message}`);
+            const runtimeError = extractRuntimeError([message, ...stderrLines, ...output]) || message;
+            d(`failed ${elapsed}ms | ${runtimeError}`);
             if (err instanceof Error && err.stack)
                 console.error(err.stack);
-            return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: message, output };
+            appendUnique(output, stderrLines);
+            appendUnique(output, [runtimeError]);
+            return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: runtimeError, output };
         }
         finally {
             this.activeQuery?.close();
@@ -195,4 +221,20 @@ function readTotalCostUsd(message) {
     const value = message.total_cost_usd;
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
+function extractRuntimeError(lines) {
+    const text = lines
+        .filter((line) => typeof line === 'string' && line.trim().length > 0)
+        .join('\n');
+    if (!text)
+        return undefined;
+    const match = text.match(/(?:API Error|Request rejected|Too Many Requests|rate limit|overloaded|429)[^\n]*/i);
+    return match?.[0]?.trim();
+}
+function appendUnique(target, lines) {
+    for (const line of lines) {
+        if (!line || target.includes(line))
+            continue;
+        target.push(line);
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/adapters/claude-code-runtime/message-format.js

@@ -5,9 +5,9 @@ export function formatMessage(message) {
         case 'result':
             return message.subtype === 'success' ? message.result : message.errors.join('\n');
         case 'system':
-            if (message.subtype === 'init') {
-                return `Claude Code initialized with ${message.model}`;
-            }
+            // if (message.subtype === 'init') {
+            //   return `Claude Code initialized with ${message.model}`;
+            // }
             if (message.subtype === 'task_started') {
                 return message.description;
             }

package/dist/adapters/git.js

@@ -50,6 +50,8 @@ function mapStatus(raw) {
         ahead: raw.ahead,
         behind: raw.behind,
         clean: raw.isClean(),
+        insertions: 0,
+        deletions: 0,
     };
 }
 function mapStatusCode(code) {
@@ -67,7 +69,39 @@ export async function gitStatus(workspaceId) {
         throw new Error('Workspace not found');
     const git = getGit(ws);
     const raw = await git.status();
-    return mapStatus(raw);
+    const result = mapStatus(raw);
+    if (!result.clean) {
+        try {
+            // Tracked changes: modified/deleted/renamed
+            const trackedStat = await git.diff(['--shortstat']);
+            let insertions = 0, deletions = 0;
+            const mIns = trackedStat.match(/(\d+) insertion/);
+            const mDel = trackedStat.match(/(\d+) deletion/);
+            if (mIns)
+                insertions += parseInt(mIns[1]);
+            if (mDel)
+                deletions += parseInt(mDel[1]);
+            // Staged new files: --cached --shortstat
+            const stagedStat = await git.diff(['--cached', '--shortstat']);
+            const sIns = stagedStat.match(/(\d+) insertion/);
+            const sDel = stagedStat.match(/(\d+) deletion/);
+            if (sIns)
+                insertions += parseInt(sIns[1]);
+            if (sDel)
+                deletions += parseInt(sDel[1]);
+            result.insertions = insertions;
+            result.deletions = deletions;
+        }
+        catch {
+            result.insertions = 0;
+            result.deletions = 0;
+        }
+    }
+    else {
+        result.insertions = 0;
+        result.deletions = 0;
+    }
+    return result;
 }
 export async function gitDiff(workspaceId, filePath) {
     const ws = getWorkspace(workspaceId);
@@ -148,7 +182,14 @@ export async function gitDiscard(workspaceId, filePath) {
     if (!ws)
         throw new Error('Workspace not found');
     const git = getGit(ws);
-    await git.checkout(['--', filePath]);
+    const status = await git.status();
+    const isUntracked = status.not_added.includes(filePath);
+    if (isUntracked) {
+        await git.clean('f', ['-d', '--', filePath]);
+    }
+    else {
+        await git.checkout(['--', filePath]);
+    }
 }
 export async function gitDiscardAll(workspaceId) {
     const ws = getWorkspace(workspaceId);
@@ -247,6 +288,103 @@ export async function gitAddRemote(workspaceId, name, url) {
         await git.addRemote(name, url);
     }
 }
+export async function gitCheckoutDetached(workspaceId, commitHash) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.checkout([commitHash]);
+}
+export async function gitCherryPick(workspaceId, commitHash) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.raw(['cherry-pick', commitHash]);
+}
+export async function gitCreateBranch(workspaceId, name, startPoint) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const args = startPoint ? [name, startPoint] : [name];
+    await git.branch(args);
+}
+export async function gitDeleteBranch(workspaceId, name, force = false) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.branch([force ? '-D' : '-d', name]);
+}
+export async function gitCreateTag(workspaceId, name, commitHash) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const args = [name];
+    if (commitHash)
+        args.push(commitHash);
+    await git.addTag(args.join(' '));
+}
+export async function gitCommitDiff(workspaceId, commitHash) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const diff = await git.diff([`${commitHash}^`, commitHash]);
+    const nameOnlyRaw = await git.diff(['--name-only', `${commitHash}^`, commitHash]);
+    const files = nameOnlyRaw.split('\n').filter(Boolean);
+    const diffs = [];
+    for (const f of files) {
+        const oldContent = await git.show([`${commitHash}^:${f}`]).catch(() => '');
+        const newContent = await git.show([`${commitHash}:${f}`]).catch(() => '');
+        diffs.push({ path: f, oldContent, newContent, isBinary: false, isNew: !oldContent, isDeleted: !newContent });
+    }
+    return diffs;
+}
+export async function gitGetRemoteUrl(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const remotes = await git.getRemotes(true);
+    return remotes.find(r => r.name === 'origin')?.refs?.push ?? null;
+}
+export async function gitMergeBase(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const result = await git.raw(['merge-base', 'HEAD', 'origin/HEAD']).catch(() => '');
+    return result.trim();
+}
+export async function gitGetConfig(scope, workspaceId) {
+    const scopeFlag = scope === 'global' ? '--global' : '--local';
+    const git = workspaceId ? getGit(getWorkspace(workspaceId)) : simpleGit();
+    const get = (key) => git.raw(['config', scopeFlag, '--get', key]).then(v => v.trim()).catch(() => '');
+    const [name, email, proxy] = await Promise.all([
+        get('user.name'),
+        get('user.email'),
+        get('http.proxy'),
+    ]);
+    return { name, email, proxy };
+}
+export async function gitSetConfig(scope, config, workspaceId) {
+    const scopeFlag = scope === 'global' ? '--global' : '--local';
+    const git = workspaceId ? getGit(getWorkspace(workspaceId)) : simpleGit();
+    const set = (key, value) => {
+        if (value)
+            return git.raw(['config', scopeFlag, key, value]);
+        return git.raw(['config', scopeFlag, '--unset', key]).catch(() => { });
+    };
+    await Promise.all([
+        config.name !== undefined ? set('user.name', config.name) : Promise.resolve(),
+        config.email !== undefined ? set('user.email', config.email) : Promise.resolve(),
+        config.proxy !== undefined ? set('http.proxy', config.proxy) : Promise.resolve(),
+        config.proxy !== undefined ? set('https.proxy', config.proxy) : Promise.resolve(),
+    ]);
+}
 export async function gitInit(workspaceId) {
     const ws = getWorkspace(workspaceId);
     if (!ws)

package/dist/agents/agent-designer.js

@@ -0,0 +1,334 @@
+import { AGENT_GENERATOR_PRESET_ID, readAgentTemplate } from '../services/agent.js';
+const SYSTEM_PROMPT = `You generate Agent Spaces agent presets.
+Return only a valid JSON object with this exact schema:
+{
+  "name": "short agent name",
+  "description": "one sentence description",
+  "systemPrompt": "markdown system prompt"
+}
+
+Rules:
+- Do not wrap the JSON in markdown fences.
+- name must be concise and suitable for a UI label.
+- description must explain the agent's responsibility.
+- systemPrompt must be valid Markdown and include role, responsibilities, workflow, constraints, and output expectations.
+- Keep the systemPrompt actionable and specific to the user's request.`;
+export async function generateAgentDesign(userPrompt) {
+    const prompt = userPrompt.trim();
+    if (!prompt)
+        throw new Error('prompt is required');
+    const config = resolveModelConfig();
+    if (!config) {
+        throw new Error(`Configure model settings for ${AGENT_GENERATOR_PRESET_ID} before generating agents.`);
+    }
+    console.info('[agent-designer] generating agent design', {
+        agentId: AGENT_GENERATOR_PRESET_ID,
+        provider: config.modelProvider ?? inferProvider(config.apiBase),
+        modelId: config.modelId,
+        apiBase: maskUrl(config.apiBase),
+        promptLength: prompt.length,
+    });
+    const content = await requestDesign(config, prompt);
+    console.info('[agent-designer] model text extracted', {
+        length: content.length,
+        preview: content.slice(0, 500),
+    });
+    return normalizeDesign(parseJsonObject(content));
+}
+function resolveModelConfig() {
+    const preset = readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
+    if (preset?.apiBase && preset.apiKey && preset.modelId) {
+        return {
+            modelProvider: preset.modelProvider,
+            modelId: preset.modelId,
+            apiBase: preset.apiBase,
+            apiKey: preset.apiKey,
+            systemPrompt: preset.systemPrompt,
+            temperature: preset.temperature,
+            maxTokens: preset.maxTokens,
+        };
+    }
+    return null;
+}
+async function requestDesign(config, userPrompt) {
+    const provider = config.modelProvider ?? inferProvider(config.apiBase);
+    if (provider === 'anthropic-messages')
+        return requestAnthropic(config, userPrompt);
+    if (provider === 'gemini-generate-content')
+        return requestGemini(config, userPrompt);
+    return requestOpenAICompatible(config, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
+}
+async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
+    const url = joinUrl(config.apiBase, useResponsesApi ? '/responses' : '/chat/completions');
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(useResponsesApi
+            ? {
+                model: config.modelId,
+                input: `${buildSystemPrompt(config)}\n\nUser request:\n${userPrompt}`,
+                temperature: config.temperature ?? 0.2,
+                max_output_tokens: config.maxTokens,
+            }
+            : {
+                model: config.modelId,
+                messages: [
+                    { role: 'system', content: buildSystemPrompt(config) },
+                    { role: 'user', content: userPrompt },
+                ],
+                temperature: config.temperature ?? 0.2,
+                max_tokens: config.maxTokens,
+            }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
+    return body.text;
+}
+async function requestAnthropic(config, userPrompt) {
+    const response = await fetch(getAnthropicMessagesUrl(config.apiBase), {
+        method: 'POST',
+        headers: {
+            'x-api-key': config.apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: config.modelId,
+            system: buildSystemPrompt(config),
+            messages: [{ role: 'user', content: userPrompt }],
+            max_tokens: config.maxTokens ?? 4096,
+            temperature: config.temperature ?? 0.2,
+        }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
+    return body.text;
+}
+async function requestGemini(config, userPrompt) {
+    const response = await fetch(joinUrl(config.apiBase, `/models/${encodeURIComponent(config.modelId)}:generateContent`), {
+        method: 'POST',
+        headers: {
+            'x-goog-api-key': config.apiKey,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            systemInstruction: { parts: [{ text: buildSystemPrompt(config) }] },
+            contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
+            generationConfig: {
+                temperature: config.temperature ?? 0.2,
+                maxOutputTokens: config.maxTokens,
+            },
+        }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
+    return body.text;
+}
+function buildSystemPrompt(config) {
+    const custom = config.systemPrompt?.trim();
+    if (!custom)
+        return SYSTEM_PROMPT;
+    return `${custom}\n\n${SYSTEM_PROMPT}`;
+}
+async function readResponseBody(response) {
+    const raw = await response.text();
+    if (!raw)
+        return { text: '' };
+    try {
+        const json = JSON.parse(raw);
+        console.info('[agent-designer] provider response received', {
+            status: response.status,
+            keys: Object.keys(json),
+            preview: raw.slice(0, 800),
+        });
+        if (isAgentDesignJson(json))
+            return { text: JSON.stringify(json) };
+        return {
+            text: extractText(json),
+            error: extractError(json),
+        };
+    }
+    catch {
+        console.info('[agent-designer] provider raw text received', {
+            status: response.status,
+            preview: raw.slice(0, 800),
+        });
+        return { text: raw };
+    }
+}
+function extractText(json) {
+    const outputText = json.output_text;
+    if (typeof outputText === 'string')
+        return outputText;
+    const output = Array.isArray(json.output) ? json.output : [];
+    const responseOutputText = output
+        .flatMap((item) => Array.isArray(item.content) ? item.content : [])
+        .map((part) => {
+        const record = part;
+        return typeof record.text === 'string' ? record.text : '';
+    })
+        .filter(Boolean)
+        .join('\n');
+    if (responseOutputText)
+        return responseOutputText;
+    const choices = Array.isArray(json.choices) ? json.choices : [];
+    const firstChoice = choices[0];
+    if (typeof firstChoice?.text === 'string')
+        return firstChoice.text;
+    const message = firstChoice?.message;
+    if (typeof message?.content === 'string')
+        return message.content;
+    if (Array.isArray(message?.content)) {
+        const messageText = message.content
+            .map((part) => typeof part.text === 'string' ? part.text : '')
+            .filter(Boolean)
+            .join('\n');
+        if (messageText)
+            return messageText;
+    }
+    const content = Array.isArray(json.content) ? json.content : [];
+    const anthropicText = content
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+    if (anthropicText)
+        return anthropicText;
+    const candidates = Array.isArray(json.candidates) ? json.candidates : [];
+    const firstCandidate = candidates[0];
+    const parts = (firstCandidate?.content?.parts ?? []);
+    return parts
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+}
+function isAgentDesignJson(json) {
+    return typeof json.name === 'string'
+        && typeof json.description === 'string'
+        && typeof json.systemPrompt === 'string';
+}
+function extractError(json) {
+    if (json.success === false) {
+        return typeof json.msg === 'string' ? json.msg : 'Provider returned success=false';
+    }
+    const error = json.error;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const message = error.message;
+        if (typeof message === 'string')
+            return message;
+    }
+    return typeof json.message === 'string' ? json.message : undefined;
+}
+function parseJsonObject(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '');
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim();
+        if (fenced)
+            return JSON.parse(fenced);
+        const candidate = findFirstJsonObject(trimmed);
+        if (candidate)
+            return JSON.parse(candidate);
+        throw new Error('Model did not return valid JSON.');
+    }
+}
+function findFirstJsonObject(text) {
+    const starts = [];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] === '{')
+            starts.push(index);
+    }
+    for (const start of starts) {
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = start; index < text.length; index += 1) {
+            const char = text[index];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (char === '{')
+                depth += 1;
+            if (char === '}')
+                depth -= 1;
+            if (depth === 0) {
+                const candidate = text.slice(start, index + 1);
+                try {
+                    JSON.parse(candidate);
+                    return candidate;
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+    }
+    return null;
+}
+function normalizeDesign(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Generated agent design must be a JSON object.');
+    }
+    const data = value;
+    const name = typeof data.name === 'string' ? data.name.trim() : '';
+    const description = typeof data.description === 'string' ? data.description.trim() : '';
+    const systemPrompt = typeof data.systemPrompt === 'string' ? data.systemPrompt.trim() : '';
+    if (!name || !description || !systemPrompt) {
+        throw new Error('Generated JSON must include name, description, and systemPrompt.');
+    }
+    return { name, description, systemPrompt };
+}
+function inferProvider(apiBase) {
+    if (apiBase?.includes('anthropic.com'))
+        return 'anthropic-messages';
+    if (apiBase?.includes('generativelanguage.googleapis.com'))
+        return 'gemini-generate-content';
+    return 'openai-chat-completions';
+}
+function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, '')}${path}`;
+}
+function getAnthropicMessagesUrl(apiBase) {
+    try {
+        const url = new URL(apiBase);
+        if (url.pathname.endsWith('/messages'))
+            return apiBase;
+        if (url.hostname === 'api.anthropic.com') {
+            return joinUrl(apiBase, '/messages');
+        }
+        return joinUrl(apiBase, '/v1/messages');
+    }
+    catch {
+        return apiBase;
+    }
+}
+function maskUrl(value) {
+    try {
+        const url = new URL(value);
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return value.slice(0, 120);
+    }
+}
+//# sourceMappingURL=agent-designer.js.map

package/dist/agents/agent-message-parts.js

@@ -134,6 +134,8 @@ function normalizeOutputLines(output) {
         .filter((line) => line.trim());
     const seenInitLines = new Set();
     return lines.filter((line) => {
+        if (isIgnorableToolProgressLine(line))
+            return false;
         if (!/^Claude Code initialized\b/i.test(line))
             return true;
         if (seenInitLines.has(line))
@@ -429,6 +431,12 @@ function summarizeMessageTitle(text) {
 function isToolLikeLine(line) {
     return /^(Using|Tool:|Read|Write|Edit|MultiEdit|Bash|Search|Grep|Glob|Todo|Task|Web|Fetch|Claude Code initialized|Codex initialized|.+ running \(\d+s\))/i.test(line.trim());
 }
+function isIgnorableToolProgressLine(line) {
+    const trimmed = line.trim();
+    return /^Claude$/i.test(trimmed)
+        || /^(Reading|Searching)(\.{1,3}|…)?$/i.test(trimmed)
+        || /^(Read|Search|Grep|Glob|SemanticSearch|WebSearch)\s+running\s+\(\d+s\)$/i.test(trimmed);
+}
 function isFinalAnswerLine(line) {
     return !isToolLikeLine(line) && !/^(\[.*\]|Agent runtime configuration:|Conversation history:)/.test(line.trim());
 }

package/dist/agents/commit-agent.js

@@ -2,6 +2,7 @@ import * as agentService from '../services/agent.js';
 import { createAgentRuntime } from '../adapters/agent-runtime.js';
 import { getWorkspace } from '../storage/workspace-store.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { simpleGit } from 'simple-git';
 const DEFAULT_SYSTEM_PROMPT = [
     'You are a git commit message generator.',
@@ -36,13 +37,19 @@ export async function runCommitAgent(workspaceId) {
     const workingDir = agentService.resolveWorkingDir(workspaceId, commitAgent);
     const systemPrompt = commitAgent.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
     const truncatedDiff = diff.length > 8000 ? diff.substring(0, 8000) + '\n... (truncated)' : diff;
-    const result = await runtime.execute([
+    const result = await runtime.execute(prependPersistentAgentContext([
         'Generate exactly one commit message for these changes.',
         'Do not inspect files or run commands. Use only this diff.',
         'Output only the commit message.',
         '',
         truncatedDiff,
-    ].join('\n'), workingDir, {
+    ].join('\n'), {
+        workspaceId,
+        workingDir,
+        boundDirs: ws.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: commitAgent.runtimeKind === 'claude-code',
+    }), workingDir, {
         maxTurns: 1,
         systemPrompt,
     });