@agent-spaces/server 0.3.63 → 0.3.65

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

@@ -4,7 +4,7 @@ import { summarizeResult } from '../agent-runtime-types.js';
 import { prepareClaudeOutputStyleFile } from '../../services/output-style.js';
 import { normalizeAdditionalDirectories, normalizePermissionMode, normalizeSkillNames, prepareConfigDir, resolveBundledClaudeExecutable, buildEnv, normalizeMcpServers } from './sdk-config.js';
 import { startClaudeAdapterIfNeeded, getClaudeCodeModel } from './adapter-pool.js';
-import { extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
+import { extractClaudeHookEvents, extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
 export class ClaudeCodeRuntime {
     config;
     abortController = null;
@@ -39,7 +39,33 @@ export class ClaudeCodeRuntime {
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         d(`sdk mcp servers | ${sdkMcpServerNames.join(',') || '-'}`);
         const stderrLines = [];
+        let sessionId = options?.resumeSessionId;
+        const emitHook = (event, matcher = '*', payload) => {
+            options?.onEvent?.({ type: 'hook_event', event, matcher, payload });
+        };
         try {
+            emitHook('SessionStart', '*', {
+                cwd,
+                model,
+                provider: this.config.provider,
+                baseURL,
+                permissionMode,
+                configDir,
+                sandboxDirs: additionalDirectories,
+                resumeSessionId: options?.resumeSessionId,
+            });
+            const hookUserPrompt = options?.userPrompt ?? prompt;
+            emitHook('UserPromptSubmit', '*', {
+                prompt: hookUserPrompt,
+                message: hookUserPrompt,
+                userMessage: hookUserPrompt,
+                fullPrompt: prompt,
+                cwd,
+                configDir,
+            });
+            if (/CLAUDE\.md|AGENTS\.md|\.claude\/rules\//.test(prompt)) {
+                emitHook('InstructionsLoaded', '*', { source: 'prompt', promptPreview: prompt.slice(0, 1000) });
+            }
             const queryOptions = {
                 cwd,
                 model,
@@ -76,11 +102,13 @@ export class ClaudeCodeRuntime {
             let usageLine = null;
             let usage;
             let costUsd;
-            let sessionId = options?.resumeSessionId;
             let sawResult = false;
             const pendingAskUserQuestionToolIds = new Set();
             let waitingForUserAnswer = false;
             for await (const message of this.activeQuery) {
+                for (const hookEvent of extractClaudeHookEvents(message)) {
+                    emitHook(hookEvent.event, hookEvent.matcher, hookEvent.payload);
+                }
                 const nextSessionId = readSessionId(message);
                 if (nextSessionId && nextSessionId !== sessionId) {
                     sessionId = nextSessionId;
@@ -145,6 +173,17 @@ export class ClaudeCodeRuntime {
             const elapsed = Date.now() - startTime;
             if (waitingForUserAnswer) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -161,6 +200,7 @@ export class ClaudeCodeRuntime {
                 const runtimeError = extractRuntimeError([...stderrLines, ...output])
                     || 'Claude Code execution stopped before reporting a final result';
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 appendUnique(output, [runtimeError]);
                 return {
@@ -176,6 +216,17 @@ export class ClaudeCodeRuntime {
             }
             if (waitingForUserAnswer && (!error || isAskUserQuestionAutoResult(error))) {
                 d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                const message = resultText || output.at(-1) || 'Waiting for user answer';
+                emitHook('Stop', '*', {
+                    status: 'waiting_for_user_answer',
+                    message,
+                    finalMessage: message,
+                    output,
+                    elapsedMs: elapsed,
+                    turns,
+                    tokenCount,
+                    sessionId,
+                });
                 if (usageLine)
                     output.push(usageLine);
                 return {
@@ -191,6 +242,7 @@ export class ClaudeCodeRuntime {
             if (error) {
                 const runtimeError = extractRuntimeError([error, ...stderrLines, ...output]) || error;
                 d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${runtimeError}`);
+                emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, turns, tokenCount, sessionId, stderr: stderrLines });
                 appendUnique(output, stderrLines);
                 if (usageLine)
                     output.push(usageLine);
@@ -213,6 +265,18 @@ export class ClaudeCodeRuntime {
             const finalOutput = resultText && !output.includes(resultText) ? [...output, resultText] : output;
             if (usageLine && !finalOutput.includes(usageLine))
                 finalOutput.push(usageLine);
+            emitHook('Stop', '*', {
+                status: 'success',
+                message: text,
+                finalMessage: text,
+                output: finalOutput,
+                elapsedMs: elapsed,
+                turns,
+                tokenCount,
+                sessionId,
+                usage,
+                costUsd,
+            });
             return {
                 success: true,
                 summary: summarizeResult(text),
@@ -230,11 +294,13 @@ export class ClaudeCodeRuntime {
             d(`failed ${elapsed}ms | ${runtimeError}`);
             if (err instanceof Error && err.stack)
                 console.error(err.stack);
+            emitHook('StopFailure', '*', { error: runtimeError, elapsedMs: elapsed, stderr: stderrLines, stack: err instanceof Error ? err.stack : undefined });
             appendUnique(output, stderrLines);
             appendUnique(output, [runtimeError]);
             return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: runtimeError, output, sessionId: options?.resumeSessionId };
         }
         finally {
+            emitHook('SessionEnd', '*', { cwd, sessionId });
             this.activeQuery?.close();
             this.activeQuery = null;
             await this.adapterRun?.release();

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

@@ -24,7 +24,7 @@ export function formatMessage(message) {
         case 'tool_progress':
             return `${message.tool_name} running (${message.elapsed_time_seconds}s)`;
         case 'tool_use_summary':
-            return message.summary;
+            return null;
         default:
             return null;
     }
@@ -95,6 +95,32 @@ export function extractToolResultEvent(message) {
     }
     return null;
 }
+export function extractClaudeHookEvents(message) {
+    const events = [];
+    if (message.type === 'system') {
+        if (message.subtype === 'task_started') {
+            events.push({ event: 'SubagentStart', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'task_notification') {
+            events.push({ event: 'Notification', matcher: '*', payload: message });
+        }
+        else if (message.subtype === 'local_command_output') {
+            events.push({ event: 'Notification', matcher: 'local_command_output', payload: message });
+        }
+    }
+    if (message.type === 'tool_use_summary') {
+        events.push({ event: 'PostToolBatch', matcher: '*', payload: message });
+    }
+    for (const toolUse of extractToolUseEvents(message)) {
+        if (toolUse.name === 'TaskCreate') {
+            events.push({ event: 'TaskCreated', matcher: toolUse.name, payload: toolUse });
+        }
+        if (toolUse.name === 'TaskCompleted') {
+            events.push({ event: 'TaskCompleted', matcher: toolUse.name, payload: toolUse });
+        }
+    }
+    return events;
+}
 export function logToolDebug(message, d, options = {}) {
     switch (message.type) {
         case 'assistant':

package/dist/adapters/claude-code-runtime/sdk-config.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicBridgeProvider } from './types.js';
 const require = createRequire(import.meta.url);
+const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 export function buildEnv(config, configDir, override) {
     const usesAnthropicBridge = isAnthropicBridgeProvider(config.provider);
     return {
@@ -132,6 +133,7 @@ export function prepareConfigDir(configDir, agentDir) {
     mkdirSync(configDir, { recursive: true });
     if (!agentDir)
         return;
+    copyClaudeBuiltInDirs(agentDir, configDir);
     const sourceSkillsDir = join(agentDir, 'skills');
     const targetSkillsDir = join(configDir, 'skills');
     rmSync(targetSkillsDir, { recursive: true, force: true });
@@ -163,6 +165,16 @@ export function prepareConfigDir(configDir, agentDir) {
         copyFileSync(source, join(targetSkillsDir, `${skillName}.md`));
     }
 }
+function copyClaudeBuiltInDirs(agentDir, configDir) {
+    for (const dir of CLAUDE_BUILT_IN_DIRS) {
+        const sourceDir = join(agentDir, dir);
+        const targetDir = join(configDir, dir);
+        rmSync(targetDir, { recursive: true, force: true });
+        if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory())
+            continue;
+        cpSync(sourceDir, targetDir, { recursive: true, force: true });
+    }
+}
 function hasSkillContent(skill, configDir) {
     if (!configDir)
         return true;

package/dist/adapters/git.js

@@ -36,26 +36,36 @@ function getGit(workspace) {
 }
 function mapStatus(raw) {
     const files = [];
+    const addOrUpdate = (file) => {
+        const existing = files.find(x => x.path === file.path);
+        if (existing) {
+            Object.assign(existing, file, {
+                staged: existing.staged || file.staged,
+                conflicted: existing.conflicted || file.conflicted,
+                status: file.conflicted ? 'conflicted' : existing.status,
+            });
+        }
+        else {
+            files.push(file);
+        }
+    };
     for (const f of raw.staged) {
-        files.push({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index) });
+        addOrUpdate({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index), staged: true });
     }
     for (const f of raw.modified) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'modified' });
-        }
+        addOrUpdate({ path: f, status: 'modified' });
     }
     for (const f of raw.not_added) {
-        files.push({ path: f, status: 'untracked' });
+        addOrUpdate({ path: f, status: 'untracked' });
     }
     for (const f of raw.deleted) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'deleted' });
-        }
+        addOrUpdate({ path: f, status: 'deleted' });
     }
     for (const f of raw.created) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'added' });
-        }
+        addOrUpdate({ path: f, status: 'added', staged: raw.staged.includes(f) });
+    }
+    for (const f of raw.conflicted) {
+        addOrUpdate({ path: f, status: 'conflicted', conflicted: true });
     }
     return {
         branch: raw.current || 'HEAD',
@@ -67,6 +77,75 @@ function mapStatus(raw) {
         deletions: 0,
     };
 }
+async function getUpstreamRef(git, branch) {
+    const refExists = async (ref) => {
+        return git.raw(['rev-parse', '--verify', '--quiet', ref])
+            .then(() => true)
+            .catch(() => false);
+    };
+    const upstream = await git.raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+        .then(v => v.trim())
+        .catch(() => '');
+    if (upstream && await refExists(upstream))
+        return upstream;
+    if (!branch || branch === 'HEAD')
+        return null;
+    const originBranch = `origin/${branch}`;
+    return await refExists(originBranch) ? originBranch : null;
+}
+function splitConflictSides(content) {
+    const left = [];
+    const right = [];
+    let mode = 'both';
+    let hasConflict = false;
+    for (const line of content.split('\n')) {
+        if (line.startsWith('<<<<<<< ')) {
+            hasConflict = true;
+            mode = 'left';
+            continue;
+        }
+        if (line.startsWith('=======')) {
+            mode = 'right';
+            continue;
+        }
+        if (line.startsWith('>>>>>>> ')) {
+            mode = 'both';
+            continue;
+        }
+        if (mode === 'both' || mode === 'left')
+            left.push(line);
+        if (mode === 'both' || mode === 'right')
+            right.push(line);
+    }
+    return { left: left.join('\n'), right: right.join('\n'), hasConflict };
+}
+async function buildWorkingDiff(git, rootDir, filePath, conflicted = false) {
+    const binary = isBinaryPath(filePath);
+    const workingContent = binary ? '' : await readFile(join(rootDir, filePath), 'utf-8').catch(() => '');
+    if (!binary && conflicted) {
+        const conflict = splitConflictSides(workingContent);
+        if (conflict.hasConflict) {
+            return {
+                path: filePath,
+                oldContent: conflict.left,
+                newContent: conflict.right,
+                isBinary: false,
+                isNew: false,
+                isDeleted: false,
+                isConflict: true,
+            };
+        }
+    }
+    const oldContent = binary ? '' : await git.show([`HEAD:${filePath}`]).catch(() => '');
+    return {
+        path: filePath,
+        oldContent,
+        newContent: workingContent,
+        isBinary: binary,
+        isNew: !oldContent,
+        isDeleted: !workingContent,
+    };
+}
 function mapStatusCode(code) {
     switch (code) {
         case 'A': return 'added';
@@ -83,6 +162,19 @@ export async function gitStatus(workspaceId) {
     const git = getGit(ws);
     const raw = await git.status();
     const result = mapStatus(raw);
+    try {
+        const headHash = await git.revparse(['--short', 'HEAD']);
+        result.headHash = headHash.trim();
+    }
+    catch { }
+    try {
+        const upstream = await getUpstreamRef(git, result.branch);
+        if (upstream) {
+            const remoteHeadHash = await git.revparse(['--short', upstream]);
+            result.remoteHeadHash = remoteHeadHash.trim();
+        }
+    }
+    catch { }
     if (!result.clean) {
         try {
             // Tracked changes: modified/deleted/renamed
@@ -122,66 +214,78 @@ export async function gitDiff(workspaceId, filePath) {
         throw new Error('Workspace not found');
     const git = getGit(ws);
     const diffs = [];
+    const status = await git.status();
+    const conflicted = new Set(status.conflicted);
     if (filePath) {
-        const diff = await git.diff([filePath]);
-        const oldContent = await git.show([`HEAD:${filePath}`]).catch(() => '');
-        const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
-        diffs.push({
-            path: filePath,
-            oldContent: isBinaryPath(filePath) ? '' : oldContent,
-            newContent: isBinaryPath(filePath) ? '' : newContent,
-            isBinary: isBinaryPath(filePath),
-            isNew: !oldContent,
-            isDeleted: !newContent,
-        });
+        diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], filePath, conflicted.has(filePath)));
     }
     else {
         const raw = await git.diff(['--name-only']);
-        const files = raw.split('\n').filter(Boolean);
+        const cachedRaw = await git.diff(['--cached', '--name-only']);
+        const files = Array.from(new Set([
+            ...raw.split('\n').filter(Boolean),
+            ...cachedRaw.split('\n').filter(Boolean),
+            ...status.not_added,
+            ...status.conflicted,
+        ]));
         for (const f of files) {
-            const binary = isBinaryPath(f);
-            const oldContent = binary ? '' : await git.show([`HEAD:${f}`]).catch(() => '');
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            diffs.push({
-                path: f,
-                oldContent,
-                newContent,
-                isBinary: binary,
-                isNew: !oldContent,
-                isDeleted: !newContent,
-            });
-        }
-        // Also check untracked (staged new files)
-        const status = await git.status();
-        for (const f of status.not_added) {
-            const binary = isBinaryPath(f);
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            if (newContent || binary) {
-                diffs.push({
-                    path: f,
-                    oldContent: '',
-                    newContent: binary ? '' : newContent,
-                    isBinary: binary,
-                    isNew: true,
-                    isDeleted: false,
-                });
-            }
+            diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], f, conflicted.has(f)));
         }
     }
     return diffs;
 }
+export async function gitStage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.add(filePath);
+}
+export async function gitUnstage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.raw(['restore', '--staged', '--', filePath]).catch(async () => {
+        await git.raw(['reset', 'HEAD', '--', filePath]);
+    });
+}
+export async function gitResolveFile(workspaceId, filePath, content, stage = true) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await writeFile(join(ws.boundDirs[0], filePath), content, 'utf-8');
+    if (stage)
+        await git.add(filePath);
+}
 export async function gitLog(workspaceId, maxCount = 50) {
     const ws = getWorkspace(workspaceId);
     if (!ws)
         throw new Error('Workspace not found');
     const git = getGit(ws);
-    const log = await git.log({ maxCount });
-    return log.all.map(entry => ({
-        hash: entry.hash.substring(0, 7),
-        message: entry.message,
-        author: entry.author_name,
-        date: entry.date,
-    }));
+    const status = await git.status();
+    const upstream = await getUpstreamRef(git, status.current || 'HEAD');
+    const refs = upstream ? ['HEAD', upstream] : ['HEAD'];
+    const pretty = '%H%x1f%s%x1f%an%x1f%aI%x1e';
+    const logArgs = ['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`];
+    const raw = await git.raw([...logArgs, ...refs]).catch((err) => {
+        if (!upstream)
+            throw err;
+        return git.raw([...logArgs, 'HEAD']);
+    });
+    return raw.split('\x1e')
+        .map(record => record.trim())
+        .filter(Boolean)
+        .map(record => {
+        const [hash = '', message = '', author = '', date = ''] = record.split('\x1f');
+        return {
+            hash: hash.substring(0, 7),
+            message,
+            author,
+            date,
+        };
+    });
 }
 export async function gitCommit(workspaceId, message) {
     const ws = getWorkspace(workspaceId);
@@ -274,6 +378,13 @@ export async function gitPush(workspaceId) {
         throw new Error('No remote repository configured. Please add a remote first.');
     await git.push('origin', branch);
 }
+export async function gitFetch(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.fetch('origin');
+}
 export async function gitPull(workspaceId) {
     const ws = getWorkspace(workspaceId);
     if (!ws)

package/dist/agents/agent-designer.js

@@ -28,13 +28,36 @@ export async function generateAgentDesign(userPrompt) {
         apiBase: maskUrl(config.apiBase),
         promptLength: prompt.length,
     });
-    const content = await requestDesign(config, prompt);
+    const content = await requestText(config, buildDesignSystemPrompt(config), prompt);
     console.info('[agent-designer] model text extracted', {
         length: content.length,
         preview: content.slice(0, 500),
     });
     return normalizeDesign(parseJsonObject(content));
 }
+export async function optimizeAgentPrompt(userPrompt, currentPrompt) {
+    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 optimizing prompts.`);
+    }
+    console.info('[agent-designer] optimizing agent prompt', {
+        agentId: AGENT_GENERATOR_PRESET_ID,
+        provider: config.modelProvider ?? inferProvider(config.apiBase),
+        modelId: config.modelId,
+        apiBase: maskUrl(config.apiBase),
+        promptLength: prompt.length,
+        currentPromptLength: currentPrompt.trim().length,
+    });
+    const content = await requestText(config, buildOptimizationSystemPrompt(config), buildPromptOptimizationUserPrompt(prompt, currentPrompt));
+    console.info('[agent-designer] optimized prompt received', {
+        length: content.length,
+        preview: content.slice(0, 500),
+    });
+    return { systemPrompt: normalizePrompt(content) };
+}
 function resolveModelConfig() {
     const preset = readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
     if (preset?.apiBase && preset.apiKey && preset.modelId) {
@@ -51,14 +74,17 @@ function resolveModelConfig() {
     return null;
 }
 async function requestDesign(config, userPrompt) {
+    return requestText(config, buildDesignSystemPrompt(config), userPrompt);
+}
+async function requestText(config, systemPrompt, userPrompt) {
     const provider = config.modelProvider ?? inferProvider(config.apiBase);
     if (provider === 'anthropic-messages')
-        return requestAnthropic(config, userPrompt);
+        return requestAnthropic(config, systemPrompt, userPrompt);
     if (provider === 'gemini-generate-content')
-        return requestGemini(config, userPrompt);
-    return requestOpenAICompatible(config, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
+        return requestGemini(config, systemPrompt, userPrompt);
+    return requestOpenAICompatible(config, systemPrompt, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
 }
-async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
+async function requestOpenAICompatible(config, systemPrompt, userPrompt, useResponsesApi) {
     const url = joinUrl(config.apiBase, useResponsesApi ? '/responses' : '/chat/completions');
     const response = await fetch(url, {
         method: 'POST',
@@ -69,14 +95,14 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         body: JSON.stringify(useResponsesApi
             ? {
                 model: config.modelId,
-                input: `${buildSystemPrompt(config)}\n\nUser request:\n${userPrompt}`,
+                input: `${systemPrompt}\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: 'system', content: systemPrompt },
                     { role: 'user', content: userPrompt },
                 ],
                 temperature: config.temperature ?? 0.2,
@@ -88,7 +114,7 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestAnthropic(config, userPrompt) {
+async function requestAnthropic(config, systemPrompt, userPrompt) {
     const response = await fetch(getAnthropicMessagesUrl(config.apiBase), {
         method: 'POST',
         headers: {
@@ -98,7 +124,7 @@ async function requestAnthropic(config, userPrompt) {
         },
         body: JSON.stringify({
             model: config.modelId,
-            system: buildSystemPrompt(config),
+            system: systemPrompt,
             messages: [{ role: 'user', content: userPrompt }],
             max_tokens: config.maxTokens ?? 4096,
             temperature: config.temperature ?? 0.2,
@@ -109,7 +135,7 @@ async function requestAnthropic(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestGemini(config, userPrompt) {
+async function requestGemini(config, systemPrompt, userPrompt) {
     const response = await fetch(joinUrl(config.apiBase, `/models/${encodeURIComponent(config.modelId)}:generateContent`), {
         method: 'POST',
         headers: {
@@ -117,7 +143,7 @@ async function requestGemini(config, userPrompt) {
             'Content-Type': 'application/json',
         },
         body: JSON.stringify({
-            systemInstruction: { parts: [{ text: buildSystemPrompt(config) }] },
+            systemInstruction: { parts: [{ text: systemPrompt }] },
             contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
             generationConfig: {
                 temperature: config.temperature ?? 0.2,
@@ -130,12 +156,40 @@ async function requestGemini(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-function buildSystemPrompt(config) {
+function buildDesignSystemPrompt(config) {
     const custom = config.systemPrompt?.trim();
     if (!custom)
         return SYSTEM_PROMPT;
     return `${custom}\n\n${SYSTEM_PROMPT}`;
 }
+function buildOptimizationSystemPrompt(config) {
+    const custom = config.systemPrompt?.trim();
+    const base = [
+        'You optimize agent system prompts.',
+        'Return only the rewritten prompt text.',
+        'Do not wrap the result in markdown fences.',
+        'Do not add commentary, bullets about the process, or any explanation outside the prompt.',
+        'Keep the prompt actionable, concise, and directly usable as a system prompt.',
+        'Preserve important constraints from the current prompt unless the user request clearly asks to change them.',
+    ].join('\n');
+    if (!custom)
+        return base;
+    return `${custom}\n\n${base}`;
+}
+function buildPromptOptimizationUserPrompt(userRequest, currentPrompt) {
+    return [
+        'User request:',
+        userRequest,
+        '',
+        'Current system prompt:',
+        currentPrompt.trim() || '(empty)',
+        '',
+        'Rewrite the current system prompt according to the user request. Return only the final prompt text.',
+    ].join('\n');
+}
+function normalizePrompt(text) {
+    return text.trim().replace(/^```(?:markdown|md)?\s*/i, '').replace(/\s*```$/i, '');
+}
 async function readResponseBody(response) {
     const raw = await response.text();
     if (!raw)

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

@@ -41,7 +41,7 @@ export function createAgentMessagePartsTracker(input) {
                 }
                 return;
             }
-            if (event.type === 'session')
+            if (event.type === 'session' || event.type === 'hook_event')
                 return;
             output.push(event.line);
             input.onOutput?.(event.line);