clawmini 0.0.7 → 0.0.9

package/src/daemon/api/index.test.ts

@@ -171,6 +171,7 @@ describe('Daemon TRPC Router', () => {
         undefined,
         false,
         undefined,
+        undefined,
         undefined
       );
       expect((fs as any).default.mkdir).not.toHaveBeenCalled();

package/src/daemon/api/policy-request.test.ts

@@ -11,7 +11,9 @@ vi.mock('../../shared/chats.js', () => ({
 vi.mock('../../shared/workspace.js', () => ({
   getWorkspaceRoot: vi.fn().mockReturnValue('/mock/workspace'),
   getClawminiDir: vi.fn().mockReturnValue('/mock/.clawmini'),
-  readPolicies: vi.fn().mockResolvedValue({
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+  readPoliciesForPath: vi.fn().mockResolvedValue({
     policies: {
       'test-cmd': {
         command: 'echo',
@@ -30,7 +32,7 @@ vi.mock('../policy-request-service.js', () => {
     PolicyRequestService: class {
       async createRequest() {
         return {
-          id: 'req-123',
+          id: 'REQ-123',
           commandName: 'test-cmd',
           args: ['arg1', 'arg2'],
           fileMappings: {
@@ -101,7 +103,7 @@ describe('createPolicyRequest preview message', () => {
       },
     });
 
-    expect(result.id).toBe('req-123');
+    expect(result.id).toBe('REQ-123');
 
     expect(chats.appendMessage).toHaveBeenCalledTimes(1);
     const callArgs = vi.mocked(chats.appendMessage).mock.calls[0]!;
@@ -114,14 +116,14 @@ describe('createPolicyRequest preview message', () => {
     // Assert preview content format
     const content = logMsg.content;
     expect(content).toContain('Sandbox Policy Request: test-cmd');
-    expect(content).toContain('ID: req-123');
+    expect(content).toContain('ID: REQ-123');
     expect(content).toContain('Args: arg1 arg2');
 
     expect(content).toContain('File [file1]:\n' + shortContent);
 
     // The long file should be truncated to 500 chars + suffix
     expect(content).toContain('File [file2]:\n' + 'A'.repeat(500) + '\n... (truncated)');
-    expect(content).toContain('Use /approve req-123 or /reject req-123 [reason]');
+    expect(content).toContain('Use /approve REQ-123 or /reject REQ-123 [reason]');
   });
 
   it('should create an auto-approved request and execute it immediately', async () => {

package/src/daemon/api/router-utils.ts

@@ -8,7 +8,7 @@ import {
   readChatSettings,
   writeChatSettings,
 } from '../../shared/workspace.js';
-import { cronManager } from '../cron.js';
+import { cronManager, normalizeJob } from '../cron.js';
 import type { z } from 'zod';
 import type { CronJobSchema } from '../../shared/config.js';
 
@@ -129,17 +129,18 @@ export async function listCronJobsShared(chatId: string) {
 }
 
 export async function addCronJobShared(chatId: string, job: z.infer<typeof CronJobSchema>) {
+  const normalized = normalizeJob(job);
   const settings = (await readChatSettings(chatId)) || {};
   const cronJobs = settings.jobs ?? [];
-  const existingIndex = cronJobs.findIndex((j) => j.id === job.id);
+  const existingIndex = cronJobs.findIndex((j) => j.id === normalized.id);
   if (existingIndex >= 0) {
-    cronJobs[existingIndex] = job;
+    cronJobs[existingIndex] = normalized;
   } else {
-    cronJobs.push(job);
+    cronJobs.push(normalized);
   }
   settings.jobs = cronJobs;
   await writeChatSettings(chatId, settings);
-  cronManager.scheduleJob(chatId, job);
+  cronManager.scheduleJob(chatId, normalized);
   return { success: true };
 }
 

package/src/daemon/api/subagent-router.ts

@@ -8,10 +8,24 @@ import { on } from 'node:events';
 import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED } from '../events.js';
 import { createAgentSession } from '../agent/agent-session.js';
 import { executeSubagent, getSubagentDepth } from './subagent-utils.js';
-import type { SubagentTracker } from '../../shared/config.js';
+import { incrementSubagent, decrementSubagent } from '../agent/turn-registry.js';
+import type { ChatSettings, SubagentTracker } from '../../shared/config.js';
 
 const MAX_SUBAGENT_DEPTH = 2;
 
+function assertSubagentAccess(
+  settings: ChatSettings | null | undefined,
+  subagentId: string,
+  callerSubagentId: string | undefined
+): SubagentTracker {
+  const sub = settings?.subagents?.[subagentId];
+  if (!sub) throw new TRPCError({ code: 'NOT_FOUND', message: 'Subagent not found' });
+  if (sub.parentId !== callerSubagentId) {
+    throw new TRPCError({ code: 'FORBIDDEN', message: 'Subagent is not a child of the caller' });
+  }
+  return sub;
+}
+
 export const subagentSpawn = apiProcedure
   .input(
     z.object({
@@ -26,54 +40,65 @@ export const subagentSpawn = apiProcedure
     const chatId = ctx.tokenPayload.chatId;
     const parentAgentId = ctx.tokenPayload.agentId;
     const parentId = ctx.tokenPayload.subagentId;
+    const parentTurnId = ctx.tokenPayload.turnId;
 
     const id = input.subagentId || randomUUID();
     const sessionId = randomUUID();
     const agentId = input.targetAgentId || parentAgentId;
     let depth = 0;
 
-    await updateChatSettings(chatId, (settings) => {
-      settings.subagents = settings.subagents || {};
+    // Increment synchronously before any await so a sibling subagent's
+    // completion cannot decrement the parent's counter to zero (firing
+    // turnEnded) during the window before executeSubagent is called.
+    incrementSubagent(parentTurnId);
+    let handedOff = false;
+    try {
+      await updateChatSettings(chatId, (settings) => {
+        settings.subagents = settings.subagents || {};
 
-      depth = getSubagentDepth(settings, parentId);
-      if (depth >= MAX_SUBAGENT_DEPTH) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Max subagent depth reached' });
-      }
+        depth = getSubagentDepth(settings, parentId);
+        if (depth >= MAX_SUBAGENT_DEPTH) {
+          throw new TRPCError({ code: 'BAD_REQUEST', message: 'Max subagent depth reached' });
+        }
 
-      // Make sure the id does not already exist
-      if (settings.subagents[id]) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Subagent ID already exists' });
-      }
+        // Make sure the id does not already exist
+        if (settings.subagents[id]) {
+          throw new TRPCError({ code: 'BAD_REQUEST', message: 'Subagent ID already exists' });
+        }
 
-      settings.subagents[id] = {
-        id,
-        agentId,
-        sessionId,
-        createdAt: new Date().toISOString(),
-        status: 'active',
-        parentId,
-      };
+        settings.subagents[id] = {
+          id,
+          agentId,
+          sessionId,
+          createdAt: new Date().toISOString(),
+          status: 'active',
+          parentId,
+        };
 
-      return settings;
-    });
+        return settings;
+      });
 
-    const workspaceRoot = getWorkspaceRoot(process.cwd());
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
 
-    const isAsync = input.async ?? depth === 0;
+      const isAsync = input.async ?? depth === 0;
 
-    // Execute asynchronously
-    executeSubagent(
-      chatId,
-      id,
-      agentId,
-      sessionId,
-      input.prompt,
-      isAsync,
-      ctx.tokenPayload,
-      workspaceRoot
-    );
+      // Execute asynchronously — executeSubagent's finally decrements.
+      handedOff = true;
+      executeSubagent(
+        chatId,
+        id,
+        agentId,
+        sessionId,
+        input.prompt,
+        isAsync,
+        ctx.tokenPayload,
+        workspaceRoot
+      );
 
-    return { id, depth, isAsync };
+      return { id, depth, isAsync };
+    } finally {
+      if (!handedOff) decrementSubagent(parentTurnId);
+    }
   });
 
 export const subagentSend = apiProcedure
@@ -87,40 +112,46 @@ export const subagentSend = apiProcedure
   .mutation(async ({ input, ctx }) => {
     if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
     const chatId = ctx.tokenPayload.chatId;
+    const parentTurnId = ctx.tokenPayload.turnId;
 
     let sub: SubagentTracker | undefined;
 
-    await updateChatSettings(chatId, (settings) => {
-      if (!settings.subagents?.[input.subagentId]) {
-        throw new TRPCError({ code: 'NOT_FOUND', message: 'Subagent not found' });
-      }
-
-      sub = settings.subagents[input.subagentId];
-      sub!.status = 'active';
-      return settings;
-    });
-
-    const workspaceRoot = getWorkspaceRoot(process.cwd());
+    incrementSubagent(parentTurnId);
+    let handedOff = false;
+    try {
+      await updateChatSettings(chatId, (settings) => {
+        sub = assertSubagentAccess(settings, input.subagentId, ctx.tokenPayload!.subagentId);
+        sub.status = 'active';
+        return settings;
+      });
 
-    // Execute asynchronously
-    executeSubagent(
-      chatId,
-      sub!.id,
-      sub!.agentId || 'default',
-      sub!.sessionId || 'default',
-      input.prompt,
-      input.async,
-      ctx.tokenPayload,
-      workspaceRoot
-    );
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
 
-    return { success: true };
+      handedOff = true;
+      executeSubagent(
+        chatId,
+        sub!.id,
+        sub!.agentId || 'default',
+        sub!.sessionId || 'default',
+        input.prompt,
+        input.async,
+        ctx.tokenPayload,
+        workspaceRoot
+      );
+
+      return { success: true };
+    } finally {
+      if (!handedOff) decrementSubagent(parentTurnId);
+    }
   });
 
-async function checkSubagentStatus(chatId: string, subagentId: string) {
+async function checkSubagentStatus(
+  chatId: string,
+  subagentId: string,
+  callerSubagentId: string | undefined
+) {
   const settings = await readChatSettings(chatId);
-  const sub = settings?.subagents?.[subagentId];
-  if (!sub) throw new TRPCError({ code: 'NOT_FOUND', message: 'Subagent not found' });
+  const sub = assertSubagentAccess(settings, subagentId, callerSubagentId);
 
   if (sub.status === 'completed' || sub.status === 'failed') {
     let outputContent: string | undefined;
@@ -160,7 +191,11 @@ export const subagentWait = apiProcedure
 
     try {
       // Check status immediately before listening, but after event iterator is buffering
-      const initialStatus = await checkSubagentStatus(chatId, input.subagentId);
+      const initialStatus = await checkSubagentStatus(
+        chatId,
+        input.subagentId,
+        ctx.tokenPayload.subagentId
+      );
       if (initialStatus) {
         clearTimeout(timeout);
         if (signal) signal.removeEventListener('abort', onAbort);
@@ -171,7 +206,11 @@ export const subagentWait = apiProcedure
         if (event.chatId === chatId && event.message?.subagentId === input.subagentId) {
           const msg = event.message;
           if (msg.role === 'subagent_status') {
-            const status = await checkSubagentStatus(chatId, input.subagentId);
+            const status = await checkSubagentStatus(
+              chatId,
+              input.subagentId,
+              ctx.tokenPayload.subagentId
+            );
             if (status) {
               clearTimeout(timeout);
               if (signal) signal.removeEventListener('abort', onAbort);
@@ -203,13 +242,9 @@ export const subagentStop = apiProcedure
     let subToStop: SubagentTracker | undefined;
 
     await updateChatSettings(chatId, (settings) => {
-      if (settings.subagents) {
-        const sub = settings.subagents[input.subagentId];
-        if (sub) {
-          sub.status = 'failed';
-          subToStop = sub;
-        }
-      }
+      const sub = assertSubagentAccess(settings, input.subagentId, ctx.tokenPayload!.subagentId);
+      sub.status = 'failed';
+      subToStop = sub;
       return settings;
     });
 
@@ -236,10 +271,8 @@ export const subagentDelete = apiProcedure
     let subToDelete: SubagentTracker | undefined;
 
     await updateChatSettings(chatId, (settings) => {
-      if (settings.subagents && settings.subagents[input.subagentId]) {
-        subToDelete = settings.subagents[input.subagentId]!;
-        delete settings.subagents[input.subagentId];
-      }
+      subToDelete = assertSubagentAccess(settings, input.subagentId, ctx.tokenPayload!.subagentId);
+      delete settings.subagents![input.subagentId];
       return settings;
     });
 
@@ -289,6 +322,9 @@ export const subagentTail = apiProcedure
     if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
     const chatId = ctx.tokenPayload.chatId;
 
+    const settings = await readChatSettings(chatId);
+    assertSubagentAccess(settings, input.subagentId, ctx.tokenPayload.subagentId);
+
     const logger = createChatLogger(chatId, input.subagentId);
     const messages = await logger.getMessages(input.limit);
 

package/src/daemon/api/subagent-utils.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { executeSubagent } from './subagent-utils.js';
 import * as workspace from '../../shared/workspace.js';
 import { taskScheduler } from '../agent/task-scheduler.js';
+import * as turnRegistry from '../agent/turn-registry.js';
 
 vi.mock('../../shared/workspace.js', () => ({
   updateChatSettings: vi.fn(),
@@ -22,6 +23,7 @@ vi.mock('../agent/chat-logger.js', () => ({
   createChatLogger: vi.fn(() => ({
     findLastMessage: vi.fn().mockResolvedValue(null),
     logSystemEvent: vi.fn(),
+    logSubagentStatus: vi.fn(),
   })),
 }));
 
@@ -31,6 +33,11 @@ vi.mock('../agent/task-scheduler.js', () => ({
   },
 }));
 
+vi.mock('../agent/turn-registry.js', () => ({
+  incrementSubagent: vi.fn(),
+  decrementSubagent: vi.fn(),
+}));
+
 describe('executeSubagent', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -53,4 +60,57 @@ describe('executeSubagent', () => {
     // Should NOT call updateChatSettings to set status to completed
     expect(workspace.updateChatSettings).not.toHaveBeenCalled();
   });
+
+  it('should not increment the parent turn counter — that is the caller-s responsibility', async () => {
+    vi.mocked(taskScheduler.hasTasks).mockReturnValue(false);
+
+    await executeSubagent(
+      'chat-1',
+      'sub-1',
+      'agent-1',
+      'session-1',
+      'hello',
+      false,
+      { agentId: 'parent-agent', turnId: 'turn-1' },
+      '/workspace'
+    );
+
+    expect(turnRegistry.incrementSubagent).not.toHaveBeenCalled();
+  });
+
+  it('should decrement the parent turn counter exactly once on early return', async () => {
+    vi.mocked(taskScheduler.hasTasks).mockReturnValue(true);
+
+    await executeSubagent(
+      'chat-1',
+      'sub-1',
+      'agent-1',
+      'session-1',
+      'hello',
+      false,
+      { agentId: 'parent-agent', turnId: 'turn-1' },
+      '/workspace'
+    );
+
+    expect(turnRegistry.decrementSubagent).toHaveBeenCalledTimes(1);
+    expect(turnRegistry.decrementSubagent).toHaveBeenCalledWith('turn-1');
+  });
+
+  it('should decrement the parent turn counter exactly once on normal completion', async () => {
+    vi.mocked(taskScheduler.hasTasks).mockReturnValue(false);
+
+    await executeSubagent(
+      'chat-1',
+      'sub-1',
+      'agent-1',
+      'session-1',
+      'hello',
+      false,
+      { agentId: 'parent-agent', turnId: 'turn-1' },
+      '/workspace'
+    );
+
+    expect(turnRegistry.decrementSubagent).toHaveBeenCalledTimes(1);
+    expect(turnRegistry.decrementSubagent).toHaveBeenCalledWith('turn-1');
+  });
 });

package/src/daemon/api/subagent-utils.ts

@@ -6,6 +6,7 @@ import type { RouterState } from '../routers/types.js';
 import { createChatLogger } from '../agent/chat-logger.js';
 import type { ChatSettings } from '../../shared/config.js';
 import { taskScheduler } from '../agent/task-scheduler.js';
+import { decrementSubagent } from '../agent/turn-registry.js';
 
 export function getSubagentDepth(settings: ChatSettings, parentId: string | undefined): number {
   let depth = 0;
@@ -17,6 +18,13 @@ export function getSubagentDepth(settings: ChatSettings, parentId: string | unde
   return depth;
 }
 
+/**
+ * Executes a subagent. Callers MUST have already called `incrementSubagent`
+ * for the parent's turn synchronously before any `await` — this function's
+ * `finally` block decrements, and we need the caller to increment earlier
+ * so that a sibling's completing task cannot decrement the parent's counter
+ * to zero (firing `turnEnded`) before this call's task is enqueued.
+ */
 export async function executeSubagent(
   chatId: string,
   subagentId: string,
@@ -24,107 +32,125 @@ export async function executeSubagent(
   sessionId: string,
   prompt: string,
   isAsync: boolean | undefined,
-  parentTokenPayload: { agentId?: string; subagentId?: string; sessionId?: string },
+  parentTokenPayload: {
+    agentId?: string;
+    subagentId?: string;
+    sessionId?: string;
+    turnId?: string;
+  },
   workspaceRoot: string
 ) {
+  const parentTurnId = parentTokenPayload?.turnId;
   try {
-    const settings = (await readChatSettings(chatId)) || {};
-    const routers = settings.routers ?? [];
-    const resolvedRouters = resolveRouters(routers, false);
+    try {
+      const settings = (await readChatSettings(chatId)) || {};
+      const routers = settings.routers ?? [];
+      const resolvedRouters = resolveRouters(routers, false);
 
-    let routerState: RouterState = {
-      messageId: randomUUID(),
-      message: prompt,
-      chatId,
-      agentId,
-      sessionId,
-      env: {},
-    };
-
-    const initialState = { ...routerState };
-    routerState = await executeRouterPipeline(routerState, resolvedRouters);
+      let routerState: RouterState = {
+        messageId: randomUUID(),
+        message: prompt,
+        chatId,
+        agentId,
+        sessionId,
+        subagentId,
+        env: {},
+      };
 
-    await applyRouterStateUpdates(
-      chatId,
-      workspaceRoot,
-      routerState,
-      settings,
-      initialState.agentId
-    );
+      const initialState = { ...routerState };
+      routerState = await executeRouterPipeline(routerState, resolvedRouters);
 
-    await executeDirectMessage(
-      chatId,
-      routerState,
-      undefined, // settings
-      workspaceRoot,
-      false, // noWait
-      undefined, // userMessageContent
-      subagentId // subagentId
-    );
+      await applyRouterStateUpdates(
+        chatId,
+        workspaceRoot,
+        routerState,
+        settings,
+        initialState.agentId
+      );
 
-    if (taskScheduler.hasTasks(sessionId)) {
-      return;
-    }
+      await executeDirectMessage(
+        chatId,
+        routerState,
+        undefined, // settings
+        workspaceRoot,
+        false, // noWait
+        undefined, // userMessageContent
+        subagentId, // subagentId
+        undefined, // systemEvent
+        undefined, // displayRole
+        parentTurnId // parentTurnId — inherit from parent agent's turn
+      );
 
-    // Update status
-    await updateChatSettings(chatId, (finalSettings) => {
-      if (finalSettings.subagents?.[subagentId]) {
-        finalSettings.subagents[subagentId]!.status = 'completed';
+      if (taskScheduler.hasTasks(sessionId)) {
+        return;
       }
-      return finalSettings;
-    });
 
-    const logger = createChatLogger(chatId, subagentId);
+      // Update status
+      await updateChatSettings(chatId, (finalSettings) => {
+        if (finalSettings.subagents?.[subagentId]) {
+          finalSettings.subagents[subagentId]!.status = 'completed';
+        }
+        return finalSettings;
+      });
 
-    // Emit debug message to wake up waiters
-    await logger.logSubagentStatus({ subagentId, status: 'completed' });
+      const logger = createChatLogger(chatId, subagentId, sessionId, parentTurnId);
 
-    if (isAsync) {
-      const lastLogMessage = await logger.findLastMessage(
-        (m) => m.role === 'agent' || m.displayRole === 'agent'
-      );
-      let outputContent = '';
-      if (lastLogMessage && 'content' in lastLogMessage) {
-        outputContent = `\n\n<subagent_output>\n${lastLogMessage.content}\n</subagent_output>`;
-      }
+      // Emit debug message to wake up waiters
+      await logger.logSubagentStatus({ subagentId, status: 'completed' });
 
-      console.log(
-        'Notifying parent',
-        chatId,
-        parentTokenPayload?.agentId,
-        parentTokenPayload?.subagentId
-      );
-      // TODO: We need to overhaul the log system in general, and should not try to do it in this PR.
-      // Currently, if the parent is the root agent, this notification is logged as a normal user message
-      // and appears in the chat UI, violating the PRD requirement to hide orchestration.
-      await executeDirectMessage(
-        chatId,
-        {
-          messageId: randomUUID(),
-          message: `<notification>Subagent ${subagentId} completed.</notification>${outputContent}`,
+      if (isAsync) {
+        const lastLogMessage = await logger.findLastMessage(
+          (m) => m.role === 'agent' || m.displayRole === 'agent'
+        );
+        let outputContent = '';
+        if (lastLogMessage && 'content' in lastLogMessage) {
+          outputContent = `\n\n<subagent_output>\n${lastLogMessage.content}\n</subagent_output>`;
+        }
+
+        console.log(
+          'Notifying parent',
           chatId,
-          agentId: parentTokenPayload?.agentId || 'default',
-          ...(parentTokenPayload?.subagentId ? { subagentId: parentTokenPayload.subagentId } : {}),
-          sessionId: parentTokenPayload?.sessionId || 'default',
-          env: {},
-        },
-        undefined,
-        workspaceRoot,
-        true,
-        undefined,
-        parentTokenPayload?.subagentId,
-        'subagent_update'
-      );
-    }
-  } catch {
-    // TODO: Wrap this in a safe try-catch to prevent unhandled promise rejections crashing the daemon if disk errors occur
-    await updateChatSettings(chatId, (errSettings) => {
-      if (errSettings.subagents?.[subagentId]) {
-        errSettings.subagents[subagentId]!.status = 'failed';
+          parentTokenPayload?.agentId,
+          parentTokenPayload?.subagentId
+        );
+        // TODO: We need to overhaul the log system in general, and should not try to do it in this PR.
+        // Currently, if the parent is the root agent, this notification is logged as a normal user message
+        // and appears in the chat UI, violating the PRD requirement to hide orchestration.
+        await executeDirectMessage(
+          chatId,
+          {
+            messageId: randomUUID(),
+            message: `<notification>Subagent ${subagentId} completed.</notification>${outputContent}`,
+            chatId,
+            agentId: parentTokenPayload?.agentId || 'default',
+            ...(parentTokenPayload?.subagentId
+              ? { subagentId: parentTokenPayload.subagentId }
+              : {}),
+            sessionId: parentTokenPayload?.sessionId || 'default',
+            env: {},
+          },
+          undefined,
+          workspaceRoot,
+          true,
+          undefined,
+          parentTokenPayload?.subagentId,
+          'subagent_update',
+          undefined,
+          parentTurnId
+        );
       }
-      return errSettings;
-    });
-    const logger = createChatLogger(chatId, subagentId);
-    await logger.logSubagentStatus({ subagentId, status: 'failed' });
+    } catch {
+      // TODO: Wrap this in a safe try-catch to prevent unhandled promise rejections crashing the daemon if disk errors occur
+      await updateChatSettings(chatId, (errSettings) => {
+        if (errSettings.subagents?.[subagentId]) {
+          errSettings.subagents[subagentId]!.status = 'failed';
+        }
+        return errSettings;
+      });
+      const logger = createChatLogger(chatId, subagentId, sessionId, parentTurnId);
+      await logger.logSubagentStatus({ subagentId, status: 'failed' });
+    }
+  } finally {
+    decrementSubagent(parentTurnId);
   }
 }