clawmini 0.0.8 → 0.0.9

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

@@ -4,7 +4,13 @@ import path from 'node:path';
 import { TRPCError } from '@trpc/server';
 import { pathIsInsideDir } from '../../shared/utils/fs.js';
 import { on } from 'node:events';
-import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, DAEMON_EVENT_TYPING } from '../events.js';
+import {
+  daemonEvents,
+  DAEMON_EVENT_CHAT_STREAM,
+  DAEMON_EVENT_TYPING,
+  type ChatStreamEnvelope,
+  type ChatStreamItem,
+} from '../events.js';
 import {
   getSettingsPath,
   readChatSettings,
@@ -39,6 +45,7 @@ export const sendMessage = apiProcedure
         noWait: z.boolean().optional(),
         files: z.array(z.string()).optional(),
         adapter: z.string().optional(),
+        externalRef: z.string().optional(),
       }),
     })
   )
@@ -99,7 +106,16 @@ export const sendMessage = apiProcedure
       message = message ? `${message}\n\n${fileList}` : fileList;
     }
 
-    await handleUserMessage(chatId, message, settings, undefined, noWait, sessionId, agentId);
+    await handleUserMessage(
+      chatId,
+      message,
+      settings,
+      undefined,
+      noWait,
+      sessionId,
+      agentId,
+      input.data.externalRef
+    );
 
     return { success: true };
   });
@@ -111,6 +127,11 @@ export const getMessages = apiProcedure
     return fetchMessages(chatId, input.limit);
   });
 
+/**
+ * Interleaved chat stream: `ChatMessage` appends and turn lifecycle events
+ * arrive on a single subscription in emission order. Consumers that only
+ * care about messages can ignore items with `kind: 'turn'`.
+ */
 export const waitForMessages = apiProcedure
   .input(
     z.object({
@@ -121,20 +142,25 @@ export const waitForMessages = apiProcedure
   .subscription(async function* ({ input, signal }) {
     const chatId = input.chatId ?? (await getDefaultChatId());
 
-    // 1. Check if there are already new messages
+    // 1. Catch up on any messages missed since `lastMessageId`. Turn events
+    //    have no persisted backlog — they're live-only, like today.
     if (input.lastMessageId) {
       const messages = await fetchMessages(chatId);
       const lastIndex = messages.findIndex((m) => m.id === input.lastMessageId);
       if (lastIndex !== -1 && lastIndex < messages.length - 1) {
-        yield messages.slice(lastIndex + 1);
+        const items: ChatStreamItem[] = messages
+          .slice(lastIndex + 1)
+          .map((message) => ({ kind: 'message', message }));
+        yield items;
       }
     }
 
-    // 2. Listen for new messages
+    // 2. Live: messages and turn events on the same channel, in emission order.
     try {
-      for await (const [event] of on(daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, { signal })) {
-        if (event.chatId === chatId) {
-          yield [event.message];
+      for await (const [envelope] of on(daemonEvents, DAEMON_EVENT_CHAT_STREAM, { signal })) {
+        const e = envelope as ChatStreamEnvelope;
+        if (e.chatId === chatId) {
+          yield [e.item];
         }
       }
     } catch (err) {

package/src/daemon/auth.ts

@@ -10,6 +10,7 @@ export interface TokenPayload {
   agentId: string;
   sessionId: string;
   subagentId?: string;
+  turnId?: string;
   timestamp: number;
 }
 

package/src/daemon/cron.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { CronManager } from './cron.js';
+import { CronManager, normalizeJob } from './cron.js';
 // @ts-expect-error - node-schedule types are missing
 import schedule from 'node-schedule';
 import { getInitialRouterState } from './message.js';
@@ -49,18 +49,76 @@ describe('CronManager', () => {
     }).toThrow("Invalid date format for 'at' schedule: invalid-date");
   });
 
-  it('correctly schedules an interval "at" schedule', () => {
+  it('fires an overdue "at" job immediately instead of dropping it', () => {
+    const cronManager = new CronManager();
+    vi.mocked(schedule.scheduleJob as any).mockImplementation((rule: any, _cb: any) => {
+      return { cancel: vi.fn(), rule } as any;
+    });
+
+    const past = new Date(Date.now() - 60_000).toISOString();
+    cronManager.scheduleJob('chat-overdue', {
+      id: 'job-overdue',
+      createdAt: new Date().toISOString(),
+      message: 'hello',
+      schedule: { at: past },
+    });
+
+    expect(schedule.scheduleJob).toHaveBeenCalledTimes(1);
+    const [rule] = vi.mocked(schedule.scheduleJob as any).mock.calls[0]!;
+    expect(rule).toBeInstanceOf(Date);
+    expect((rule as Date).getTime()).toBeGreaterThan(Date.now() - 1_000);
+  });
+
+  it('correctly schedules an absolute "at" schedule', () => {
     const cronManager = new CronManager();
     expect(() => {
       cronManager.scheduleJob('chat2', {
         id: 'job2',
         createdAt: new Date().toISOString(),
         message: 'hello',
-        schedule: { at: '2m' },
+        schedule: { at: new Date(Date.now() + 120_000).toISOString() },
       });
     }).not.toThrow();
   });
 
+  it('normalizeJob resolves interval "at" to an absolute ISO timestamp', () => {
+    const before = Date.now();
+    const normalized = normalizeJob({
+      id: 'job-norm',
+      createdAt: new Date().toISOString(),
+      message: 'hi',
+      schedule: { at: '2s' },
+    });
+    const after = Date.now();
+    expect('at' in normalized.schedule).toBe(true);
+    const at = (normalized.schedule as { at: string }).at;
+    const ms = new Date(at).getTime();
+    expect(ms).toBeGreaterThanOrEqual(before + 2000);
+    expect(ms).toBeLessThanOrEqual(after + 2000);
+  });
+
+  it('normalizeJob preserves an already-absolute "at" value', () => {
+    const iso = new Date(Date.now() + 60_000).toISOString();
+    const normalized = normalizeJob({
+      id: 'job-abs',
+      createdAt: new Date().toISOString(),
+      message: 'hi',
+      schedule: { at: iso },
+    });
+    expect((normalized.schedule as { at: string }).at).toBe(iso);
+  });
+
+  it('normalizeJob throws on unparseable "at" value', () => {
+    expect(() =>
+      normalizeJob({
+        id: 'job-bad',
+        createdAt: new Date().toISOString(),
+        message: 'hi',
+        schedule: { at: 'not-a-date' },
+      })
+    ).toThrow("Invalid date format for 'at' schedule: not-a-date");
+  });
+
   it('passes job.session.id to getInitialRouterState when session type is existing', async () => {
     const cronManager = new CronManager();
     let scheduledCallback: any = null;
@@ -73,7 +131,7 @@ describe('CronManager', () => {
       id: 'job3',
       createdAt: new Date().toISOString(),
       message: 'test existing session',
-      schedule: { at: '1m' },
+      schedule: { at: new Date(Date.now() + 60_000).toISOString() },
       session: { type: 'existing', id: 'my-old-session-id' },
     });
 

package/src/daemon/cron.ts

@@ -9,6 +9,34 @@ import fs from 'node:fs/promises';
 import { getSettingsPath } from '../shared/workspace.js';
 import { applyEnvOverrides } from '../shared/utils/env.js';
 
+// Resolves relative `at` intervals (e.g. "2s", "5m") to absolute ISO timestamps
+// so a job's target time is stable across daemon restarts. Throws on unparseable
+// `at` values so invalid input is rejected at creation rather than silently
+// shifted by `scheduleJob`. `cron` and `every` schedules pass through unchanged.
+export function normalizeJob(job: CronJob): CronJob {
+  if (!('at' in job.schedule)) return job;
+
+  const atStr = job.schedule.at;
+  const match = atStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?|s|sec|seconds?)$/i);
+  let absolute: Date;
+  if (match) {
+    const val = parseInt(match[1]!, 10);
+    const unit = match[2]!.toLowerCase();
+    let ms = 0;
+    if (unit.startsWith('s')) ms = val * 1000;
+    else if (unit.startsWith('m')) ms = val * 60 * 1000;
+    else if (unit.startsWith('h')) ms = val * 60 * 60 * 1000;
+    else if (unit.startsWith('d')) ms = val * 24 * 60 * 60 * 1000;
+    absolute = new Date(Date.now() + ms);
+  } else {
+    absolute = new Date(atStr);
+    if (isNaN(absolute.getTime())) {
+      throw new Error(`Invalid date format for 'at' schedule: ${atStr}`);
+    }
+  }
+  return { ...job, schedule: { at: absolute.toISOString() } };
+}
+
 export class CronManager {
   private jobs = new Map<string, schedule.Job>();
 
@@ -62,22 +90,19 @@ export class CronManager {
         rule = everyStr;
       }
     } else if ('at' in job.schedule) {
-      const atStr = (job.schedule as { at: string }).at;
-      const match = atStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?|s|sec|seconds?)$/i);
-      if (match) {
-        const val = parseInt(match[1]!, 10);
-        const unit = match[2]!.toLowerCase();
-        let ms = 0;
-        if (unit.startsWith('s')) ms = val * 1000;
-        else if (unit.startsWith('m')) ms = val * 60 * 1000;
-        else if (unit.startsWith('h')) ms = val * 60 * 60 * 1000;
-        else if (unit.startsWith('d')) ms = val * 24 * 60 * 60 * 1000;
-        rule = new Date(Date.now() + ms);
-      } else {
-        rule = new Date(atStr);
-        if (isNaN(rule.getTime())) {
-          throw new Error(`Invalid date format for 'at' schedule: ${atStr}`);
-        }
+      const atStr = job.schedule.at;
+      rule = new Date(atStr);
+      if (isNaN(rule.getTime())) {
+        throw new Error(`Invalid date format for 'at' schedule: ${atStr}`);
+      }
+      // If the target time has already passed (e.g. daemon was down past it),
+      // node-schedule returns null and the job silently never fires. Push it
+      // just into the future so it executes on the next tick and cleans up.
+      if (rule.getTime() <= Date.now()) {
+        console.warn(
+          `One-off job ${job.id} for chat ${chatId} is overdue (target ${atStr}); firing immediately.`
+        );
+        rule = new Date(Date.now() + 100);
       }
       isOneOff = true;
     } else {
@@ -144,6 +169,7 @@ export class CronManager {
         routerState.nextSessionId = job.nextSessionId;
       if (job.action !== undefined) routerState.action = job.action;
       if (job.jobs !== undefined) routerState.jobs = job.jobs;
+      routerState.jobId = job.id;
 
       const routers = chatSettings.routers ?? globalSettings?.routers ?? [];
       const resolvedRouters = resolveRouters(routers, false);

package/src/daemon/events.ts

@@ -5,11 +5,76 @@ export const daemonEvents = new EventEmitter();
 
 export const DAEMON_EVENT_MESSAGE_APPENDED = 'message-appended';
 export const DAEMON_EVENT_TYPING = 'typing';
+export const DAEMON_EVENT_TURN_STARTED = 'turn-started';
+export const DAEMON_EVENT_TURN_ENDED = 'turn-ended';
+/**
+ * Unified event carrying both `ChatMessage` appends and turn lifecycle
+ * events so a single `waitForMessages` subscription can interleave them
+ * in emission order (no merge logic or messageQueue on the consumer side).
+ */
+export const DAEMON_EVENT_CHAT_STREAM = 'chat-stream';
+
+export interface TurnStartedEvent {
+  chatId: string;
+  turnId: string;
+  rootMessageId: string;
+  externalRef?: string;
+}
+
+export interface TurnEndedEvent {
+  chatId: string;
+  turnId: string;
+  outcome: 'ok' | 'error';
+}
+
+export type TurnLifecycleEvent =
+  | { type: 'started'; turnId: string; rootMessageId: string; externalRef?: string }
+  | { type: 'ended'; turnId: string; outcome: 'ok' | 'error' };
+
+export type ChatStreamItem =
+  | { kind: 'message'; message: ChatMessage }
+  | { kind: 'turn'; event: TurnLifecycleEvent };
+
+export interface ChatStreamEnvelope {
+  chatId: string;
+  item: ChatStreamItem;
+}
 
 export function emitMessageAppended(chatId: string, message: ChatMessage) {
   daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, { chatId, message });
+  const envelope: ChatStreamEnvelope = { chatId, item: { kind: 'message', message } };
+  daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
 }
 
 export function emitTyping(chatId: string) {
   daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId });
 }
+
+export function emitTurnStarted(event: TurnStartedEvent) {
+  daemonEvents.emit(DAEMON_EVENT_TURN_STARTED, event);
+  const lifecycle: TurnLifecycleEvent = {
+    type: 'started',
+    turnId: event.turnId,
+    rootMessageId: event.rootMessageId,
+    ...(event.externalRef ? { externalRef: event.externalRef } : {}),
+  };
+  const envelope: ChatStreamEnvelope = {
+    chatId: event.chatId,
+    item: { kind: 'turn', event: lifecycle },
+  };
+  daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
+}
+
+export function emitTurnEnded(event: TurnEndedEvent) {
+  daemonEvents.emit(DAEMON_EVENT_TURN_ENDED, event);
+  const lifecycle: TurnLifecycleEvent = {
+    type: 'ended',
+    turnId: event.turnId,
+    outcome: event.outcome,
+  };
+  const envelope: ChatStreamEnvelope = {
+    chatId: event.chatId,
+    item: { kind: 'turn', event: lifecycle },
+  };
+  daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
+}

package/src/daemon/index.ts

@@ -20,6 +20,9 @@ import { SettingsSchema } from '../shared/config.js';
 import { validateToken, getApiContext } from './auth.js';
 import path from 'node:path';
 import { exportLiteToEnvironment } from '../shared/lite.js';
+import { RequestStore } from './request-store.js';
+import { drainPendingReplies } from './pending-replies.js';
+import { getClawminiVersion } from '../shared/version.js';
 
 export async function initDaemon() {
   const socketPath = getSocketPath();
@@ -66,11 +69,13 @@ export async function initDaemon() {
           const command = envConfig?.[hookType];
           if (command) {
             console.log(`Executing '${hookType}' hook for environment '${envName}': ${command}`);
+            // No timeout: a SIGTERM mid-hook risks partial teardown (e.g.
+            // containers left running). The supervisor's per-service SIGKILL
+            // timer is the ultimate backstop for runaway hooks.
             execSync(command, {
               cwd: affectedDir,
               stdio: 'inherit',
               env: { ...process.env, ENV_DIR: envDir },
-              timeout: hookType === 'down' ? 10000 : undefined,
             });
           }
         } catch (err) {
@@ -163,11 +168,29 @@ export async function initDaemon() {
   };
   await cleanOrphanedSubagents();
 
+  try {
+    const removed = await new RequestStore(getWorkspaceRoot()).cleanupCompleted();
+    if (removed > 0) {
+      console.log(`Cleaned up ${removed} completed policy request file(s).`);
+    }
+  } catch (err) {
+    console.warn('Failed to clean completed policy requests:', err);
+  }
+
   await runHooks('up');
 
   isReady = true;
   readyPromiseResolve!();
 
+  // Drain any replies queued by the previous daemon instance (e.g. /restart
+  // or /upgrade). This must run after the daemon is `isReady` so the tRPC
+  // subscription that the adapter forwarder reconnects to can deliver them.
+  try {
+    await drainPendingReplies(getClawminiVersion());
+  } catch (err) {
+    console.warn('Failed to drain pending replies:', err);
+  }
+
   // Initialize cron jobs
   cronManager.init().catch((err) => {
     console.error('Failed to initialize cron manager:', err);

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

@@ -19,6 +19,7 @@ vi.mock('../shared/workspace.js', () => ({
 
   readChatSettings: vi.fn().mockResolvedValue(null),
   writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  updateChatSettings: vi.fn().mockResolvedValue(undefined),
   readAgentSessionSettings: vi.fn().mockResolvedValue(null),
   writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
   getAgent: vi.fn().mockResolvedValue(null),

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

@@ -36,6 +36,7 @@ vi.mock('./cron.js', () => ({
     scheduleJob: vi.fn(),
     unscheduleJob: vi.fn(),
   },
+  normalizeJob: (job: unknown) => job,
 }));
 
 describe('Jobs and Session Handling in handleUserMessage', () => {

package/src/daemon/message.ts

@@ -1,11 +1,15 @@
+import { randomUUID } from 'node:crypto';
 import { executeRouterPipeline, resolveRouters } from './routers.js';
 import type { RouterState } from './routers/types.js';
 import { type ChatSettings, type Settings } from '../shared/config.js';
-import { readChatSettings, writeChatSettings } from '../shared/workspace.js';
-import { cronManager } from './cron.js';
+import { readChatSettings, updateChatSettings, writeChatSettings } from '../shared/workspace.js';
+import { cronManager, normalizeJob } from './cron.js';
 import type { Message } from './agent/types.js';
 import { createAgentSession } from './agent/agent-session.js';
 import { createChatLogger } from './agent/chat-logger.js';
+import { taskScheduler } from './agent/task-scheduler.js';
+import { emitTurnStarted } from './events.js';
+import { registerTurn, markParentExited } from './agent/turn-registry.js';
 
 export { calculateDelay } from './agent/agent-runner.js';
 
@@ -24,9 +28,12 @@ export async function executeDirectMessage(
     | 'subagent_update'
     | 'router'
     | 'other',
-  displayRole?: 'user' | 'agent'
+  displayRole?: 'user' | 'agent',
+  parentTurnId?: string
 ) {
-  const logger = createChatLogger(chatId, subagentId);
+  const turnId = parentTurnId ?? randomUUID();
+  const emitLifecycle = !parentTurnId;
+  const logger = createChatLogger(chatId, subagentId, state.sessionId, turnId);
 
   let msgId: string;
   if (systemEvent) {
@@ -35,6 +42,7 @@ export async function executeDirectMessage(
       event: systemEvent,
       messageId: state.messageId,
       ...(displayRole ? { displayRole } : {}),
+      ...(state.jobId ? { jobId: state.jobId } : {}),
     });
     msgId = sysMsg.id;
   } else {
@@ -59,36 +67,57 @@ export async function executeDirectMessage(
     cwd,
     settings,
     logger,
+    turnId,
   });
   let finalMessage: Message = {
     id: state.messageId,
     content: state.message,
     env: state.env ?? {},
+    turnId,
   };
 
   // Process actions
   if (state.action === 'stop') {
     agentSession.stop();
+    if (!subagentId) {
+      await stopActiveSubagents(chatId, cwd);
+    }
     return;
   }
   if (state.action === 'interrupt') {
     finalMessage = agentSession.interrupt(finalMessage);
   }
 
+  if (emitLifecycle) {
+    registerTurn(chatId, turnId);
+    emitTurnStarted({
+      chatId,
+      turnId,
+      rootMessageId: msgId,
+      ...(state.externalRef ? { externalRef: state.externalRef } : {}),
+    });
+  }
+
   // Process message
   const taskPromise = agentSession.handleMessage(finalMessage);
 
-  if (!noWait) {
+  const settleTurn = async () => {
     try {
       await taskPromise;
+      if (emitLifecycle) markParentExited(turnId, 'ok');
     } catch (err) {
+      if (emitLifecycle) markParentExited(turnId, 'error');
       if (!(err instanceof Error && err.name === 'AbortError')) {
         throw err;
       }
     }
+  };
+
+  if (!noWait) {
+    await settleTurn();
   } else {
-    taskPromise.catch((err) => {
-      if (err.name !== 'AbortError') {
+    settleTurn().catch((err) => {
+      if (err?.name !== 'AbortError') {
         console.error('Task execution error:', err);
       }
     });
@@ -100,7 +129,8 @@ export async function getInitialRouterState(
   message: string,
   chatSettings: Partial<ChatSettings>,
   overrideAgentId?: string,
-  overrideSessionId?: string
+  overrideSessionId?: string,
+  externalRef?: string
 ): Promise<RouterState> {
   const agentId = overrideAgentId ?? chatSettings.defaultAgent ?? 'default';
   const sessionId = overrideSessionId ?? chatSettings.sessions?.[agentId] ?? 'default';
@@ -113,6 +143,7 @@ export async function getInitialRouterState(
     agentId,
     sessionId,
     env: {},
+    ...(externalRef ? { externalRef } : {}),
   };
 }
 
@@ -123,7 +154,8 @@ export async function handleUserMessage(
   cwd: string = process.cwd(),
   noWait: boolean = false,
   sessionId?: string,
-  overrideAgentId?: string
+  overrideAgentId?: string,
+  externalRef?: string
 ): Promise<void> {
   const chatSettings = (await readChatSettings(chatId, cwd)) ?? {};
 
@@ -137,7 +169,8 @@ export async function handleUserMessage(
     message,
     chatSettings,
     overrideAgentId,
-    sessionId
+    sessionId,
+    externalRef
   );
 
   const routers = chatSettings.routers ?? settings?.routers ?? [];
@@ -146,7 +179,15 @@ export async function handleUserMessage(
 
   await applyRouterStateUpdates(chatId, cwd, finalState, chatSettings, initialState.agentId);
 
-  await executeDirectMessage(chatId, finalState, settings, cwd, noWait, message);
+  await executeDirectMessage(
+    chatId,
+    finalState,
+    settings,
+    cwd,
+    noWait,
+    message,
+    finalState.subagentId
+  );
 }
 
 export async function applyRouterStateUpdates(
@@ -185,12 +226,13 @@ export async function applyRouterStateUpdates(
     }
 
     if (finalState.jobs.add?.length) {
-      const addMap = new Map(finalState.jobs.add.map((job) => [job.id, job]));
-      for (const job of finalState.jobs.add) {
+      const normalized = finalState.jobs.add.map(normalizeJob);
+      const addMap = new Map(normalized.map((job) => [job.id, job]));
+      for (const job of normalized) {
         cronManager.scheduleJob(chatId, job);
       }
       chatSettings.jobs = chatSettings.jobs.filter((job) => !addMap.has(job.id));
-      chatSettings.jobs.push(...finalState.jobs.add);
+      chatSettings.jobs.push(...normalized);
       settingsChanged = true;
     }
   }
@@ -207,3 +249,25 @@ export async function applyRouterStateUpdates(
     finalState.agentId = currentAgentId;
   }
 }
+
+async function stopActiveSubagents(chatId: string, cwd: string): Promise<void> {
+  const sessionsToAbort: string[] = [];
+  await updateChatSettings(
+    chatId,
+    (settings) => {
+      if (settings.subagents) {
+        for (const sub of Object.values(settings.subagents)) {
+          if (sub.status === 'active') {
+            if (sub.sessionId) sessionsToAbort.push(sub.sessionId);
+            sub.status = 'failed';
+          }
+        }
+      }
+      return settings;
+    },
+    cwd
+  );
+  for (const sessionId of sessionsToAbort) {
+    taskScheduler.abortTasks(sessionId);
+  }
+}