@controlflow-ai/daemon 0.1.3 → 0.1.5

package/bin/daemon.js

@@ -1,2 +1,7 @@
 #!/usr/bin/env bun
-import '../src/daemon.ts';
+import { main } from '../src/daemon.ts';
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@controlflow-ai/daemon",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "scripts": {
     "server": "bun run src/server.ts",

package/src/agent-runtime.ts

@@ -157,6 +157,19 @@ function formatMessageAttachmentSummary(message: Message): string {
   return ` [attachments: ${items.join('; ')}]`;
 }
 
+function formatMergedDeliveredContent(context: DeliveryContext | undefined, currentMessage: Message): string {
+  if (!context || context.messages.length === 0) return sanitizeProviderIds(currentMessage.content);
+  const lines = context.messages.map((message) => {
+    const marker = message.id === currentMessage.id ? ' current' : '';
+    const parent = message.parent_id === null ? '' : ` parent=${message.parent_id}`;
+    const recipient = message.recipient ? ` to=@${sanitizeProviderIds(message.recipient)}` : '';
+    const sender = sanitizeProviderIds(message.sender);
+    const content = sanitizeProviderIds(message.content).trim();
+    return `[${message.id}${marker}] @${sender}${recipient}${parent}:\n${content}`;
+  });
+  return `Merged delivered message content:\n${lines.join('\n\n')}`;
+}
+
 function formatSavedRoomContext(savedMessages: RoomSavedMessage[] | undefined): string {
   if (!savedMessages || savedMessages.length === 0) return '';
   const lines = savedMessages.slice(0, 10).map((saved) => {
@@ -228,7 +241,8 @@ export function buildPalPrompt(input: AgentRuntimeRunInput): string {
   const chatName = sanitizeProviderIds(input.message.chat_name);
   const chatRef = input.message.chat_id;
   const sender = sanitizeProviderIds(input.message.sender);
-  const content = sanitizeProviderIds(input.message.content);
+  const currentContent = sanitizeProviderIds(input.message.content);
+  const content = formatMergedDeliveredContent(input.deliveryContext, input.message);
   const freshnessFlags = `--base-message-id ${input.message.id} --hold-if-stale`;
   const projectContext = input.projectContext
     ? input.projectContext.accessible
@@ -270,7 +284,7 @@ ${formatRoomModeAndSkillContext({ roomMode: input.roomMode, enabledSkills: input
 ${messageContext}
 ${savedRoomContext}
 ${runtimeAttachments}
-${formatAllMentionOnlyHandoff(content, messageContextLabel)}
+${formatAllMentionOnlyHandoff(currentContent, messageContextLabel)}
 Content:
 ${content}
 

package/src/app.ts

@@ -133,7 +133,7 @@ interface AgentRoomSubscriptionBody {
   mode?: AgentRoomSubscriptionMode;
 }
 
-const agentRoomSubscriptionModes: AgentRoomSubscriptionMode[] = ['all', 'periodic', 'mentions', 'muted', 'off'];
+const agentRoomSubscriptionModes: AgentRoomSubscriptionMode[] = ['all', 'available', 'periodic', 'mentions', 'muted', 'off'];
 const agentActivityKinds: AgentActivityKind[] = ['lifecycle', 'working', 'thinking', 'output', 'tool', 'error'];
 const roomTaskStatuses: RoomTaskStatus[] = ['todo', 'in_progress', 'in_review', 'done', 'closed'];
 const roomReminderStatuses: RoomReminderStatus[] = ['scheduled', 'fired', 'canceled'];
@@ -144,7 +144,7 @@ const workflowRunStatuses: WorkflowRunStatus[] = ['running', 'completed', 'faile
 
 function parseAgentRoomSubscriptionMode(value: unknown): AgentRoomSubscriptionMode {
   if (typeof value !== 'string' || !agentRoomSubscriptionModes.includes(value as AgentRoomSubscriptionMode)) {
-    throw new HttpError(400, 'INVALID_SUBSCRIPTION_MODE', 'mode must be all, periodic, mentions, muted, or off');
+    throw new HttpError(400, 'INVALID_SUBSCRIPTION_MODE', 'mode must be all, available, periodic, mentions, muted, or off');
   }
   return value as AgentRoomSubscriptionMode;
 }
@@ -2162,6 +2162,33 @@ export function route(store: MessageStore, request: Request, options: AppRouteOp
     }
   }
 
+  const roomAgentInterruptMatch = pathname.match(/^\/api\/rooms\/([^/]+)\/agents\/([^/]+)\/interrupt$/);
+  if (request.method === 'POST' && roomAgentInterruptMatch) {
+    const room = store.resolveRoom(decodeURIComponent(roomAgentInterruptMatch[1]!));
+    if (!room) throw new HttpError(404, 'ROOM_NOT_FOUND', 'room not found');
+    const agent = decodeURIComponent(roomAgentInterruptMatch[2]!);
+    if (!store.getAgent(agent)) throw new HttpError(404, 'AGENT_NOT_FOUND', 'agent not found');
+    try {
+      const run = store.requestRoomAgentRunAction({ roomId: room.id, agent, action: 'interrupt' });
+      const pendingBacklogCount = store.countPendingDeliveriesAfterMessage({
+        roomId: room.id,
+        agent,
+        afterMessageId: run.trigger_message_id ?? run.message_id,
+      });
+      return json({
+        run,
+        pending_backlog_count: pendingBacklogCount,
+        message: `Stop requested for @${agent} current processing. Pending messages were not cleared. Already completed file changes, commands, and external side effects are not rolled back.`,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes('running run for agent') && message.includes('was not found')) {
+        throw new HttpError(404, 'RUN_NOT_FOUND', 'no running runtime for this agent in this room');
+      }
+      throw error;
+    }
+  }
+
   const roomAgentSubscriptionMatch = pathname.match(/^\/api\/rooms\/([^/]+)\/agents\/([^/]+)\/subscription$/);
   if (request.method === 'PATCH' && roomAgentSubscriptionMatch) {
     return readJson<AgentRoomSubscriptionBody>(request).then((body) => {
@@ -2653,6 +2680,23 @@ export function route(store: MessageStore, request: Request, options: AppRouteOp
     });
   }
 
+  const deliveryCancelMatch = pathname.match(/^\/api\/deliveries\/([^/]+)\/cancel$/);
+  if (request.method === 'POST' && deliveryCancelMatch) {
+    return readJson<FinishDeliveryBody>(request).then((body) => {
+      const connection = requireDaemonConnection(store, request);
+      const ownerId = connection?.connectionId ?? body.connection_id ?? body.daemon_id;
+      if (!ownerId?.trim()) throw new HttpError(400, 'MISSING_DAEMON_ID', 'daemon_id or connection auth is required');
+      if (!body.claim_token?.trim()) throw new HttpError(400, 'MISSING_CLAIM_TOKEN', 'claim_token is required');
+      const delivery = store.cancelClaimedDelivery(deliveryCancelMatch[1]!, {
+        daemonId: ownerId,
+        connectionId: connection?.connectionId ?? body.connection_id,
+        claimToken: body.claim_token,
+        runId: body.run_id,
+      });
+      return json({ delivery });
+    });
+  }
+
   if (request.method === 'POST' && pathname === '/api/messages') {
     return readJson<SendBody>(request).then(async (body) => {
       const connection = assertDaemonConnection(store, request);
@@ -2929,7 +2973,7 @@ export function route(store: MessageStore, request: Request, options: AppRouteOp
     });
   }
 
-  const actionMatch = pathname.match(/^\/api\/runs\/([^/]+)\/(kill|restart)$/);
+  const actionMatch = pathname.match(/^\/api\/runs\/([^/]+)\/(kill|restart|interrupt)$/);
   if (request.method === 'POST' && actionMatch) {
     const run = store.requestRunAction(actionMatch[1]!, actionMatch[2] as RunAction);
     return json({ run });

package/src/cli.ts

@@ -23,6 +23,7 @@ Usage:
   bun run src/cli.ts rooms handoff --from-room <room-id> --from <agent> --purpose <goal> [--source-message <id>] [--name <room>] [--team agent:mode ...] [--stdin]
   bun run src/cli.ts rooms invite --room general --agent codex [--mode mentions|all|periodic|muted|off]
   bun run src/cli.ts rooms restart-agent --room general --agent codex [--json]
+  bun run src/cli.ts rooms interrupt-agent --room general --agent codex [--json]
   bun run src/cli.ts debate start --chat general --a palbeta --b clawed [--turns 6] <topic>
   bun run src/cli.ts rooms list [--json]
   bun run src/cli.ts rooms members --room <room-id-or-name> [--json]
@@ -139,15 +140,15 @@ function roomNameFromPurpose(purpose: string): string {
   return `handoff-${slug || Date.now().toString(36)}`;
 }
 
-function parseTeamFlags(values: string[]): Array<{ agent: string; mode?: 'all' | 'periodic' | 'mentions' | 'muted' | 'off' }> | undefined {
+function parseTeamFlags(values: string[]): Array<{ agent: string; mode?: 'all' | 'available' | 'periodic' | 'mentions' | 'muted' | 'off' }> | undefined {
   if (!values.length) return undefined;
   return values.map((value) => {
     const [agent, mode] = value.split(':');
     if (!agent?.trim()) throw new Error('--team requires agent or agent:mode');
-    if (mode && !['all', 'periodic', 'mentions', 'muted', 'off'].includes(mode)) {
-      throw new Error('--team mode must be all, periodic, mentions, muted, or off');
+    if (mode && !['all', 'available', 'periodic', 'mentions', 'muted', 'off'].includes(mode)) {
+      throw new Error('--team mode must be all, available, periodic, mentions, muted, or off');
     }
-    return { agent: agent.trim(), mode: mode as 'all' | 'periodic' | 'mentions' | 'muted' | 'off' | undefined };
+    return { agent: agent.trim(), mode: mode as 'all' | 'available' | 'periodic' | 'mentions' | 'muted' | 'off' | undefined };
   });
 }
 
@@ -614,6 +615,21 @@ async function main(): Promise<void> {
       }
       return;
     }
+    if (sub === 'interrupt-agent' || sub === 'stop-agent') {
+      const roomRef = flag(args.flags, 'room') ?? flag(args.flags, 'chat-id') ?? args.values[1];
+      const agent = flag(args.flags, 'agent') ?? args.values[2];
+      if (!roomRef) throw new Error(`rooms ${sub} requires --room <room-id-or-name>`);
+      if (!agent) throw new Error(`rooms ${sub} requires --agent <agent-key>`);
+      const result = await daemonClient.interruptRoomAgent(roomRef, agent);
+      if (args.flags.json) {
+        printJson(result);
+      } else {
+        console.log(`interrupt requested for @${sanitizeProviderIds(agent)} in ${sanitizeProviderIds(roomRef)}: run=${result.run.id} status=${result.run.status} pending_backlog=${result.pending_backlog_count}`);
+        console.log('Pending messages were not cleared; they remain available for the next wakeup.');
+        console.log('Already completed file changes, commands, and external side effects are not rolled back.');
+      }
+      return;
+    }
     throw new Error(`unknown rooms subcommand: ${sub}`);
   }
 

package/src/client.ts

@@ -134,6 +134,12 @@ export interface HeldDraftResolutionResult {
   notify?: unknown;
 }
 
+export interface InterruptRoomAgentResult {
+  run: AgentRun;
+  pending_backlog_count: number;
+  message: string;
+}
+
 export interface ListHeldDraftsRequest {
   agent?: string;
   room_id?: string | null;
@@ -388,6 +394,10 @@ export class LockClient {
     return data.run;
   }
 
+  async interruptRoomAgent(room: string, agent: string): Promise<InterruptRoomAgentResult> {
+    return this.post<InterruptRoomAgentResult>(`/api/rooms/${encodeURIComponent(room)}/agents/${encodeURIComponent(agent)}/interrupt`, {});
+  }
+
   async scheduleReminder(input: CreateRoomReminderRequest): Promise<RoomReminder> {
     const data = await this.post<{ reminder: RoomReminder }>('/api/reminders', input);
     return data.reminder;
@@ -667,6 +677,11 @@ export class LockClient {
     return data.delivery;
   }
 
+  async cancelClaimedDelivery(id: string, input: FinishDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>(`/api/deliveries/${id}/cancel`, input);
+    return data.delivery;
+  }
+
   async getOrCreateSession(input: GetOrCreateSessionRequest): Promise<AgentSession> {
     const data = await this.post<{ session: AgentSession }>('/api/sessions', input);
     return data.session;

package/src/daemon-client.ts

@@ -1,7 +1,7 @@
 import { defaultDaemonToken, defaultDaemonUrl } from './config.js';
 import { localHeaders } from './local-auth.js';
 import type { AgentRoomSubscriptionMode, AgentRun, ApiResponse, Chat, HeldMessageDraft, Message, RoomChannel, RoomParticipant, RoomReminder, RoomSavedMessage, RoomTask, RoomTaskStatus, RunAction } from './types.js';
-import type { ClaimRoomTaskRequest, CreateArtifactRequest, CreateHandoffRoomRequest, CreateRoomReminderRequest, CreateRoomSavedMessageRequest, CreateRoomTasksRequest, HeldDraftResolutionResult, ListHeldDraftsRequest, ListRoomRemindersRequest, ListRoomSavedMessagesRequest, SendMessageResult, SendRequest } from './client.js';
+import type { ClaimRoomTaskRequest, CreateArtifactRequest, CreateHandoffRoomRequest, CreateRoomReminderRequest, CreateRoomSavedMessageRequest, CreateRoomTasksRequest, HeldDraftResolutionResult, InterruptRoomAgentResult, ListHeldDraftsRequest, ListRoomRemindersRequest, ListRoomSavedMessagesRequest, SendMessageResult, SendRequest } from './client.js';
 
 export class DaemonClient {
   readonly baseUrl: string;
@@ -115,6 +115,10 @@ export class DaemonClient {
     return data.run;
   }
 
+  async interruptRoomAgent(room: string, agent: string): Promise<InterruptRoomAgentResult> {
+    return this.post<InterruptRoomAgentResult>(`/local/rooms/${encodeURIComponent(room)}/agents/${encodeURIComponent(agent)}/interrupt`, {});
+  }
+
   async scheduleReminder(input: CreateRoomReminderRequest): Promise<RoomReminder> {
     const data = await this.post<{ reminder: RoomReminder }>('/local/reminders', input);
     return data.reminder;

package/src/daemon.ts

@@ -8,7 +8,7 @@ import { formatMessage } from './format.js';
 import { startLocalApi } from './local-api.js';
 import type { LocalApiAgentPrincipal } from './local-auth.js';
 import { loadOrCreateDaemonToken } from './token-file.js';
-import type { ComputerAgentAssignment, Message, MessageDelivery } from './types.js';
+import type { AgentRun, ComputerAgentAssignment, Message, MessageDelivery, RunAction } from './types.js';
 import type { AgentRuntime } from './agent-runtime.js';
 import { knownRuntimeNames, resolveRuntimeDriver } from './runtime-registry.js';
 import { buildRuntimeLaunchContext, type AgentPermissionProfile } from './agent-permissions.js';
@@ -457,7 +457,7 @@ async function loadPermissionProfile(client: LockClient, agent: string): Promise
 }
 
 async function ackSteeredDeliveries(
-  client: LockClient,
+  client: Pick<LockClient, 'ackDelivery'>,
   active: ActiveRunHandle,
   options: { daemonId: string; connectionId?: string | null },
   runId: string,
@@ -475,7 +475,7 @@ async function ackSteeredDeliveries(
 }
 
 async function failSteeredDeliveries(
-  client: LockClient,
+  client: Pick<LockClient, 'failDelivery'>,
   active: ActiveRunHandle,
   options: { daemonId: string; connectionId?: string | null },
   runId: string,
@@ -494,11 +494,57 @@ async function failSteeredDeliveries(
   }
 }
 
+export async function finishStoppedRunAction(
+  client: Pick<LockClient, 'finishRun' | 'ackDelivery' | 'cancelClaimedDelivery' | 'failDelivery'>,
+  input: {
+    action: 'kill' | 'restart' | 'interrupt';
+    runId: string;
+    exitCode: number | null;
+    output: string;
+    delivery: MessageDelivery;
+    active: ActiveRunHandle;
+    daemonId: string;
+    connectionId?: string | null;
+  },
+): Promise<'done' | 'restart'> {
+  if (!input.delivery.claim_token) throw new Error(`delivery ${input.delivery.id} is not claimed`);
+  if (input.action === 'restart') {
+    await client.finishRun(input.runId, { status: 'restarted', exit_code: input.exitCode, output: input.output });
+    await failSteeredDeliveries(client, input.active, { daemonId: input.daemonId, connectionId: input.connectionId }, input.runId, 'active run restarted before completion');
+    return 'restart';
+  }
+  if (input.action === 'kill') {
+    await client.finishRun(input.runId, { status: 'killed', exit_code: input.exitCode, output: input.output });
+    await client.ackDelivery(input.delivery.id, { daemon_id: input.daemonId, connection_id: input.connectionId, claim_token: input.delivery.claim_token, run_id: input.runId });
+    await ackSteeredDeliveries(client, input.active, { daemonId: input.daemonId, connectionId: input.connectionId }, input.runId);
+    return 'done';
+  }
+
+  await client.finishRun(input.runId, { status: 'cancelled', exit_code: input.exitCode, output: input.output });
+  await client.cancelClaimedDelivery(input.delivery.id, { daemon_id: input.daemonId, connection_id: input.connectionId, claim_token: input.delivery.claim_token, run_id: input.runId });
+  await failSteeredDeliveries(client, input.active, { daemonId: input.daemonId, connectionId: input.connectionId }, input.runId, 'active run interrupted before completion');
+  return 'done';
+}
+
+export async function resolveStoppedRunActionAfterRuntime(
+  client: Pick<LockClient, 'getRun'>,
+  input: { runId: string; observedAction: RunAction | null },
+): Promise<RunAction | null> {
+  if (input.observedAction) return input.observedAction;
+  const latest = await client.getRun(input.runId).catch((error) => {
+    console.warn(`[daemon] failed to re-check run action run=${input.runId}: ${error instanceof Error ? error.message : String(error)}`);
+    return null as AgentRun | null;
+  });
+  if (latest?.status === 'running' && latest.action) return latest.action;
+  return null;
+}
+
 async function ackCoveredPendingDeliveries(
   client: LockClient,
   input: {
     agent: string;
     chatId: string;
+    startMessageId: number;
     triggerMessageId: number;
     maxCoveredMessageId: number;
     daemonId: string;
@@ -507,12 +553,13 @@ async function ackCoveredPendingDeliveries(
     runId: string;
   },
 ): Promise<void> {
-  if (input.maxCoveredMessageId <= input.triggerMessageId) return;
+  if (input.maxCoveredMessageId <= input.startMessageId) return;
   const pending = await client.listDeliveries(input.agent, 'pending', PENDING_DELIVERY_CANDIDATE_LIMIT);
   const covered = pending.filter((delivery) => (
     delivery.chat_id === input.chatId
-    && delivery.message_id > input.triggerMessageId
+    && delivery.message_id > input.startMessageId
     && delivery.message_id <= input.maxCoveredMessageId
+    && delivery.message_id !== input.triggerMessageId
   ));
   for (const delivery of covered) {
     try {
@@ -674,6 +721,7 @@ async function executeRun(client: LockClient, delivery: MessageDelivery, message
     extraArgs: options.extraArgs,
   });
   const maxCoveredMessageId = deliveryContext?.messages.reduce((max, item) => Math.max(max, item.id), message.id) ?? message.id;
+  const startMessageId = deliveryContext?.startMessageId ?? message.id;
 
   try {
     const runtimeAttachments = runtimeAttachmentsForMessage({ message });
@@ -736,6 +784,56 @@ async function executeRun(client: LockClient, delivery: MessageDelivery, message
       return 'done';
     }
 
+    const stoppedByAction = await resolveStoppedRunActionAfterRuntime(client, {
+      runId: run.id,
+      observedAction: result.stoppedByAction,
+    });
+    if (stoppedByAction && stoppedByAction !== result.stoppedByAction) {
+      console.log(`${logPrefix} run=${run.id} persisted action=${stoppedByAction} observed after runtime exit`);
+    }
+
+    if (stoppedByAction === 'restart') {
+      console.log(`${logPrefix} run=${run.id} finishing with restart`);
+      return finishStoppedRunAction(client, {
+        action: 'restart',
+        runId: run.id,
+        exitCode: result.exitCode,
+        output: result.output,
+        delivery,
+        active: activeHandle,
+        daemonId: options.daemonId,
+        connectionId: options.connectionId,
+      });
+    }
+
+    if (stoppedByAction === 'kill') {
+      console.log(`${logPrefix} run=${run.id} finishing with killed`);
+      return finishStoppedRunAction(client, {
+        action: 'kill',
+        runId: run.id,
+        exitCode: result.exitCode,
+        output: result.output,
+        delivery,
+        active: activeHandle,
+        daemonId: options.daemonId,
+        connectionId: options.connectionId,
+      });
+    }
+
+    if (stoppedByAction === 'interrupt') {
+      console.log(`${logPrefix} run=${run.id} finishing with cancelled`);
+      return finishStoppedRunAction(client, {
+        action: 'interrupt',
+        runId: run.id,
+        exitCode: result.exitCode,
+        output: result.output,
+        delivery,
+        active: activeHandle,
+        daemonId: options.daemonId,
+        connectionId: options.connectionId,
+      });
+    }
+
     if (options.dryRun && result.output.trim()) {
       console.log(`${logPrefix} dry-run sending output back to chat`);
       await client.sendMessage({
@@ -747,21 +845,6 @@ async function executeRun(client: LockClient, delivery: MessageDelivery, message
       });
     }
 
-    if (result.stoppedByAction === 'restart') {
-      console.log(`${logPrefix} run=${run.id} finishing with restart`);
-      await client.finishRun(run.id, { status: 'restarted', exit_code: result.exitCode, output: result.output });
-      await failSteeredDeliveries(client, activeHandle, options, run.id, 'active run restarted before completion');
-      return 'restart';
-    }
-
-    if (result.stoppedByAction === 'kill') {
-      console.log(`${logPrefix} run=${run.id} finishing with killed`);
-      await client.finishRun(run.id, { status: 'killed', exit_code: result.exitCode, output: result.output });
-      await client.ackDelivery(delivery.id, { daemon_id: options.daemonId, connection_id: options.connectionId, claim_token: delivery.claim_token, run_id: run.id });
-      await ackSteeredDeliveries(client, activeHandle, options, run.id);
-      return 'done';
-    }
-
     if (result.exitCode === 0) {
       console.log(`${logPrefix} run=${run.id} finishing with completed`);
       await client.finishRun(run.id, { status: 'completed', exit_code: result.exitCode, output: result.output });
@@ -769,6 +852,7 @@ async function executeRun(client: LockClient, delivery: MessageDelivery, message
       await ackCoveredPendingDeliveries(client, {
         agent: options.agent,
         chatId: message.chat_id,
+        startMessageId,
         triggerMessageId: message.id,
         maxCoveredMessageId,
         daemonId: options.daemonId,
@@ -1058,7 +1142,7 @@ async function reconcileManagedAgents(input: {
   return activatedAgents;
 }
 
-async function main(): Promise<void> {
+export async function main(): Promise<void> {
   const rawArgs = parseArgs();
   // When launched as `bun run src/daemon.ts --agent foo`, the first arg is a flag,
   // not a subcommand. Shift it back into flags/values.

package/src/db.ts

@@ -1448,9 +1448,9 @@ export class MessageStore {
     this.palHome = options.palHome ?? defaultPalHomeDir();
     ensureParentDir(path);
     this.db = new Database(path);
+    this.db.exec('PRAGMA busy_timeout = 5000');
     this.db.exec('PRAGMA journal_mode = WAL');
     this.db.exec('PRAGMA foreign_keys = ON');
-    this.db.exec('PRAGMA busy_timeout = 5000');
     runMigrations(this.db);
   }
 
@@ -4646,7 +4646,7 @@ export class MessageStore {
     const previous = this.db.query(`
       SELECT COALESCE(MAX(message_id), 0) AS message_id
       FROM message_deliveries
-      WHERE agent = ? AND chat_id = ? AND message_id < ?
+      WHERE agent = ? AND chat_id = ? AND message_id < ? AND status IN ('acked', 'failed', 'canceled')
     `).get(input.agent, room.id, trigger.id) as { message_id: number } | null;
     const startMessageId = Math.max(Number(cursor ?? 0), Number(previous?.message_id ?? 0), 0);
     const total = this.db.query(`
@@ -5294,7 +5294,7 @@ export class MessageStore {
         SELECT md.*
         FROM message_deliveries md
         INNER JOIN (
-          SELECT pending.chat_id, MIN(pending.rowid) AS first_rowid
+          SELECT pending.chat_id, MAX(pending.rowid) AS first_rowid
           FROM message_deliveries pending
           WHERE pending.agent = ? AND pending.status = ?
             AND NOT EXISTS (
@@ -5320,7 +5320,7 @@ export class MessageStore {
         SELECT md.*
         FROM message_deliveries md
         INNER JOIN (
-          SELECT chat_id, MIN(rowid) AS first_rowid
+          SELECT chat_id, MAX(rowid) AS first_rowid
           FROM message_deliveries
           WHERE agent = ? AND status = ?
           GROUP BY chat_id
@@ -5338,6 +5338,16 @@ export class MessageStore {
     return rows.map(rowToDelivery);
   }
 
+  countPendingDeliveriesAfterMessage(input: { roomId: string; agent: string; afterMessageId: number }): number {
+    this.releaseExpiredDeliveries();
+    const row = this.db.query(`
+      SELECT COUNT(*) AS count
+      FROM message_deliveries
+      WHERE chat_id = ? AND agent = ? AND status = 'pending' AND message_id > ?
+    `).get(input.roomId, input.agent.trim(), input.afterMessageId) as { count: number } | null;
+    return Number(row?.count ?? 0);
+  }
+
   listRecentDeliveriesForAgent(agent: string, limit = 20): MessageDelivery[] {
     this.releaseExpiredDeliveries();
     const rows = this.db.query(`
@@ -5429,7 +5439,7 @@ export class MessageStore {
     }
     const allRows = this.db.query(`
       SELECT agent FROM agent_room_subscriptions
-      WHERE room_id = ? AND channel_id IS NULL AND mode IN ('all', 'periodic')
+      WHERE room_id = ? AND channel_id IS NULL AND mode IN ('all', 'available', 'periodic')
     `).all(room.id) as Array<{ agent: string }>;
     for (const row of allRows) candidates.add(row.agent);
 
@@ -5479,6 +5489,8 @@ export class MessageStore {
     const mode = subscription?.mode ?? 'mentions';
     if (mode === 'off') return false;
     if (direct) return true;
+    const hasAnyMention = message.recipient !== null || (message.mentions ?? []).length > 0;
+    if (mode === 'available') return !hasAnyMention;
     if (mode === 'all') return true;
     return false;
   }
@@ -5773,6 +5785,27 @@ export class MessageStore {
     return this.getDelivery(id)!;
   }
 
+  cancelClaimedDelivery(id: string, input: FinishDeliveryInput): MessageDelivery {
+    const existing = this.getDelivery(id);
+    if (existing?.status === 'canceled') {
+      if ((existing.connection_id ?? existing.daemon_id) === (input.connectionId ?? input.daemonId) && existing.claim_token === input.claimToken && existing.run_id === (input.runId ?? null)) {
+        return existing;
+      }
+      throw new Error(`terminal delivery ${id} conflicts with cancel request`);
+    }
+    if (existing && ['acked', 'failed'].includes(existing.status)) {
+      throw new Error(`terminal delivery ${id} cannot be canceled from ${existing.status}`);
+    }
+
+    const result = this.db.query(`
+      UPDATE message_deliveries
+      SET status = 'canceled', run_id = COALESCE(?, run_id)
+      WHERE id = ? AND status IN ('claimed', 'processing_completed') AND (connection_id = ? OR (connection_id IS NULL AND daemon_id = ?)) AND claim_token = ?
+    `).run(input.runId ?? null, id, input.connectionId ?? input.daemonId, input.daemonId, input.claimToken);
+    if (result.changes === 0) throw new Error(`claimed delivery ${id} was not found`);
+    return this.getDelivery(id)!;
+  }
+
   ackDelivery(id: string, input: FinishDeliveryInput): MessageDelivery {
     const existing = this.getDelivery(id);
     if (existing?.status === 'acked') {

package/src/local-api.ts

@@ -244,7 +244,7 @@ function requireMessageWritePrincipal(principal: LocalApiPrincipal, body: SendBo
 function requireAgentRoomScope(principal: LocalApiPrincipal, roomRef: string): void {
   if (principal.kind === 'daemon') return;
   if (roomRef !== principal.chatId) {
-    throw new HttpError(403, 'LOCAL_AGENT_FORBIDDEN', 'agent-scoped token can only manage tasks in its active room by chat_id');
+    throw new HttpError(403, 'LOCAL_AGENT_FORBIDDEN', 'agent-scoped token can only access its active room by chat_id');
   }
 }
 
@@ -540,6 +540,17 @@ export async function localRoute(request: Request, options: LocalApiOptions): Pr
       return json({ run: await client.restartRoomAgent(roomRef, restartAgent) });
     }
 
+    const roomAgentInterruptMatch = pathname.match(/^\/local\/rooms\/([^/]+)\/agents\/([^/]+)\/interrupt$/);
+    if (request.method === 'POST' && roomAgentInterruptMatch) {
+      const roomRef = decodeURIComponent(roomAgentInterruptMatch[1]!);
+      requireAgentRoomScope(principal, roomRef);
+      const interruptAgent = decodeURIComponent(roomAgentInterruptMatch[2]!);
+      if (principal.kind === 'agent' && interruptAgent !== principal.agent) {
+        throw new HttpError(403, 'LOCAL_AGENT_FORBIDDEN', 'agent-scoped token can only interrupt its own runtime');
+      }
+      return json(await client.interruptRoomAgent(roomRef, interruptAgent));
+    }
+
     if (request.method === 'GET' && pathname === '/local/reminders') {
       return json({
         reminders: await client.listReminders({

package/src/migrations/017_unified_room_delivery.ts

@@ -92,7 +92,7 @@ export function up(db: Database): void {
       agent TEXT NOT NULL,
       room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
       channel_id TEXT REFERENCES room_channels(id) ON DELETE CASCADE,
-      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'periodic', 'mentions', 'muted', 'off')),
+      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'available', 'periodic', 'mentions', 'muted', 'off')),
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now')),
       UNIQUE(agent, room_id, channel_id)

package/src/migrations/036_project_agent_defaults.ts

@@ -9,7 +9,7 @@ export function up(db: Database): void {
       id TEXT PRIMARY KEY,
       project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
       agent TEXT NOT NULL,
-      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'periodic', 'mentions', 'muted', 'off')),
+      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'available', 'periodic', 'mentions', 'muted', 'off')),
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now')),
       UNIQUE(project_id, agent)

package/src/migrations/046_agent_run_interrupt.ts

@@ -0,0 +1,78 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 46;
+export const name = 'agent_run_interrupt';
+export const transaction = false;
+
+export function up(db: Database): void {
+  const row = db.query(`
+    SELECT sql
+    FROM sqlite_master
+    WHERE type = 'table' AND name = 'agent_runs'
+  `).get() as { sql?: string } | null;
+  const sql = row?.sql ?? '';
+  if (sql.includes("'interrupt'") && sql.includes("'cancelled'")) return;
+
+  db.exec('PRAGMA foreign_keys = OFF');
+  db.exec('PRAGMA legacy_alter_table = ON');
+  try {
+    db.exec(`
+      DROP INDEX IF EXISTS idx_agent_runs_message_id;
+      DROP INDEX IF EXISTS idx_agent_runs_status;
+      DROP INDEX IF EXISTS idx_agent_runs_session_id;
+      DROP INDEX IF EXISTS idx_agent_runs_delivery_id;
+      DROP INDEX IF EXISTS idx_agent_runs_connection_id;
+      DROP INDEX IF EXISTS idx_agent_runs_computer_room_active;
+
+      ALTER TABLE agent_runs RENAME TO agent_runs_legacy;
+
+      CREATE TABLE agent_runs (
+        id TEXT PRIMARY KEY,
+        message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+        agent TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed', 'killed', 'restarted', 'cancelled')),
+        action TEXT CHECK (action IN ('kill', 'restart', 'interrupt')),
+        attempt INTEGER NOT NULL DEFAULT 1,
+        pid INTEGER,
+        cwd TEXT NOT NULL,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        ended_at TEXT,
+        exit_code INTEGER,
+        output TEXT NOT NULL DEFAULT '',
+        session_id TEXT REFERENCES agent_sessions(id) ON DELETE SET NULL,
+        trigger_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+        daemon_id TEXT REFERENCES daemon_instances(id) ON DELETE SET NULL,
+        delivery_id TEXT REFERENCES message_deliveries(id) ON DELETE SET NULL,
+        computer_id TEXT REFERENCES computers(id) ON DELETE SET NULL,
+        connection_id TEXT REFERENCES computer_connections(id) ON DELETE SET NULL,
+        runtime_provider TEXT,
+        runtime_invocation_id TEXT
+      );
+
+      INSERT INTO agent_runs (
+        id, message_id, agent, status, action, attempt, pid, cwd, started_at, updated_at, ended_at,
+        exit_code, output, session_id, trigger_message_id, daemon_id, delivery_id, computer_id,
+        connection_id, runtime_provider, runtime_invocation_id
+      )
+      SELECT
+        id, message_id, agent, status, action, attempt, pid, cwd, started_at, updated_at, ended_at,
+        exit_code, output, session_id, trigger_message_id, daemon_id, delivery_id, computer_id,
+        connection_id, runtime_provider, runtime_invocation_id
+      FROM agent_runs_legacy;
+
+      DROP TABLE agent_runs_legacy;
+
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_message_id ON agent_runs(message_id, attempt);
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_status ON agent_runs(status, updated_at);
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_session_id ON agent_runs(session_id, attempt);
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_delivery_id ON agent_runs(delivery_id);
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_connection_id ON agent_runs(connection_id);
+      CREATE INDEX IF NOT EXISTS idx_agent_runs_computer_room_active
+        ON agent_runs(computer_id, agent, status, session_id);
+    `);
+  } finally {
+    db.exec('PRAGMA legacy_alter_table = OFF');
+    db.exec('PRAGMA foreign_keys = ON');
+  }
+}

package/src/migrations/047_available_receive_mode.ts

@@ -0,0 +1,57 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 47;
+export const name = 'available_receive_mode';
+
+export function up(db: Database): void {
+  db.exec(`
+    ALTER TABLE agent_room_subscriptions RENAME TO agent_room_subscriptions_old;
+
+    CREATE TABLE agent_room_subscriptions (
+      id TEXT PRIMARY KEY,
+      agent TEXT NOT NULL,
+      room_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      channel_id TEXT REFERENCES room_channels(id) ON DELETE CASCADE,
+      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'available', 'periodic', 'mentions', 'muted', 'off')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_read_message_id INTEGER NOT NULL DEFAULT 0,
+      last_read_at TEXT,
+      UNIQUE(agent, room_id, channel_id)
+    );
+
+    INSERT INTO agent_room_subscriptions (
+      id, agent, room_id, channel_id, mode, created_at, updated_at, last_read_message_id, last_read_at
+    )
+    SELECT id, agent, room_id, channel_id, mode, created_at, updated_at, last_read_message_id, last_read_at
+    FROM agent_room_subscriptions_old;
+
+    DROP TABLE agent_room_subscriptions_old;
+
+    CREATE INDEX IF NOT EXISTS idx_agent_room_subscriptions_room
+      ON agent_room_subscriptions(room_id, mode, agent);
+    CREATE INDEX IF NOT EXISTS idx_agent_room_subscriptions_read_state
+      ON agent_room_subscriptions(agent, room_id, last_read_message_id);
+
+    ALTER TABLE project_agent_defaults RENAME TO project_agent_defaults_old;
+
+    CREATE TABLE project_agent_defaults (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      mode TEXT NOT NULL DEFAULT 'mentions' CHECK (mode IN ('all', 'available', 'periodic', 'mentions', 'muted', 'off')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(project_id, agent)
+    );
+
+    INSERT INTO project_agent_defaults (id, project_id, agent, mode, created_at, updated_at)
+    SELECT id, project_id, agent, mode, created_at, updated_at
+    FROM project_agent_defaults_old;
+
+    DROP TABLE project_agent_defaults_old;
+
+    CREATE INDEX IF NOT EXISTS idx_project_agent_defaults_project
+      ON project_agent_defaults(project_id, agent);
+  `);
+}

package/src/migrations.ts

@@ -44,10 +44,13 @@ import * as messageAttachmentFileKind from './migrations/042_message_attachment_
 import * as roomModeSkillRegistry from './migrations/043_room_mode_skill_registry.js';
 import * as workflowRuntime from './migrations/044_workflow_runtime.js';
 import * as skillRepositoryOwnership from './migrations/045_skill_repository_ownership.js';
+import * as agentRunInterrupt from './migrations/046_agent_run_interrupt.js';
+import * as availableReceiveMode from './migrations/047_available_receive_mode.js';
 
 interface Migration {
   version: number;
   name: string;
+  transaction?: boolean;
   up(db: Database): void;
 }
 
@@ -97,6 +100,8 @@ const migrations: Migration[] = [
   roomModeSkillRegistry,
   workflowRuntime,
   skillRepositoryOwnership,
+  agentRunInterrupt,
+  availableReceiveMode,
 ].sort((a, b) => a.version - b.version);
 
 function assertContiguousMigrations(): void {
@@ -147,9 +152,14 @@ export function runMigrations(db: Database): void {
   for (const migration of migrations) {
     if (applied.has(migration.version)) continue;
 
-    db.transaction(() => {
+    const applyMigration = () => {
       migration.up(db);
       markApplied(db, migration);
-    })();
+    };
+    if (migration.transaction === false) {
+      applyMigration();
+    } else {
+      db.transaction(applyMigration)();
+    }
   }
 }

package/src/types.ts

@@ -5,7 +5,7 @@ export type ProjectStatus = 'active' | 'archived';
 export type MessageType = 'message' | 'system';
 export type RoomProvider = 'web' | 'lark' | 'wechat';
 export type RoomTopicCapability = 'native' | 'unsupported';
-export type AgentRoomSubscriptionMode = 'all' | 'periodic' | 'mentions' | 'muted' | 'off';
+export type AgentRoomSubscriptionMode = 'all' | 'available' | 'periodic' | 'mentions' | 'muted' | 'off';
 export type RoomSystemEventType = 'agent_invited' | 'agent_removed' | 'agent_receive_mode_changed';
 export type RoomSystemEventActorKind = 'user' | 'agent' | 'system';
 export type PalIdentityKind = 'user' | 'bot' | 'agent' | 'room';
@@ -181,8 +181,8 @@ export interface MessageAttachment extends MessageAttachmentMetadata {
   source_ref: string | null;
 }
 
-export type RunStatus = 'running' | 'completed' | 'failed' | 'killed' | 'restarted';
-export type RunAction = 'kill' | 'restart';
+export type RunStatus = 'running' | 'completed' | 'failed' | 'killed' | 'restarted' | 'cancelled';
+export type RunAction = 'kill' | 'restart' | 'interrupt';
 export type DeliveryStatus = 'pending' | 'claimed' | 'processing_completed' | 'acked' | 'failed' | 'canceled';
 export type HeldDraftStatus = 'held' | 'abandoned' | 'sent_anyway';
 export type RoomTaskStatus = 'todo' | 'in_progress' | 'in_review' | 'done' | 'closed';