tuna-agent 0.1.0 → 0.1.1

package/dist/agents/claude-code-adapter.d.ts

@@ -1,9 +1,11 @@
 import type { AgentAdapter, AgentType } from './types.js';
-import type { TaskAssignment, InputResponse } from '../types/index.js';
+import type { AgentConfig, TaskAssignment, InputResponse } from '../types/index.js';
 import type { AgentWebSocketClient } from '../daemon/ws-client.js';
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     readonly type: AgentType;
     readonly displayName = "Claude Code";
+    private readonly agentConfig;
+    constructor(config: AgentConfig);
     checkHealth(): Promise<{
         ok: boolean;
         message: string;

package/dist/agents/claude-code-adapter.js

@@ -7,9 +7,14 @@ import { planTask, chatWithPM } from '../pm/planner.js';
 import { savePMState, clearPMState } from '../daemon/pm-state.js';
 import { simplifyMarkdown, waitForInput, sessionToPayload, executePlanAndReport, } from '../utils/execution-helpers.js';
 import { downloadAttachments, cleanupAttachments } from '../utils/image-download.js';
+import { writeAgentFolderMcpConfig } from '../mcp/setup.js';
 export class ClaudeCodeAdapter {
     type = 'claude-code';
     displayName = 'Claude Code';
+    agentConfig;
+    constructor(config) {
+        this.agentConfig = config;
+    }
     async checkHealth() {
         try {
             execSync('which claude', { stdio: 'ignore' });
@@ -72,17 +77,24 @@ export class ClaudeCodeAdapter {
                     const cwd = task.repoPath || defaultWorkspace;
                     if (!fs.existsSync(cwd))
                         fs.mkdirSync(cwd, { recursive: true });
+                    // Write MCP config to agent folder .claude/settings.json on first round
+                    // Claude Code reads settings.json automatically (--mcp-config flag is unreliable)
+                    if (round === 0) {
+                        writeAgentFolderMcpConfig(cwd, this.agentConfig);
+                    }
+                    // Skills/scheduled tasks use MCP tools (knowledge sync) → disable agentTeam
+                    // Manual chat tasks may spawn sub-agents → keep agentTeam enabled
+                    const useAgentTeam = task.source !== 'skill' && task.source !== 'scheduled';
                     const result = await runClaude({
                         prompt: userMessage,
                         cwd,
-                        allowedTools: ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep'],
                         outputFormat: 'stream-json',
                         includePartialMessages: true,
-                        agentTeam: true,
                         maxTurns: 50,
                         resumeSessionId: round > 0 ? sessionId : undefined,
                         signal,
                         inputFiles: currentInputFiles,
+                        agentTeam: useAgentTeam,
                         ...(confirmBeforeEdit && onPermissionRequest ? {
                             permissionMode: 'default',
                             onPermissionRequest: (tool, detail) => onPermissionRequest('agent-team', tool, detail),
@@ -123,10 +135,22 @@ export class ClaudeCodeAdapter {
                                 return;
                             }
                             // Log non-stream events for debugging
-                            console.log(`[ClaudeCode] stream line: type=${data.type}${data.type === 'assistant' ? ' (assistant msg)' : ''}`);
-                            // Track session ID
+                            if (data.type === 'system') {
+                                console.log(`[ClaudeCode] system: ${JSON.stringify(data).slice(0, 300)}`);
+                            }
+                            else {
+                                console.log(`[ClaudeCode] stream line: type=${data.type}${data.type === 'assistant' ? ' (assistant msg)' : ''}`);
+                            }
+                            // Track session ID + log MCP tools from init
                             if (data.type === 'system' && data.subtype === 'init') {
                                 sessionId = data.session_id;
+                                const initData = data;
+                                // tools can be string[] or object[] depending on Claude Code version
+                                const rawTools = initData.tools;
+                                const toolNames = rawTools?.map(t => typeof t === 'string' ? t : String(t?.name ?? '')) ?? [];
+                                const mcpTools = toolNames.filter(n => n.startsWith('mcp__'));
+                                console.log(`[ClaudeCode] Init tools: total=${toolNames.length}, mcp=${mcpTools.length} (${mcpTools.join(', ') || 'none'})`);
+                                console.log(`[ClaudeCode] All tools: ${toolNames.join(', ')}`);
                             }
                             // Send tool usage to activity tab
                             if (data.type === 'assistant' && data.message) {

package/dist/agents/factory.d.ts

@@ -1,2 +1,3 @@
 import type { AgentAdapter, AgentConfig } from './types.js';
-export declare function createAgentAdapter(config: AgentConfig): AgentAdapter;
+import type { AgentConfig as DaemonAgentConfig } from '../types/index.js';
+export declare function createAgentAdapter(config: AgentConfig, daemonConfig?: DaemonAgentConfig): AgentAdapter;

package/dist/agents/factory.js

@@ -1,9 +1,9 @@
 import { ClaudeCodeAdapter } from './claude-code-adapter.js';
 import { OpenClawAdapter } from './openclaw-adapter.js';
-export function createAgentAdapter(config) {
+export function createAgentAdapter(config, daemonConfig) {
     switch (config.type) {
         case 'claude-code':
-            return new ClaudeCodeAdapter();
+            return new ClaudeCodeAdapter(daemonConfig);
         case 'openclaw':
             return new OpenClawAdapter(config);
         default:

package/dist/cli/commands/extension.d.ts

@@ -0,0 +1,10 @@
+/**
+ * List all Chrome extensions paired with this machine.
+ * Usage: tuna-agent extension list
+ */
+export declare function extensionList(): Promise<void>;
+/**
+ * Pair this machine with a Chrome extension using its pairing code.
+ * Usage: tuna-agent extension connect TUNA-XXXX-XXXX
+ */
+export declare function extensionConnect(code: string): Promise<void>;

package/dist/cli/commands/extension.js

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../../config/store.js';
+/**
+ * List all Chrome extensions paired with this machine.
+ * Usage: tuna-agent extension list
+ */
+export async function extensionList() {
+    const config = loadConfig();
+    if (!config) {
+        console.error(chalk.red('Not connected. Run tuna-agent connect <CODE> first.'));
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/extension/list`, {
+            headers: { 'Authorization': `Bearer ${config.agentToken}` },
+        });
+        const body = await res.json();
+        if (!res.ok || !body.data) {
+            console.error(chalk.red(`Failed: ${body.message || 'Unknown error'}`));
+            process.exit(1);
+        }
+        const { extensions, total } = body.data;
+        console.log(chalk.cyan(`\nPaired Extensions (${total})\n`));
+        if (total === 0) {
+            console.log(chalk.gray('  No extensions paired yet.'));
+            console.log(`\n  Run ${chalk.bold('tuna-agent extension connect <CODE>')} to pair one.`);
+            return;
+        }
+        for (const ext of extensions) {
+            const status = ext.connected ? chalk.green('● connected') : chalk.gray('○ offline');
+            console.log(`  ${status}  ${chalk.bold(ext.code)}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nFailed: ${msg}`));
+        process.exit(1);
+    }
+}
+/**
+ * Pair this machine with a Chrome extension using its pairing code.
+ * Usage: tuna-agent extension connect TUNA-XXXX-XXXX
+ */
+export async function extensionConnect(code) {
+    const config = loadConfig();
+    if (!config) {
+        console.error(chalk.red('Not connected. Run tuna-agent connect <CODE> first.'));
+        process.exit(1);
+    }
+    const normalizedCode = code.trim().toUpperCase();
+    if (!normalizedCode.startsWith('TUNA-')) {
+        console.error(chalk.red('Invalid pair code. Expected format: TUNA-XXXX-XXXX'));
+        process.exit(1);
+    }
+    console.log(chalk.cyan('Pairing with Chrome extension...'));
+    console.log(`  Code: ${chalk.bold(normalizedCode)}`);
+    try {
+        const res = await fetch(`${config.apiUrl}/extension/pair`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.agentToken}`,
+            },
+            body: JSON.stringify({ code: normalizedCode }),
+        });
+        const body = await res.json();
+        if (!res.ok || !body.data) {
+            console.error(chalk.red(`\nFailed: ${body.message || 'Unknown error'}`));
+            process.exit(1);
+        }
+        console.log(chalk.green('\nExtension paired successfully!'));
+        console.log(`  Machine: ${body.data.machineName}`);
+        console.log('\nThe Content Creator extension should now show your agent as connected.');
+        // Save code locally so agent can restore the pairing after server restart
+        const codes = new Set(config.extensionCodes || []);
+        codes.add(normalizedCode);
+        saveConfig({ ...config, extensionCodes: [...codes] });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nPairing failed: ${msg}`));
+        console.error(`Make sure tuna-agent daemon is configured (run tuna-agent connect first)`);
+        process.exit(1);
+    }
+}

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import { connect } from './commands/connect.js';
 import { start } from './commands/start.js';
 import { stop } from './commands/stop.js';
 import { status } from './commands/status.js';
+import { extensionConnect, extensionList } from './commands/extension.js';
 const program = new Command()
     .name('tuna-agent')
     .description('Tuna Agent - Run AI coding tasks on your machine')
@@ -29,4 +30,15 @@ program
     .command('status')
     .description('Show agent connection status')
     .action(status);
+const extensionCmd = program
+    .command('extension')
+    .description('Manage Chrome extension pairing');
+extensionCmd
+    .command('connect <code>')
+    .description('Pair this agent with the Content Creator Chrome extension')
+    .action(extensionConnect);
+extensionCmd
+    .command('list')
+    .description('List all Chrome extensions paired with this machine')
+    .action(extensionList);
 program.parse();

package/dist/daemon/index.js

@@ -2,8 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { AgentWebSocketClient } from './ws-client.js';
-import { removePid } from '../config/store.js';
-import { validatePath } from '../utils/validate-path.js';
+import { removePid, loadConfig, saveConfig } from '../config/store.js';
 import { validateMessage } from '../utils/message-schemas.js';
 import { createAgentAdapter } from '../agents/factory.js';
 import { loadPMState, savePMState, clearPMState } from './pm-state.js';
@@ -11,6 +10,8 @@ import { chatWithPM } from '../pm/planner.js';
 import { executePlanAndReport, simplifyMarkdown, waitForInput } from '../utils/execution-helpers.js';
 import { runClaude } from '../utils/claude-cli.js';
 import { downloadAttachments, cleanupAttachments } from '../utils/image-download.js';
+import { scanSkills } from '../utils/skill-scanner.js';
+import { setupMcpConfig } from '../mcp/setup.js';
 /**
  * Start the agent daemon.
  * Connects to API via WebSocket, receives tasks, delegates to agent adapter.
@@ -21,7 +22,14 @@ export async function startDaemon(config) {
         type: config.agentType || 'claude-code',
         ...config.agentConfig,
     };
-    const adapter = createAgentAdapter(agentConfig);
+    const adapter = createAgentAdapter(agentConfig, config);
+    // Setup MCP config for Knowledge server
+    try {
+        setupMcpConfig(config);
+    }
+    catch (err) {
+        console.warn(`[Daemon] MCP config setup failed (non-fatal):`, err);
+    }
     // Health check on startup
     const health = await adapter.checkHealth();
     if (!health.ok) {
@@ -58,8 +66,8 @@ export async function startDaemon(config) {
         switch (type) {
             case 'connected':
                 console.log(`[Daemon] Connected as "${msg.name}" (${msg.agentId})`);
-                // Recover any tasks orphaned by previous daemon crash/restart
-                ws.send({ action: 'recover_orphaned_tasks' });
+                // Recover orphaned tasks — pass activeTaskId so API won't fail a task we're still running
+                ws.send({ action: 'recover_orphaned_tasks', activeTaskId: currentTaskId ?? undefined });
                 break;
             case 'task_assigned': {
                 const task = msg.task;
@@ -76,6 +84,15 @@ export async function startDaemon(config) {
                 currentTaskId = task.id;
                 currentTaskAbort = new AbortController();
                 console.log(`[Daemon] Received task: ${task.id} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0})`);
+                // Update MCP config with the task's agent ID so knowledge server uses correct attribution
+                if (task.agentId) {
+                    try {
+                        setupMcpConfig({ ...config, agentId: task.agentId });
+                    }
+                    catch (err) {
+                        console.warn(`[Daemon] MCP config update for task failed (non-fatal):`, err);
+                    }
+                }
                 try {
                     await adapter.handleTask(task, ws, pendingInputResolvers, currentTaskAbort.signal, pendingPermissionResolvers);
                 }
@@ -117,42 +134,21 @@ export async function startDaemon(config) {
             }
             case 'command': {
                 const command = msg.command;
-                if (command === 'scan_workspace') {
-                    const rawPath = msg.workspace_path || '~/tuna-workspace';
-                    const wsPath = rawPath.startsWith('~')
-                        ? path.join(os.homedir(), rawPath.slice(1))
-                        : rawPath;
-                    try {
-                        validatePath(wsPath, os.homedir());
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        console.error(`[Daemon] Workspace path validation failed: ${errMsg}`);
-                        ws.send({ action: 'workspace_scanned', projects: [] });
-                        break;
-                    }
-                    // Resolve agent folder paths (sent by API)
-                    const rawFolders = msg.agent_folders || [];
-                    const agentFolders = rawFolders.map(f => f.startsWith('~') ? path.join(os.homedir(), f.slice(1)) : f);
-                    console.log(`[Daemon] Scanning workspace: ${wsPath}, agent folders: ${agentFolders.length}`);
-                    ws.setWorkspacePath(wsPath);
-                    ws.setAgentFolders(agentFolders);
-                    try {
-                        const entries = fs.readdirSync(wsPath, { withFileTypes: true });
-                        const projects = entries
-                            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                            .map(e => ({
-                            name: e.name,
-                            path: path.join(wsPath, e.name),
-                        }));
-                        ws.send({ action: 'workspace_scanned', projects });
-                        console.log(`[Daemon] Found ${projects.length} projects in workspace`);
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        console.error(`[Daemon] Workspace scan failed: ${errMsg}`);
-                        ws.send({ action: 'workspace_scanned', projects: [] });
-                    }
+                if (command === 'rescan_agent_skills') {
+                    const agentId = msg.agent_id;
+                    const rawFolder = msg.folder_path || '';
+                    const rawWsPath = msg.workspace_path || '~/tuna-workspace';
+                    const wsPath = rawWsPath.startsWith('~')
+                        ? path.join(os.homedir(), rawWsPath.slice(1))
+                        : rawWsPath;
+                    const folder = rawFolder.startsWith('~')
+                        ? path.join(os.homedir(), rawFolder.slice(1))
+                        : rawFolder;
+                    console.log(`[Daemon] Rescan skills for agent ${agentId}, folder: ${folder || '(none)'}`);
+                    const folders = folder ? [folder] : [];
+                    const skills = scanSkills(wsPath, folders);
+                    ws.send({ action: 'agent_skills_scanned', agent_id: agentId, skills });
+                    console.log(`[Daemon] Scanned ${skills.length} skill(s) for agent ${agentId}`);
                 }
                 else if (command === 'analyze_skill') {
                     const skillId = msg.skill_id;
@@ -180,12 +176,15 @@ export async function startDaemon(config) {
                             const analyzePrompt = `You are analyzing a Claude Code skill file (markdown prompt template). Extract the following structured information from the content below:
 
 1. **description**: A short summary of what this skill does in under 80 characters. Be very concise — like a subtitle, not a full sentence.
-2. **actions**: Sub-commands or modes available in this skill. Look for sections, headings, or conditional logic that indicate different actions/modes the user can invoke. Each action has a "name" (short, lowercase, no spaces — use hyphens) and "description" (what it does, max 100 chars).
-3. **parameters**: Input parameters the skill accepts. Look for {{param_name}} placeholders, $ARGUMENTS references, or documented inputs. Each parameter has "key", "label", "type" (text/number/select/multiline), "required" (boolean), "default_value", "options" (for select type), "placeholder".
+2. **actions**: Sub-commands or modes available in this skill. Look for sections, headings, or conditional logic that indicate different actions/modes the user can invoke. Each action has:
+   - "name" (short, lowercase, no spaces — use hyphens)
+   - "description" (what it does, max 100 chars)
+   - "params" (array of parameter KEY strings that are relevant to THIS specific action — only include params that this action actually uses)
+3. **parameters**: ALL input parameters the skill accepts (the full definitions). Look for {{param_name}} placeholders, $ARGUMENTS references, or documented inputs. Each parameter has "key", "label", "type" (text/number/select/multiline), "required" (boolean), "default_value", "options" (for select type), "placeholder".
    - IMPORTANT: If a parameter has a finite set of known values (e.g. listed in config files, enums, documented choices), use type "select" and populate the "options" array with ALL known values. Only use type "text" when the input is truly free-form.
 
 Respond with ONLY valid JSON, no markdown, no explanation:
-{"description":"...","actions":[{"name":"...","description":"..."}],"parameters":[{"key":"...","label":"...","type":"select","required":false,"options":["opt1","opt2"]}]}
+{"description":"...","actions":[{"name":"...","description":"...","params":["param_key1","param_key2"]}],"parameters":[{"key":"...","label":"...","type":"select","required":false,"options":["opt1","opt2"]}]}
 
 If no actions are found, return an empty array. If no parameters found, return an empty array.
 
@@ -287,8 +286,79 @@ ${skillContent.slice(0, 15000)}`;
                 }
                 break;
             }
+            case 'extension_task': {
+                // Task sent from Chrome extension — run Claude and stream results back
+                const extCode = msg.code;
+                const extTaskId = msg.taskId;
+                const extTask = msg.task;
+                const extStream = msg.stream;
+                if (!extCode || !extTaskId || !extTask) {
+                    console.warn('[Daemon] extension_task missing required fields');
+                    break;
+                }
+                console.log(`[Daemon] Extension task ${extTaskId}: ${extTask.substring(0, 80)}`);
+                // Run in background — don't block message handling
+                (async () => {
+                    try {
+                        let accumulated = '';
+                        let progress = 0;
+                        const result = await runClaude({
+                            prompt: extTask,
+                            cwd: os.homedir(),
+                            maxTurns: 10,
+                            outputFormat: extStream ? 'stream-json' : 'json',
+                            lightweight: true,
+                            timeoutMs: 120000,
+                            onStreamLine: extStream ? (data) => {
+                                if (data.type === 'stream_event') {
+                                    const event = data.event;
+                                    if (event?.type === 'content_block_delta') {
+                                        const delta = event.delta;
+                                        if (delta?.type === 'text_delta' && delta.text) {
+                                            const chunk = delta.text;
+                                            accumulated += chunk;
+                                            ws.send({ action: 'extension_task_stream', code: extCode, taskId: extTaskId, text: chunk });
+                                        }
+                                    }
+                                }
+                            } : undefined,
+                        });
+                        ws.send({
+                            action: 'extension_task_done',
+                            code: extCode,
+                            taskId: extTaskId,
+                            result: { script: result.result, text: result.result },
+                        });
+                        console.log(`[Daemon] Extension task ${extTaskId} done`);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        console.error(`[Daemon] Extension task ${extTaskId} error: ${errMsg}`);
+                        ws.send({
+                            action: 'extension_task_done',
+                            code: extCode,
+                            taskId: extTaskId,
+                            result: { error: errMsg },
+                        });
+                    }
+                })();
+                break;
+            }
             case 'pong':
                 break;
+            case 'extension_unpaired': {
+                // Extension signed out — remove this code from local config so it's not restored on reconnect
+                const unpairCode = msg.code;
+                if (unpairCode) {
+                    const cfg = loadConfig();
+                    if (cfg?.extensionCodes) {
+                        const newCodes = cfg.extensionCodes.filter(c => c !== unpairCode);
+                        saveConfig({ ...cfg, extensionCodes: newCodes });
+                        console.log(`[Daemon] Extension unpaired: ${unpairCode}`);
+                    }
+                }
+                break;
+            }
             case 'error':
                 console.error(`[Daemon] Server error: ${msg.message}`);
                 break;

package/dist/daemon/ws-client.d.ts

@@ -10,9 +10,6 @@ export declare class AgentWebSocketClient {
     private running;
     private onMessage;
     private onAuthFailed?;
-    private heartbeatCount;
-    private _workspacePath;
-    private _agentFolders;
     constructor(config: AgentConfig, onMessage: MessageHandler, onAuthFailed?: (code: number, reason: string) => void);
     connect(): void;
     disconnect(): void;
@@ -94,14 +91,21 @@ export declare class AgentWebSocketClient {
         context?: string;
         startedAt?: string;
     }): boolean;
+    /**
+     * Stream a text chunk back to the Chrome extension for an extension task.
+     */
+    sendExtensionStream(code: string, taskId: string, text: string): boolean;
+    /**
+     * Signal that an extension task is complete.
+     */
+    sendExtensionDone(code: string, taskId: string, result: Record<string, unknown>): boolean;
+    /**
+     * Send progress update for an extension task.
+     */
+    sendExtensionProgress(code: string, taskId: string, progress: number): boolean;
     get isConnected(): boolean;
     private _connect;
     private _startHeartbeat;
-    /** Set workspace path (called when scan_workspace command is received) */
-    setWorkspacePath(wsPath: string): void;
-    /** Set agent folder paths for skill scanning */
-    setAgentFolders(folders: string[]): void;
-    private _scanWorkspace;
     private _stopHeartbeat;
     private _scheduleReconnect;
 }

package/dist/daemon/ws-client.js

@@ -1,9 +1,5 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
 import WebSocket from 'ws';
 import { getSystemLoad, detectCapabilities } from '../system/info.js';
-import { scanSkills } from '../utils/skill-scanner.js';
 /** Close codes that indicate a permanent error — do NOT reconnect. */
 const PERMANENT_CLOSE_CODES = new Set([
     4001, // Authentication failed (invalid token)
@@ -19,9 +15,6 @@ export class AgentWebSocketClient {
     running = false;
     onMessage;
     onAuthFailed;
-    heartbeatCount = 0;
-    _workspacePath = null;
-    _agentFolders = [];
     constructor(config, onMessage, onAuthFailed) {
         this.config = config;
         this.onMessage = onMessage;
@@ -159,6 +152,24 @@ export class AgentWebSocketClient {
             timestamp: message.startedAt || new Date().toISOString(),
         });
     }
+    /**
+     * Stream a text chunk back to the Chrome extension for an extension task.
+     */
+    sendExtensionStream(code, taskId, text) {
+        return this.send({ action: 'extension_task_stream', code, taskId, text });
+    }
+    /**
+     * Signal that an extension task is complete.
+     */
+    sendExtensionDone(code, taskId, result) {
+        return this.send({ action: 'extension_task_done', code, taskId, result });
+    }
+    /**
+     * Send progress update for an extension task.
+     */
+    sendExtensionProgress(code, taskId, progress) {
+        return this.send({ action: 'extension_task_progress', code, taskId, progress });
+    }
     get isConnected() {
         return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
     }
@@ -177,6 +188,11 @@ export class AgentWebSocketClient {
             this.reconnectAttempts = 0;
             console.log('[WS] Connected to API server');
             this._startHeartbeat();
+            // Restore extension pairings so server can send agent_connected to already-connected extensions
+            const codes = this.config.extensionCodes;
+            if (codes && codes.length > 0) {
+                this.send({ action: 'restore_extensions', codes });
+            }
         });
         this.ws.on('message', (raw) => {
             try {
@@ -210,70 +226,15 @@ export class AgentWebSocketClient {
     }
     _startHeartbeat() {
         this._stopHeartbeat();
-        this.heartbeatCount = 0;
-        // Scan workspace once on connect (delayed 3s to let connection stabilize)
-        setTimeout(() => this._scanWorkspace(), 3000);
         this.heartbeatTimer = setInterval(() => {
-            this.heartbeatCount++;
             const agentType = this.config.agentType || 'claude-code';
             this.send({
                 action: 'heartbeat',
                 system_load: getSystemLoad(),
                 capabilities: detectCapabilities(agentType),
             });
-            // Scan workspace every 20th heartbeat (~10 min)
-            if (this.heartbeatCount % 20 === 0) {
-                this._scanWorkspace();
-            }
         }, 30000);
     }
-    /** Set workspace path (called when scan_workspace command is received) */
-    setWorkspacePath(wsPath) {
-        this._workspacePath = wsPath;
-    }
-    /** Set agent folder paths for skill scanning */
-    setAgentFolders(folders) {
-        this._agentFolders = folders;
-    }
-    _scanWorkspace() {
-        const wsPath = this._workspacePath || path.join(os.homedir(), 'tuna-workspace');
-        try {
-            if (!fs.existsSync(wsPath))
-                return;
-            const entries = fs.readdirSync(wsPath, { withFileTypes: true });
-            const projects = entries
-                .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                .map(e => ({ name: e.name, path: path.join(wsPath, e.name) }));
-            this.send({ action: 'workspace_scanned', projects });
-        }
-        catch {
-            // Silent fail — non-critical
-        }
-        // Scan skills from .claude/commands/ directories
-        // Merge API-provided folders with local config scan_paths
-        try {
-            let folders = [...this._agentFolders];
-            if (folders.length === 0) {
-                // Fallback: read scan_paths from local config
-                const configPath = path.join(os.homedir(), '.tuna-agent', 'config.json');
-                try {
-                    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                    if (Array.isArray(cfg.scan_paths)) {
-                        folders = cfg.scan_paths;
-                    }
-                }
-                catch { /* no config or parse error */ }
-            }
-            const skills = scanSkills(wsPath, folders);
-            if (skills.length > 0) {
-                this.send({ action: 'skills_scanned', skills });
-                console.log(`[WS] Scanned ${skills.length} skill(s) from ${folders.length} folder(s)`);
-            }
-        }
-        catch {
-            // Silent fail — non-critical
-        }
-    }
     _stopHeartbeat() {
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);

package/dist/mcp/knowledge-server.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Knowledge MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes knowledge tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node knowledge-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+export {};

package/dist/mcp/knowledge-server.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * Knowledge MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes knowledge tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node knowledge-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let apiUrl = '';
+    let token = '';
+    let agentId = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--api-url' && args[i + 1])
+            apiUrl = args[++i];
+        else if (args[i] === '--token' && args[i + 1])
+            token = args[++i];
+        else if (args[i] === '--agent-id' && args[i + 1])
+            agentId = args[++i];
+    }
+    if (!apiUrl || !token || !agentId) {
+        process.stderr.write('Usage: knowledge-server --api-url URL --token TOKEN --agent-id ID\n');
+        process.exit(1);
+    }
+    return { apiUrl, token, agentId };
+}
+// ===== API Client =====
+async function apiCall(config, method, path, body) {
+    const url = `${config.apiUrl}${path}`;
+    const headers = {
+        'Authorization': `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+    };
+    const options = { method, headers };
+    if (body)
+        options.body = JSON.stringify(body);
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!res.ok || (json.code && json.code >= 400)) {
+        throw new Error(json.message || `API error: ${res.status}`);
+    }
+    return json.data;
+}
+function sendResponse(res) {
+    // Claude Code uses newline-delimited JSON (not Content-Length framing)
+    process.stdout.write(JSON.stringify(res) + '\n');
+}
+function sendResult(id, result) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, result });
+}
+function sendError(id, code, message) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, error: { code, message } });
+}
+// ===== Tool Definitions =====
+const TOOLS = [
+    {
+        name: 'list_knowledge',
+        description: 'List all knowledge documents accessible to this agent. Returns document names, descriptions, and IDs.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'read_knowledge',
+        description: 'Read the full content of a knowledge document by its ID. Returns the markdown content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                knowledge_id: { type: 'string', description: 'The ID of the knowledge document to read' },
+            },
+            required: ['knowledge_id'],
+        },
+    },
+    {
+        name: 'create_knowledge',
+        description: 'Create a new knowledge document. Content should be in markdown format.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name/title of the knowledge document' },
+                content: { type: 'string', description: 'Markdown content of the document' },
+                description: { type: 'string', description: 'Short description of what this document contains' },
+            },
+            required: ['name', 'content'],
+        },
+    },
+    {
+        name: 'update_knowledge',
+        description: 'Update an existing knowledge document. Can update name, description, and/or content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                knowledge_id: { type: 'string', description: 'The ID of the knowledge document to update' },
+                name: { type: 'string', description: 'New name (optional)' },
+                content: { type: 'string', description: 'New markdown content (optional)' },
+                description: { type: 'string', description: 'New description (optional)' },
+            },
+            required: ['knowledge_id'],
+        },
+    },
+];
+// ===== Request Handler =====
+async function handleRequest(config, req) {
+    try {
+        switch (req.method) {
+            case 'initialize':
+                sendResult(req.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'tuna-knowledge', version: '1.0.0' },
+                });
+                break;
+            case 'notifications/initialized':
+                // No response needed for notifications
+                break;
+            case 'tools/list':
+                sendResult(req.id, { tools: TOOLS });
+                break;
+            case 'tools/call': {
+                const toolName = req.params?.name ?? '';
+                const args = req.params?.arguments ?? {};
+                const result = await handleToolCall(config, toolName, args);
+                sendResult(req.id, result);
+                break;
+            }
+            case 'ping':
+                sendResult(req.id, {});
+                break;
+            default:
+                if (req.id !== undefined) {
+                    sendError(req.id, -32601, `Method not found: ${req.method}`);
+                }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (req.id !== undefined) {
+            sendError(req.id, -32603, message);
+        }
+    }
+}
+async function handleToolCall(config, toolName, args) {
+    try {
+        switch (toolName) {
+            case 'list_knowledge': {
+                const data = await apiCall(config, 'GET', `/agent-knowledge?agent_id=${config.agentId}`);
+                const items = data.items || [];
+                if (items.length === 0) {
+                    return { content: [{ type: 'text', text: 'No knowledge documents found for this agent.' }] };
+                }
+                const listing = items.map((k) => `- **${k.name}** (ID: ${k._id})\n  ${k.description || 'No description'}\n  Size: ${k.file_size} bytes | Updated: ${k.updated_at}`).join('\n\n');
+                return { content: [{ type: 'text', text: `Found ${items.length} knowledge document(s):\n\n${listing}` }] };
+            }
+            case 'read_knowledge': {
+                if (!args.knowledge_id) {
+                    return { content: [{ type: 'text', text: 'Error: knowledge_id is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'GET', `/agent-knowledge/${args.knowledge_id}`);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ${data.name}\n\n${data.description ? `> ${data.description}\n\n` : ''}${data.content}`,
+                        }],
+                };
+            }
+            case 'create_knowledge': {
+                if (!args.name || !args.content) {
+                    return { content: [{ type: 'text', text: 'Error: name and content are required' }], isError: true };
+                }
+                const data = await apiCall(config, 'POST', '/agent-knowledge', {
+                    name: args.name,
+                    content: args.content,
+                    description: args.description || '',
+                    agent_id: config.agentId,
+                });
+                return { content: [{ type: 'text', text: `Knowledge "${data.name}" created (ID: ${data._id})` }] };
+            }
+            case 'update_knowledge': {
+                if (!args.knowledge_id) {
+                    return { content: [{ type: 'text', text: 'Error: knowledge_id is required' }], isError: true };
+                }
+                const body = {};
+                if (args.name)
+                    body.name = args.name;
+                if (args.content)
+                    body.content = args.content;
+                if (args.description)
+                    body.description = args.description;
+                const data = await apiCall(config, 'PUT', `/agent-knowledge/${args.knowledge_id}`, body);
+                return { content: [{ type: 'text', text: `Knowledge "${data.name}" updated (ID: ${data._id})` }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${toolName}` }], isError: true };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+}
+// ===== Stdio Transport =====
+function startServer(config) {
+    process.stderr.write(`[knowledge-mcp] Starting with agent ${config.agentId}\n`);
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        // Claude Code sends newline-delimited JSON (one JSON object per line)
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? ''; // Keep incomplete last line in buffer
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const req = JSON.parse(trimmed);
+                handleRequest(config, req).catch((err) => {
+                    process.stderr.write(`[knowledge-mcp] Error handling ${req.method}: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write(`[knowledge-mcp] Failed to parse JSON: ${trimmed.slice(0, 100)}\n`);
+            }
+        }
+    });
+    process.stdin.on('end', () => {
+        process.stderr.write('[knowledge-mcp] stdin closed, shutting down\n');
+        process.exit(0);
+    });
+}
+// ===== Main =====
+const config = parseArgs();
+startServer(config);
+export {};

package/dist/mcp/setup.d.ts

@@ -0,0 +1,20 @@
+import type { AgentConfig } from '../types/index.js';
+/**
+ * Generate MCP server config file for Claude Code.
+ * This file is auto-detected by runClaude and passed via --mcp-config.
+ */
+export declare function setupMcpConfig(config: AgentConfig): string;
+/**
+ * Get the MCP config path if it exists.
+ */
+export declare function getMcpConfigPath(): string | undefined;
+/**
+ * Write MCP server config into agent's folder .mcp.json.
+ * Claude Code reads .mcp.json automatically for project-level MCPs.
+ * Note: .claude/settings.json mcpServers is NOT reliably read by Claude Code CLI.
+ */
+export declare function writeAgentFolderMcpConfig(agentFolderPath: string, config: AgentConfig): void;
+/**
+ * Clean up MCP config file.
+ */
+export declare function cleanupMcpConfig(): void;

package/dist/mcp/setup.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const MCP_CONFIG_DIR = path.join(process.env.HOME || '', '.tuna-agent');
+const MCP_CONFIG_PATH = path.join(MCP_CONFIG_DIR, 'mcp-config.json');
+/**
+ * Generate MCP server config file for Claude Code.
+ * This file is auto-detected by runClaude and passed via --mcp-config.
+ */
+export function setupMcpConfig(config) {
+    const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const mcpConfig = {
+        mcpServers: {
+            'tuna-knowledge': {
+                command: process.execPath, // full path to current node binary
+                args: [
+                    knowledgeServerPath,
+                    '--api-url', config.apiUrl,
+                    '--token', config.agentToken,
+                    '--agent-id', config.agentId,
+                ],
+            },
+        },
+    };
+    if (!fs.existsSync(MCP_CONFIG_DIR)) {
+        fs.mkdirSync(MCP_CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(MCP_CONFIG_PATH, JSON.stringify(mcpConfig, null, 2));
+    console.log(`[MCP] Config written to ${MCP_CONFIG_PATH}`);
+    return MCP_CONFIG_PATH;
+}
+/**
+ * Get the MCP config path if it exists.
+ */
+export function getMcpConfigPath() {
+    if (fs.existsSync(MCP_CONFIG_PATH)) {
+        return MCP_CONFIG_PATH;
+    }
+    return undefined;
+}
+/**
+ * Write MCP server config into agent's folder .mcp.json.
+ * Claude Code reads .mcp.json automatically for project-level MCPs.
+ * Note: .claude/settings.json mcpServers is NOT reliably read by Claude Code CLI.
+ */
+export function writeAgentFolderMcpConfig(agentFolderPath, config) {
+    const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    try {
+        const mcpJsonPath = path.join(agentFolderPath, '.mcp.json');
+        // Read existing .mcp.json to preserve other servers (e.g. playwright)
+        let existing = {};
+        if (fs.existsSync(mcpJsonPath)) {
+            existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+        }
+        const existingServers = existing.mcpServers ?? {};
+        existing.mcpServers = {
+            ...existingServers,
+            'tuna-knowledge': {
+                command: process.execPath,
+                args: [
+                    knowledgeServerPath,
+                    '--api-url', config.apiUrl,
+                    '--token', config.agentToken,
+                    '--agent-id', config.agentId,
+                ],
+            },
+        };
+        fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
+        console.log(`[MCP] Agent folder .mcp.json written to ${mcpJsonPath}`);
+    }
+    catch (err) {
+        console.warn(`[MCP] Failed to write agent folder .mcp.json:`, err);
+    }
+}
+/**
+ * Clean up MCP config file.
+ */
+export function cleanupMcpConfig() {
+    if (fs.existsSync(MCP_CONFIG_PATH)) {
+        fs.unlinkSync(MCP_CONFIG_PATH);
+    }
+}

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export interface AgentConfig {
     agentConfig?: {
         openclawGatewayUrl?: string;
     };
+    extensionCodes?: string[];
 }
 export interface AgentCapabilities {
     supports_teams: boolean;
@@ -41,6 +42,7 @@ export interface TaskAssignment {
     confirmBeforeEdit?: boolean;
     attachments?: ChatAttachment[];
     source?: 'manual' | 'skill' | 'scheduled' | 'workflow' | 'api';
+    agentId?: string;
 }
 export interface ConnectResponse {
     machine_id: string;

package/dist/utils/claude-cli.d.ts

@@ -20,6 +20,8 @@ export interface ClaudeCliOptions {
     onPermissionRequest?: (tool: string, detail: string) => Promise<boolean>;
     /** Local file paths to pass as input (e.g., images) via --input-file flags */
     inputFiles?: string[];
+    /** Path to MCP server config JSON file (passed via --mcp-config) */
+    mcpConfigPath?: string;
 }
 export interface ClaudeCliResult {
     result: string;

package/dist/utils/claude-cli.js

@@ -1,5 +1,6 @@
 import { spawn, execSync } from 'child_process';
 import { StringDecoder } from 'string_decoder';
+import { getMcpConfigPath } from '../mcp/setup.js';
 /** Cached absolute path to `claude` binary, resolved once at first use */
 let _claudeBinPath = null;
 function getClaudeBinPath() {
@@ -101,6 +102,11 @@ export function runClaude(options) {
             args.push('--tools', ''); // skip built-in tools
             args.push('--disable-slash-commands'); // skip skills/plugins
         }
+        // Auto-detect MCP config for knowledge server (skip if lightweight mode)
+        const mcpConfig = options.mcpConfigPath || (!options.lightweight ? getMcpConfigPath() : undefined);
+        if (mcpConfig) {
+            args.push('--mcp-config', mcpConfig);
+        }
         if (options.permissionMode) {
             args.push('--permission-mode', options.permissionMode);
         }
@@ -111,6 +117,7 @@ export function runClaude(options) {
             }
         }
         const useInteractiveStdin = !!options.permissionMode && !!options.onPermissionRequest;
+        console.log(`[claude-cli] Spawning with args: ${args.filter(a => !a.startsWith('sk-') && a.length < 200).join(' ')}`);
         const claudeBin = getClaudeBinPath();
         // Ensure PATH includes common bin dirs so shebang `#!/usr/bin/env node` resolves
         const spawnPath = [
@@ -198,6 +205,10 @@ export function runClaude(options) {
         proc.stderr.on('data', (chunk) => {
             const text = stderrDecoder.write(chunk);
             stderr += text;
+            // Log stderr for debugging (MCP server startup errors, etc.)
+            if (text.trim()) {
+                console.log(`[claude-cli] stderr: ${text.trim().substring(0, 300)}`);
+            }
             // Detect permission prompts from Claude Code on stderr
             if (useInteractiveStdin) {
                 handlePermissionPrompt(text, proc, options.onPermissionRequest);

package/dist/utils/message-schemas.d.ts

@@ -29,10 +29,13 @@ export declare const CommandMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"command">;
     command: z.ZodString;
     workspace_path: z.ZodOptional<z.ZodString>;
+    agent_folders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    folder_path: z.ZodOptional<z.ZodString>;
     skill_id: z.ZodOptional<z.ZodString>;
     source_path: z.ZodOptional<z.ZodString>;
     skill_name: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 export declare const TaskCancelledSchema: z.ZodObject<{
     type: z.ZodLiteral<"task_cancelled">;
     taskId: z.ZodString;

package/dist/utils/message-schemas.js

@@ -21,11 +21,16 @@ export const CommandMessageSchema = z.object({
     type: z.literal('command'),
     command: z.string().min(1),
     workspace_path: z.string().optional(),
+    // For scan_workspace command
+    agent_folders: z.array(z.string()).optional(),
+    // For rescan_agent_skills command
+    agent_id: z.string().optional(),
+    folder_path: z.string().optional(),
     // For analyze_skill command
     skill_id: z.string().optional(),
     source_path: z.string().optional(),
     skill_name: z.string().optional(),
-});
+}).passthrough();
 export const TaskCancelledSchema = z.object({
     type: z.literal('task_cancelled'),
     taskId: z.string().min(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"