npm - kanon-cli - Versions diffs - 0.1.0 → 0.1.2 - Mend

kanon-cli 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/bin/kanon.js +134 -1
package/package.json +5 -3
package/src/commands/canvas.js +45 -0
package/src/commands/card.js +14 -1
package/src/commands/cards.js +3 -2
package/src/commands/label.js +1 -1
package/src/commands/list.js +1 -1
package/src/commands/note.js +79 -0
package/src/commands/sheet.js +137 -0
package/src/commands/subcard.js +59 -0
package/src/commands/watch.js +9 -0
package/src/dashboard/dist/assets/index-ClOAcx9M.css +1 -0
package/src/dashboard/dist/assets/index-DrHjrBfj.js +216 -0
package/src/dashboard/dist/index.html +2 -2
package/src/dashboard/server/index.js +36 -1
package/src/dashboard/server/proxy.js +5 -1
package/src/dashboard/server/settings.js +251 -11
package/src/lib/admin.js +29 -3
package/src/lib/api.js +55 -0
package/src/lib/claude.js +65 -9
package/src/prompts/templates.js +55 -19
package/src/dashboard/dist/assets/index-Dcbpx-Xz.js +0 -186
package/src/dashboard/dist/assets/index-DhFfv70f.css +0 -1

package/src/dashboard/dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Kanon Dashboard</title>
-    <script type="module" crossorigin src="/assets/index-Dcbpx-Xz.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DhFfv70f.css">
+    <script type="module" crossorigin src="/assets/index-DrHjrBfj.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-ClOAcx9M.css">
   </head>
   <body class="h-full text-gray-100">
     <div id="root" class="h-full"></div>

package/src/dashboard/server/index.js CHANGED Viewed

@@ -12,13 +12,48 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function createDashboardServer(port = 3737) {
   const app = express();
-  app.use(express.json());
+  app.use(express.json({ limit: '5mb' }));
   // API routes
   app.use('/api/kanon', createProxyRoutes());
   app.use('/api/settings', createSettingsRoutes());
   app.use('/api/agent', createAgentRoutes());
+  // GET /api/version — current version + check for updates
+  app.get('/api/version', async (req, res) => {
+    try {
+      const pkgPath = path.resolve(__dirname, '../../../package.json');
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const current = pkg.version;
+      let latest = current;
+      try {
+        const resp = await fetch('https://registry.npmjs.org/kanon-cli/latest', {
+          headers: { 'Accept': 'application/json' },
+          signal: AbortSignal.timeout(3000),
+        });
+        if (resp.ok) {
+          const data = await resp.json();
+          latest = data.version || current;
+        }
+      } catch {}
+      res.json({ current, latest, updateAvailable: latest !== current });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // POST /api/update — run npm update -g kanon-cli
+  app.post('/api/update', async (req, res) => {
+    try {
+      execSync('npm install -g kanon-cli@latest', { stdio: 'pipe', timeout: 30000 });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.stderr?.toString() || err.message });
+    }
+  });
   // POST /api/restart — restart server, optionally rebuild dashboard first
   app.post('/api/restart', async (req, res) => {
     const rebuild = req.query.rebuild === '1';

package/src/dashboard/server/proxy.js CHANGED Viewed

@@ -10,8 +10,12 @@ export function createProxyRoutes() {
     const serverUrl = getServerUrl();
     try {
+      if (!config.token) {
+        return res.status(401).json({ error: 'Agent not configured. Set up your agent on the Credentials page first.' });
+      }
       const headers = { 'Content-Type': 'application/json' };
-      if (config.token) headers['Authorization'] = `Bearer ${config.token}`;
+      headers['Authorization'] = `Bearer ${config.token}`;
       const opts = { method, headers };
       if (req.body && Object.keys(req.body).length) {

package/src/dashboard/server/settings.js CHANGED Viewed

@@ -172,32 +172,164 @@ export function createSettingsRoutes() {
     }
   });
-  // GET /api/settings/credentials — returns global config (masked password)
-  router.get('/credentials', (req, res) => {
+  // GET /api/settings/credentials — returns global config + agent profile from server
+  router.get('/credentials', async (req, res) => {
     const config = loadGlobalConfig();
-    res.json({
+    const base = {
       server_url: config.server_url || '',
       email: config.email || '',
-      password: config.password ? '********' : '',
+      password: config.password || '',
       token: config.token || '',
       user_name: config.user_name || '',
       user_id: config.user_id || '',
-    });
+    };
+    // Fetch agent profile from server if we have a token
+    if (config.token) {
+      try {
+        const serverUrl = getServerUrl();
+        const profileRes = await fetch(`${serverUrl}/api/auth/me`, {
+          headers: { 'Authorization': `Bearer ${config.token}` },
+        });
+        if (profileRes.ok) {
+          const profile = await profileRes.json();
+          const user = profile.user || profile;
+          base.user_name = user.name || base.user_name;
+          base.color = user.color || '#6366f1';
+          base.avatar = user.avatar || '';
+        }
+      } catch {}
+    }
+    res.json(base);
   });
   // PUT /api/settings/credentials — update global config
   router.put('/credentials', (req, res) => {
     try {
       const current = loadGlobalConfig();
-      const update = { ...current };
+      const email = req.body.email ?? current.email ?? '';
+      // If email is cleared, also clear auth fields
+      const clearAuth = !email;
+      saveGlobalConfig({
+        server_url: req.body.server_url ?? current.server_url ?? '',
+        email,
+        password: clearAuth ? '' : (req.body.password ?? current.password ?? ''),
+        token: clearAuth ? '' : (req.body.token ?? current.token ?? ''),
+        user_id: clearAuth ? '' : (req.body.user_id ?? current.user_id ?? ''),
+        user_name: clearAuth ? '' : (req.body.user_name ?? current.user_name ?? ''),
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // PUT /api/settings/agent-profile — update agent name and color on Kanon server
+  router.put('/agent-profile', async (req, res) => {
+    try {
+      const config = loadGlobalConfig();
+      if (!config.token) return res.status(401).json({ error: 'Not logged in' });
+      const serverUrl = getServerUrl();
+      const { name, color } = req.body;
+      const profileRes = await fetch(`${serverUrl}/api/auth/me`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${config.token}`,
+        },
+        body: JSON.stringify({ name, color }),
+      });
+      if (!profileRes.ok) {
+        const data = await profileRes.json().catch(() => ({}));
+        return res.status(profileRes.status).json({ error: data.error || 'Failed to update profile' });
+      }
+      // Update local config name
+      if (name) saveGlobalConfig({ ...config, user_name: name });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // POST /api/settings/agent-avatar — upload agent avatar to Kanon server
+  router.post('/agent-avatar', async (req, res) => {
+    try {
+      const config = loadGlobalConfig();
+      if (!config.token) return res.status(401).json({ error: 'Not logged in' });
+      const serverUrl = getServerUrl();
+      const { image } = req.body;
+      if (!image) return res.status(400).json({ error: 'No image data' });
+      const avatarRes = await fetch(`${serverUrl}/api/auth/me/avatar`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${config.token}`,
+        },
+        body: JSON.stringify({ image }),
+      });
+      if (!avatarRes.ok) {
+        const data = await avatarRes.json().catch(() => ({}));
+        return res.status(avatarRes.status).json({ error: data.error || 'Failed to upload avatar' });
+      }
+      const data = await avatarRes.json();
+      res.json({ ok: true, avatar: data.user?.avatar || data.avatar });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // DELETE /api/settings/agent-avatar — remove agent avatar
+  router.delete('/agent-avatar', async (req, res) => {
+    try {
+      const config = loadGlobalConfig();
+      if (!config.token) return res.status(401).json({ error: 'Not logged in' });
+      const serverUrl = getServerUrl();
+      const delRes = await fetch(`${serverUrl}/api/auth/me/avatar`, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${config.token}` },
+      });
+      if (!delRes.ok) {
+        const data = await delRes.json().catch(() => ({}));
+        return res.status(delRes.status).json({ error: data.error || 'Failed to remove avatar' });
+      }
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // DELETE /api/settings/agent-account — delete agent account from Kanon server + clear local config
+  router.delete('/agent-account', async (req, res) => {
+    try {
+      const config = loadGlobalConfig();
+      if (!config.token) return res.status(401).json({ error: 'Not logged in' });
+      const serverUrl = getServerUrl();
+      const delRes = await fetch(`${serverUrl}/api/auth/me`, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${config.token}` },
+      });
-      if (req.body.server_url) update.server_url = req.body.server_url;
-      if (req.body.email) update.email = req.body.email;
-      if (req.body.password && req.body.password !== '********') {
-        update.password = req.body.password;
+      if (!delRes.ok) {
+        const data = await delRes.json().catch(() => ({}));
+        return res.status(delRes.status).json({ error: data.error || 'Failed to delete account' });
       }
-      saveGlobalConfig(update);
+      // Clear local credentials
+      saveGlobalConfig({ server_url: config.server_url });
       res.json({ ok: true });
     } catch (err) {
       res.status(500).json({ error: err.message });
@@ -232,5 +364,113 @@ export function createSettingsRoutes() {
     }
   });
+  // POST /api/settings/provision-agent — log in as user, create agent, save credentials
+  router.post('/provision-agent', async (req, res) => {
+    try {
+      const { email, password, agent_name, team_ids } = req.body;
+      const serverUrl = getServerUrl();
+      if (!email || !password || !agent_name) {
+        return res.status(400).json({ error: 'Email, password, and agent name are required' });
+      }
+      // 1. Log in with user's personal credentials
+      const loginRes = await fetch(`${serverUrl}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+      });
+      if (!loginRes.ok) {
+        const data = await loginRes.json().catch(() => ({}));
+        return res.status(401).json({ error: data.error || 'Login failed. Check your email and password.' });
+      }
+      const loginData = await loginRes.json();
+      const userToken = loginData.token;
+      // 2. Provision agent via Kanon API
+      const provisionRes = await fetch(`${serverUrl}/api/agents/provision`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${userToken}`,
+        },
+        body: JSON.stringify({ name: agent_name, team_ids: team_ids || [] }),
+      });
+      if (!provisionRes.ok) {
+        const data = await provisionRes.json().catch(() => ({}));
+        return res.status(provisionRes.status).json({ error: data.error || 'Failed to provision agent' });
+      }
+      const provisionData = await provisionRes.json();
+      const agent = provisionData.agent;
+      // 3. Save agent credentials to global config
+      const current = loadGlobalConfig();
+      saveGlobalConfig({
+        ...current,
+        server_url: serverUrl,
+        email: agent.email,
+        password: agent.password || current.password,
+        token: agent.token,
+        user_id: agent.id,
+        user_name: agent.name,
+      });
+      res.json({
+        ok: true,
+        created: provisionData.created,
+        agent: {
+          id: agent.id,
+          email: agent.email,
+          name: agent.name,
+          teams: agent.teams || [],
+        },
+        skippedTeams: provisionData.skippedTeams || [],
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  // POST /api/settings/provision-teams — get user's teams for provisioning UI
+  router.post('/provision-teams', async (req, res) => {
+    try {
+      const { email, password } = req.body;
+      const serverUrl = getServerUrl();
+      // Log in to get token
+      const loginRes = await fetch(`${serverUrl}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+      });
+      if (!loginRes.ok) {
+        const data = await loginRes.json().catch(() => ({}));
+        return res.status(401).json({ error: data.error || 'Login failed' });
+      }
+      const loginData = await loginRes.json();
+      // Fetch teams
+      const teamsRes = await fetch(`${serverUrl}/api/agents/teams`, {
+        headers: { 'Authorization': `Bearer ${loginData.token}` },
+      });
+      if (!teamsRes.ok) {
+        const data = await teamsRes.json().catch(() => ({}));
+        return res.status(teamsRes.status).json({ error: data.error || `Failed to fetch teams. Please try again later.` });
+      }
+      const teamsData = await teamsRes.json();
+      res.json(teamsData);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
   return router;
 }

package/src/lib/admin.js CHANGED Viewed

@@ -1,9 +1,21 @@
 import chalk from 'chalk';
 import fs from 'fs';
-import { getStatusPath } from './config.js';
+import { getStatusPath, getServerUrl, getToken } from './config.js';
 import { getActiveWorkers, killWorker, spawnClaude } from './claude.js';
 import { buildBundlePrompt } from '../prompts/templates.js';
+/** Fire-and-forget POST to server for agent status changes */
+function _notifyAgentStatus(cardId, boardId, action, extra = {}) {
+  const serverUrl = getServerUrl();
+  const token = getToken();
+  if (!serverUrl || !token || !boardId) return;
+  fetch(`${serverUrl}/api/agents/status`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+    body: JSON.stringify({ cardId, boardId, action, ...extra }),
+  }).catch(() => {});
+}
 export class AgentController {
   constructor(config = {}) {
     this.checkInterval = (config.check_interval_seconds || 60) * 1000;
@@ -113,6 +125,7 @@ export class AgentController {
     }
     this.queue.push({ cardId, prompt, config: claudeConfig, priority, addedAt: Date.now(), card, extraPrompt, boardId });
+    _notifyAgentStatus(cardId, boardId, 'queue');
     // Sort by priority (higher first), then by time (older first)
     this.queue.sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
@@ -202,8 +215,16 @@ export class AgentController {
     }
     this.log('info', null, `Starting bundled worker for ${tasks.length} cards: ${cardIds.map(id => id.substring(0, 8)).join(', ')}`);
-    const worker = spawnClaude(bundleId, combinedPrompt, tasks[0].config);
+    const worker = spawnClaude(bundleId, combinedPrompt, { ...tasks[0].config, boardId: tasks[0].boardId, outputCardId: tasks[0].cardId });
     if (worker?.process) {
+      // Notify primary card as active, others as bundled
+      for (const t of tasks) {
+        const isPrimary = t === tasks[0];
+        _notifyAgentStatus(t.cardId, t.boardId, 'start', {
+          bundleId,
+          primaryCardId: isPrimary ? null : tasks[0].cardId,
+        });
+      }
       worker.process.on('close', (code) => {
         this._decBoard(boardKey);
         this.completedWorkers.push({
@@ -217,6 +238,9 @@ export class AgentController {
           output: worker.output.slice(-50),
         });
         if (this.completedWorkers.length > 10) this.completedWorkers.shift();
+        for (const cid of cardIds) {
+          _notifyAgentStatus(cid, tasks[0].boardId, 'stop', { exitCode: code });
+        }
         this.log(code === 0 ? 'info' : 'warn', null, `Bundled worker finished (exit ${code}, ${Math.round((Date.now() - worker.startedAt) / 1000)}s) — cards: ${cardIds.map(id => id.substring(0, 8)).join(', ')}`);
         this._processQueue();
       });
@@ -225,8 +249,9 @@ export class AgentController {
   _startSingleWorker(task, boardKey) {
     this.log('info', task.cardId, 'Starting worker from queue');
-    const worker = spawnClaude(task.cardId, task.prompt, task.config);
+    const worker = spawnClaude(task.cardId, task.prompt, { ...task.config, boardId: task.boardId });
     if (worker?.process) {
+      _notifyAgentStatus(task.cardId, task.boardId, 'start');
       worker.process.on('close', (code) => {
         if (boardKey) this._decBoard(boardKey);
         this.completedWorkers.push({
@@ -238,6 +263,7 @@ export class AgentController {
           output: worker.output.slice(-50),
         });
         if (this.completedWorkers.length > 10) this.completedWorkers.shift();
+        _notifyAgentStatus(task.cardId, task.boardId, 'stop', { exitCode: code });
         this.log(code === 0 ? 'info' : 'warn', task.cardId, `Worker finished (exit ${code}, ${Math.round((Date.now() - worker.startedAt) / 1000)}s)`);
         this._processQueue();
       });

package/src/lib/api.js CHANGED Viewed

@@ -219,6 +219,61 @@ class KanonAPI {
     }
     return res.json();
   }
+  // --- Subcards ---
+  async setParent(cardId, parentCardId) {
+    return this.request('PUT', `/cards/${cardId}/set-parent`, { parentCardId });
+  }
+  // --- Sheets ---
+  async getSheet(cardId) {
+    return this.request('GET', `/cards/${cardId}/sheet`);
+  }
+  async createSheet(cardId) {
+    return this.request('POST', `/cards/${cardId}/sheet`);
+  }
+  async updateSheet(cardId, data) {
+    return this.request('PUT', `/cards/${cardId}/sheet`, { data });
+  }
+  async updateSheetCell(cardId, { tab, row, col, value }) {
+    return this.request('PUT', `/cards/${cardId}/sheet/cell`, { tab, row, col, value });
+  }
+  async deleteSheet(cardId) {
+    return this.request('DELETE', `/cards/${cardId}/sheet`);
+  }
+  // --- Notes (plaintext) ---
+  async getNoteText(cardId) {
+    return this.request('GET', `/cards/${cardId}/note/text`);
+  }
+  async setNoteText(cardId, text) {
+    return this.request('PUT', `/cards/${cardId}/note/text`, { text });
+  }
+  async appendNoteText(cardId, text) {
+    return this.request('POST', `/cards/${cardId}/note/text/append`, { text });
+  }
+  async createNote(cardId) {
+    return this.request('POST', `/cards/${cardId}/note`);
+  }
+  async deleteNote(cardId) {
+    return this.request('DELETE', `/cards/${cardId}/note`);
+  }
+  // --- Canvas/Whiteboard ---
+  async getCanvasSummary(cardId) {
+    return this.request('GET', `/cards/${cardId}/whiteboard/summary`);
+  }
 }
 export const api = new KanonAPI();

package/src/lib/claude.js CHANGED Viewed

@@ -1,7 +1,9 @@
 import { spawn } from 'child_process';
+import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
+import { getServerUrl, getToken } from './config.js';
 // Resolve the bin/ directory so `kanon` is in PATH for spawned Claude sessions
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -10,6 +12,19 @@ const kanonBinDir = path.resolve(__dirname, '../../bin');
 /** Active Claude processes indexed by cardId */
 const activeWorkers = new Map();
+/** Fire-and-forget POST to server for agent output streaming */
+function _flushToServer(cardId, boardId, lines, config) {
+  const serverUrl = getServerUrl();
+  const token = getToken();
+  if (!serverUrl || !token) return;
+  fetch(`${serverUrl}/api/agents/output`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+    body: JSON.stringify({ cardId, boardId, lines }),
+  }).catch(() => {}); // fire-and-forget
+}
 /**
  * Spawn a Claude Code process for a card.
  * Returns a WorkerInfo object tracked by the agent controller.
@@ -35,6 +50,16 @@ export function spawnClaude(cardId, prompt, config = {}) {
   const projectDir = config.project_dir || process.cwd();
+  // Write a temporary kanon.config.yaml so `kanon board/cards/list` work inside the agent
+  let tempConfigPath = null;
+  if (config.boardId) {
+    const configPath = path.join(projectDir, 'kanon.config.yaml');
+    if (!fs.existsSync(configPath)) {
+      tempConfigPath = configPath;
+      fs.writeFileSync(configPath, `board_id: "${config.boardId}"\n`);
+    }
+  }
   const worker = {
     cardId,
     startedAt: Date.now(),
@@ -42,6 +67,10 @@ export function spawnClaude(cardId, prompt, config = {}) {
     output: [],
     exitCode: null,
     process: null,
+    _pendingServerLines: [],
+    _boardId: config.boardId || null,
+    _outputCardId: config.outputCardId || null,
+    _tempConfigPath: tempConfigPath,
   };
   const proc = spawn(claudeCmd, args, {
@@ -53,6 +82,14 @@ export function spawnClaude(cardId, prompt, config = {}) {
   worker.process = proc;
+  // Flush pending output to server every 3 seconds + poll for kill requests
+  worker._flushTimer = setInterval(() => {
+    if (worker._pendingServerLines.length > 0 && worker._boardId) {
+      const lines = worker._pendingServerLines.splice(0);
+      _flushToServer(worker._outputCardId || worker.cardId, worker._boardId, lines, config);
+    }
+  }, 3000);
   // Buffer for incomplete JSON lines from stream-json output
   let stdoutBuf = '';
@@ -73,7 +110,8 @@ export function spawnClaude(cardId, prompt, config = {}) {
         // Not valid JSON – store raw line as-is
         worker.lastOutput = Date.now();
         worker.output.push(trimmed);
-        if (worker.output.length > 100) worker.output.shift();
+        worker._pendingServerLines.push(trimmed);
+        if (worker.output.length > 500) worker.output.shift();
         continue;
       }
@@ -84,21 +122,28 @@ export function spawnClaude(cardId, prompt, config = {}) {
         for (const block of parsed.message.content) {
           if (block.type === 'text' && block.text) {
             worker.output.push(block.text);
+            worker._pendingServerLines.push(block.text);
           } else if (block.type === 'tool_use') {
             const name = block.name || 'unknown';
             const inputPreview = block.input
               ? JSON.stringify(block.input).substring(0, 120)
               : '';
-            worker.output.push(`[Tool: ${name}] ${inputPreview}`);
+            const toolLine = `[Tool: ${name}] ${inputPreview}`;
+            worker.output.push(toolLine);
+            worker._pendingServerLines.push(toolLine);
           }
-          if (worker.output.length > 100) worker.output.shift();
+          if (worker.output.length > 500) worker.output.shift();
         }
       } else if (parsed.type === 'result' && parsed.result) {
-        worker.output.push(`[Result] ${parsed.result.substring(0, 200)}`);
-        if (worker.output.length > 100) worker.output.shift();
+        const resultLine = `[Result] ${parsed.result.substring(0, 200)}`;
+        worker.output.push(resultLine);
+        worker._pendingServerLines.push(resultLine);
+        if (worker.output.length > 500) worker.output.shift();
       } else if (parsed.type === 'error') {
-        worker.output.push(`[Error] ${parsed.error?.message || JSON.stringify(parsed)}`);
-        if (worker.output.length > 100) worker.output.shift();
+        const errorLine = `[Error] ${parsed.error?.message || JSON.stringify(parsed)}`;
+        worker.output.push(errorLine);
+        worker._pendingServerLines.push(errorLine);
+        if (worker.output.length > 500) worker.output.shift();
       }
       // Silently skip other message types (system, etc.)
     }
@@ -107,12 +152,23 @@ export function spawnClaude(cardId, prompt, config = {}) {
   proc.stderr.on('data', (data) => {
     const line = data.toString();
     worker.lastOutput = Date.now();
-    worker.output.push(`[stderr] ${line}`);
-    if (worker.output.length > 100) worker.output.shift();
+    const stderrLine = `[stderr] ${line}`;
+    worker.output.push(stderrLine);
+    worker._pendingServerLines.push(stderrLine);
+    if (worker.output.length > 500) worker.output.shift();
   });
   proc.on('close', (code) => {
     worker.exitCode = code;
+    clearInterval(worker._flushTimer);
+    // Final flush
+    if (worker._pendingServerLines.length > 0 && worker._boardId) {
+      _flushToServer(worker._outputCardId || worker.cardId, worker._boardId, worker._pendingServerLines.splice(0), config);
+    }
+    // Clean up temp config
+    if (worker._tempConfigPath) {
+      try { fs.unlinkSync(worker._tempConfigPath); } catch {}
+    }
     activeWorkers.delete(cardId);
     console.log(chalk.dim(`Worker for card ${cardId} exited with code ${code}`));
   });