clawmini 0.0.3 → 0.0.5

package/src/daemon/cron.ts

@@ -2,12 +2,12 @@
 import schedule from 'node-schedule';
 import { listChats } from '../shared/chats.js';
 import { readChatSettings, writeChatSettings } from '../shared/workspace.js';
-import { executeDirectMessage, getInitialRouterState } from './message.js';
+import { executeDirectMessage, getInitialRouterState, applyRouterStateUpdates } from './message.js';
+import { executeRouterPipeline, resolveRouters } from './routers.js';
 import type { CronJob, Settings } from '../shared/config.js';
 import fs from 'node:fs/promises';
 import { getSettingsPath } from '../shared/workspace.js';
 import { applyEnvOverrides } from '../shared/utils/env.js';
-import { runCommand } from './utils/spawn.js';
 
 export class CronManager {
   private jobs = new Map<string, schedule.Job>();
@@ -117,11 +117,12 @@ export class CronManager {
         globalSettings = undefined;
       }
 
-      const overrideSessionId = job.session?.type === 'new' ? crypto.randomUUID() : undefined;
-      const routerState = await getInitialRouterState(
+      const overrideSessionId = job.session?.type === 'new' ? crypto.randomUUID() : job.session?.id;
+      const chatSettings = (await readChatSettings(chatId, process.cwd())) ?? {};
+      let routerState = await getInitialRouterState(
         chatId,
         job.message,
-        process.cwd(),
+        chatSettings,
         job.agentId,
         overrideSessionId
       );
@@ -130,16 +131,42 @@ export class CronManager {
         routerState.env = routerState.env || {};
         applyEnvOverrides(routerState.env, job.env);
       }
-      if (job.reply !== undefined) routerState.reply = job.reply;
+
+      const currentAgentId = job.agentId ?? chatSettings.defaultAgent ?? 'default';
+      const currentActiveSession = chatSettings.sessions?.[currentAgentId];
+      const isOutdatedSession =
+        job.session?.type === 'existing' &&
+        currentActiveSession !== undefined &&
+        currentActiveSession !== job.session.id;
+
+      if (job.reply !== undefined && !isOutdatedSession) routerState.reply = job.reply;
+      if (job.nextSessionId !== undefined && !isOutdatedSession)
+        routerState.nextSessionId = job.nextSessionId;
+      if (job.action !== undefined) routerState.action = job.action;
+      if (job.jobs !== undefined) routerState.jobs = job.jobs;
+
+      const routers = chatSettings.routers ?? globalSettings?.routers ?? [];
+      const resolvedRouters = resolveRouters(routers, false);
+      const initialState = { ...routerState };
+      routerState = await executeRouterPipeline(routerState, resolvedRouters);
+
+      await applyRouterStateUpdates(
+        chatId,
+        process.cwd(),
+        routerState,
+        chatSettings,
+        initialState.agentId
+      );
 
       await executeDirectMessage(
         chatId,
         routerState,
         globalSettings,
         process.cwd(),
-        runCommand,
         false,
-        job.message
+        job.message,
+        undefined,
+        'cron'
       );
 
       if (isOneOff) {

package/src/daemon/index.ts

@@ -12,7 +12,9 @@ import {
   readEnvironment,
   getEnvironmentPath,
   getWorkspaceRoot,
+  updateChatSettings,
 } from '../shared/workspace.js';
+import { listChats } from '../shared/chats.js';
 import { cronManager } from './cron.js';
 import { SettingsSchema } from '../shared/config.js';
 import { validateToken, getApiContext } from './auth.js';
@@ -140,6 +142,27 @@ export async function initDaemon() {
     });
   });
 
+  const cleanOrphanedSubagents = async () => {
+    try {
+      const chats = await listChats();
+      for (const chatId of chats) {
+        await updateChatSettings(chatId, (settings) => {
+          if (settings.subagents) {
+            for (const subagent of Object.values(settings.subagents)) {
+              if (subagent.status === 'active') {
+                subagent.status = 'failed';
+              }
+            }
+          }
+          return settings;
+        });
+      }
+    } catch (err) {
+      console.warn('Failed to clean orphaned subagents:', err);
+    }
+  };
+  await cleanOrphanedSubagents();
+
   await runHooks('up');
 
   isReady = true;

package/src/daemon/message-agent.test.ts

@@ -3,14 +3,21 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { handleUserMessage } from './message.js';
 import * as workspace from '../shared/workspace.js';
 import { spawn } from 'node:child_process';
-import { runCommandCallback, createAutoFinishMockSpawn } from './message-test-utils.js';
+import { createAutoFinishMockSpawn } from './message-test-utils.js';
 
 vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
 vi.mock('../shared/chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
 vi.mock('./routers.js', () => ({
+  resolveRouters: vi.fn((routers) => routers),
   executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
 }));
 vi.mock('../shared/workspace.js', () => ({
+  resolveAgentWorkDir: vi
+    .fn()
+    .mockImplementation((id, dir, root) => (dir ? `${root}/${dir}` : `${root}/${id}`)),
+
+  readSettings: vi.fn().mockResolvedValue(null),
+
   readChatSettings: vi.fn().mockResolvedValue(null),
   writeChatSettings: vi.fn().mockResolvedValue(undefined),
   readAgentSessionSettings: vi.fn().mockResolvedValue(null),
@@ -50,14 +57,7 @@ describe('Agent Configuration & Execution CWD', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat-custom',
-      'hello',
-      settings as any,
-      '/dir',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-custom', 'hello', settings as any, '/dir', false);
 
     expect(workspace.getAgent).toHaveBeenCalledWith('custom-agent', '/dir');
     expect(mockSpawn).toHaveBeenCalledWith(
@@ -83,14 +83,7 @@ describe('Agent Configuration & Execution CWD', () => {
 
     const settings = { defaultAgent: { commands: { new: 'echo main' } } };
 
-    await handleUserMessage(
-      'chat-dir-1',
-      'hi',
-      settings as any,
-      '/base/workspace',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-dir-1', 'hi', settings as any, '/base/workspace', false);
 
     expect(mockSpawn).toHaveBeenCalledWith(
       'echo agent-dir',
@@ -113,14 +106,7 @@ describe('Agent Configuration & Execution CWD', () => {
 
     const settings = { defaultAgent: { commands: { new: 'echo main' } } };
 
-    await handleUserMessage(
-      'chat-dir-2',
-      'hi',
-      settings as any,
-      '/base/workspace',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-dir-2', 'hi', settings as any, '/base/workspace', false);
 
     expect(mockSpawn).toHaveBeenCalledWith(
       'echo my-dir',

package/src/daemon/message-extraction.test.ts

@@ -4,15 +4,21 @@ import { handleUserMessage } from './message.js';
 import * as workspace from '../shared/workspace.js';
 import * as chats from './chats.js';
 import { spawn } from 'node:child_process';
-import { runCommandCallback } from './message-test-utils.js';
 import { EventEmitter } from 'node:events';
 
 vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
 vi.mock('./chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
 vi.mock('./routers.js', () => ({
+  resolveRouters: vi.fn((routers) => routers),
   executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
 }));
 vi.mock('../shared/workspace.js', () => ({
+  resolveAgentWorkDir: vi
+    .fn()
+    .mockImplementation((id, dir, root) => (dir ? `${root}/${dir}` : `${root}/${id}`)),
+
+  readSettings: vi.fn().mockResolvedValue(null),
+
   readChatSettings: vi.fn().mockResolvedValue(null),
   writeChatSettings: vi.fn().mockResolvedValue(undefined),
   readAgentSessionSettings: vi.fn().mockResolvedValue(null),
@@ -68,14 +74,7 @@ describe('Extraction Logic', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat1',
-      'hello',
-      settings as any,
-      '/dir-extract-1',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat1', 'hello', settings as any, '/dir-extract-1', false);
 
     // Verify spawn was called twice
     expect(mockSpawn).toHaveBeenCalledTimes(2);
@@ -84,15 +83,6 @@ describe('Extraction Logic', () => {
     expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo getSessionId', expect.anything());
 
     // Verify state files were updated
-    expect(workspace.writeChatSettings).toHaveBeenCalledWith(
-      'chat1',
-      expect.objectContaining({
-        defaultAgent: 'my-agent',
-        sessions: { 'my-agent': 'default' },
-      }),
-      '/dir-extract-1'
-    );
-
     expect(workspace.writeAgentSessionSettings).toHaveBeenCalledWith(
       'my-agent',
       'default',
@@ -141,14 +131,7 @@ describe('Extraction Logic', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat1',
-      'hello',
-      settings as any,
-      '/dir-extract-2',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat1', 'hello', settings as any, '/dir-extract-2', false);
 
     expect(mockSpawn).toHaveBeenCalledTimes(2);
     expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo getMessageContent', expect.anything());
@@ -157,7 +140,7 @@ describe('Extraction Logic', () => {
     expect(chats.appendMessage).toHaveBeenCalledWith(
       'chat1',
       expect.objectContaining({
-        role: 'log',
+        role: 'command',
         content: 'extracted message content',
         stdout: 'main_output',
       })

package/src/daemon/message-fallbacks.test.ts

@@ -2,15 +2,21 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { handleUserMessage, calculateDelay } from './message.js';
 import { spawn } from 'node:child_process';
-import { runCommandCallback } from './message-test-utils.js';
 import * as chats from '../shared/chats.js';
 
 vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
 vi.mock('../shared/chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
 vi.mock('./routers.js', () => ({
+  resolveRouters: vi.fn((routers) => routers),
   executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
 }));
 vi.mock('../shared/workspace.js', () => ({
+  resolveAgentWorkDir: vi
+    .fn()
+    .mockImplementation((id, dir, root) => (dir ? `${root}/${dir}` : `${root}/${id}`)),
+
+  readSettings: vi.fn().mockResolvedValue(null),
+
   readChatSettings: vi.fn().mockResolvedValue(null),
   writeChatSettings: vi.fn().mockResolvedValue(undefined),
   readAgentSessionSettings: vi.fn().mockResolvedValue(null),
@@ -109,14 +115,7 @@ describe('Message Fallbacks & Retries', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat-fallback',
-      'hello',
-      settings as any,
-      '/dir',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-fallback', 'hello', settings as any, '/dir', false);
 
     // Should call base once, then fallback once
     expect(mockSpawn).toHaveBeenCalledTimes(2);
@@ -127,7 +126,7 @@ describe('Message Fallbacks & Retries', () => {
     expect(chats.appendMessage).toHaveBeenCalledWith(
       'chat-fallback',
       expect.objectContaining({
-        role: 'log',
+        role: 'command',
         content: 'output 2',
         exitCode: 0,
       }),
@@ -175,14 +174,7 @@ describe('Message Fallbacks & Retries', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat-empty',
-      'hello',
-      settings as any,
-      '/dir',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-empty', 'hello', settings as any, '/dir', false);
 
     // Call 1: base (success)
     // Call 2: getMessageContent (returns empty -> failure)
@@ -233,14 +225,7 @@ describe('Message Fallbacks & Retries', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat-retries',
-      'hello',
-      settings as any,
-      '/dir',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-retries', 'hello', settings as any, '/dir', false);
 
     // Call 1: base (fail)
     // Call 2: fallback attempt 0 (fail)
@@ -290,20 +275,13 @@ describe('Message Fallbacks & Retries', () => {
       },
     };
 
-    await handleUserMessage(
-      'chat-log-retry',
-      'hello',
-      settings as any,
-      '/dir',
-      false,
-      runCommandCallback
-    );
+    await handleUserMessage('chat-log-retry', 'hello', settings as any, '/dir', false);
 
     // Should find the retry log message
     expect(chats.appendMessage).toHaveBeenCalledWith(
       'chat-log-retry',
       expect.objectContaining({
-        role: 'log',
+        role: 'command',
         content: 'Error running agent, retrying in 1 seconds...',
         command: 'retry-delay',
       }),

package/src/daemon/message-interruption.test.ts

@@ -1,12 +1,22 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { executeDirectMessage } from './message.js';
-import { getMessageQueue } from './queue.js';
+import { taskScheduler } from './agent/task-scheduler.js';
 import type { RouterState } from './routers/types.js';
+import { runCommand } from './utils/spawn.js';
+import { randomUUID } from 'node:crypto';
+
+vi.mock('./utils/spawn.js', () => ({ runCommand: vi.fn() }));
 
 vi.mock('./chats.js', () => ({
   appendMessage: vi.fn().mockResolvedValue(undefined),
 }));
 vi.mock('../shared/workspace.js', () => ({
+  resolveAgentWorkDir: vi
+    .fn()
+    .mockImplementation((id, dir, root) => (dir ? `${root}/${dir}` : `${root}/${id}`)),
+
+  readSettings: vi.fn().mockResolvedValue(null),
+
   readChatSettings: vi.fn().mockResolvedValue(null),
   writeChatSettings: vi.fn().mockResolvedValue(undefined),
   readAgentSessionSettings: vi.fn().mockResolvedValue(null),
@@ -25,55 +35,72 @@ describe('Interruption flow in message handler', () => {
   });
 
   it('stops execution and clears queue when action is stop', async () => {
-    const queue = getMessageQueue('/test-interrupt-stop');
-    const abortSpy = vi.spyOn(queue, 'abortCurrent');
-    const clearSpy = vi.spyOn(queue, 'clear');
+    const sessionId = 'test-interrupt-stop';
+    taskScheduler.abortTasks(sessionId);
+    const abortSpy = vi.spyOn(taskScheduler, 'abortTasks');
 
     const state: RouterState = {
       message: 'stop everything',
       messageId: 'mock-msg-id',
       chatId: 'chat1',
       action: 'stop',
+      sessionId,
     };
 
-    const runCommand = vi.fn();
-    await executeDirectMessage('chat1', state, undefined, '/test-interrupt-stop', runCommand, true);
+    vi.mocked(runCommand).mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
+    await executeDirectMessage('chat1', state, undefined, '/test-interrupt-stop', true);
 
-    expect(abortSpy).toHaveBeenCalled();
-    expect(clearSpy).toHaveBeenCalled();
+    expect(abortSpy).toHaveBeenCalledWith(sessionId);
     expect(runCommand).not.toHaveBeenCalled();
 
     // We expect it NOT to enqueue because it returns early
-    expect(queue['pending'].length).toBe(0);
+    const key = `chat1:${sessionId}`;
+    expect(taskScheduler['queues'].get(key)?.['queue'].length ?? 0).toBe(0);
   });
 
   it('interrupts execution and batches pending tasks when action is interrupt', async () => {
-    const queue = getMessageQueue('/test-interrupt-batch');
-    const abortSpy = vi.spyOn(queue, 'abortCurrent');
+    const sessionId = 'test-interrupt-batch';
+    taskScheduler.abortTasks(sessionId);
+    const interruptSpy = vi.spyOn(taskScheduler, 'interruptTasks');
 
     // Block the queue with a running task so subsequent ones stay pending
-    queue
-      .enqueue(async () => {
-        await new Promise((r) => setTimeout(r, 500));
+    taskScheduler
+      .schedule({
+        id: randomUUID(),
+        rootChatId: 'chat1',
+        dirPath: 'dir1',
+        sessionId,
+        execute: async () => {
+          await new Promise((r) => setTimeout(r, 500));
+        },
       })
       .catch(() => {});
 
     // Enqueue some dummy tasks with payloads
-    queue
-      .enqueue(
-        async () => {
+    taskScheduler
+      .schedule({
+        id: randomUUID(),
+        rootChatId: 'chat1',
+        dirPath: 'dir1',
+        sessionId,
+        text: 'pending 1',
+        execute: async () => {
           await new Promise((r) => setTimeout(r, 100));
         },
-        { text: 'pending 1', sessionId: 'test-session' }
-      )
+      })
       .catch(() => {});
-    queue
-      .enqueue(
-        async () => {
+
+    taskScheduler
+      .schedule({
+        id: randomUUID(),
+        rootChatId: 'chat1',
+        dirPath: 'dir1',
+        sessionId,
+        text: 'pending 2',
+        execute: async () => {
           await new Promise((r) => setTimeout(r, 100));
         },
-        { text: 'pending 2', sessionId: 'test-session' }
-      )
+      })
       .catch(() => {});
 
     const state: RouterState = {
@@ -81,52 +108,42 @@ describe('Interruption flow in message handler', () => {
       messageId: 'mock-msg-id',
       chatId: 'chat1',
       action: 'interrupt',
-      sessionId: 'test-session',
+      sessionId,
     };
 
-    const runCommand = vi.fn().mockResolvedValue({ stdout: 'done', stderr: '', exitCode: 0 });
-
-    await executeDirectMessage(
-      'chat1',
-      state,
-      undefined,
-      '/test-interrupt-batch',
-      runCommand,
-      true
-    );
+    vi.mocked(runCommand).mockResolvedValue({ stdout: 'done', stderr: '', exitCode: 0 });
 
-    expect(abortSpy).toHaveBeenCalled();
+    await executeDirectMessage('chat1', state, undefined, '/test-interrupt-batch', true);
 
-    // Should have concatenated the pending tasks with the new message
-    // and enqueued it.
+    expect(interruptSpy).toHaveBeenCalledWith(sessionId);
 
-    // In our executeDirectMessage, the state.message gets mutated.
-    // However, it's easier to verify what was enqueued by extracting pending again,
-    // or by checking state.message.
-    expect(state.message).toBe(
+    // Verify that the new task enqueued contains the merged payload
+    const queueKey = `chat1:${sessionId}`;
+    const queueItems = taskScheduler['queues'].get(queueKey)?.['queue'] || [];
+    const newlyEnqueued = queueItems.find((t) => t.task.sessionId === sessionId);
+    expect(newlyEnqueued).toBeDefined();
+    expect(newlyEnqueued?.task.text).toBe(
       '<message>\npending 1\n</message>\n\n<message>\npending 2\n</message>\n\n<message>\nnew urgent task\n</message>'
     );
   });
 
   it('returns early when message is empty and no action is specified', async () => {
-    const queue = getMessageQueue('/test-interrupt-empty');
+    const sessionId = 'test-interrupt-empty';
+    taskScheduler.abortTasks(sessionId);
+
     const state: RouterState = {
       message: '   ',
       messageId: 'mock-msg-id',
       chatId: 'chat1',
+      sessionId,
     };
 
-    const runCommand = vi.fn();
-    await executeDirectMessage(
-      'chat1',
-      state,
-      undefined,
-      '/test-interrupt-empty',
-      runCommand,
-      true
-    );
+    vi.mocked(runCommand).mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
+    await executeDirectMessage('chat1', state, undefined, '/test-interrupt-empty', true);
 
     expect(runCommand).not.toHaveBeenCalled();
-    expect(queue['pending'].length).toBe(0);
+    const queueKey = `chat1:${sessionId}`;
+    const queuedForSession = taskScheduler['queues'].get(queueKey)?.['queue'] || [];
+    expect(queuedForSession.length).toBe(0);
   });
 });