clawmini 0.0.8 → 0.0.9

package/src/daemon/agent/turn-registry.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import {
+  registerTurn,
+  incrementSubagent,
+  decrementSubagent,
+  markParentExited,
+  _resetTurnRegistryForTests,
+  _getTurnStateForTests,
+} from './turn-registry.js';
+import { daemonEvents, DAEMON_EVENT_TURN_ENDED, type TurnEndedEvent } from '../events.js';
+
+describe('turn-registry', () => {
+  let ended: TurnEndedEvent[];
+  const capture = (e: TurnEndedEvent) => {
+    ended.push(e);
+  };
+
+  beforeEach(() => {
+    ended = [];
+    daemonEvents.on(DAEMON_EVENT_TURN_ENDED, capture);
+    _resetTurnRegistryForTests();
+  });
+
+  afterEach(() => {
+    daemonEvents.off(DAEMON_EVENT_TURN_ENDED, capture);
+    _resetTurnRegistryForTests();
+  });
+
+  it('fires turnEnded immediately when parent exits with no outstanding subagents', () => {
+    registerTurn('chat-1', 'turn-a');
+    markParentExited('turn-a', 'ok');
+    expect(ended).toEqual([{ chatId: 'chat-1', turnId: 'turn-a', outcome: 'ok' }]);
+    expect(_getTurnStateForTests('turn-a')).toBeUndefined();
+  });
+
+  it('defers turnEnded until outstanding subagents drain', () => {
+    registerTurn('chat-1', 'turn-a');
+    incrementSubagent('turn-a');
+    incrementSubagent('turn-a');
+    markParentExited('turn-a', 'ok');
+    expect(ended).toEqual([]);
+    decrementSubagent('turn-a');
+    expect(ended).toEqual([]);
+    decrementSubagent('turn-a');
+    expect(ended).toEqual([{ chatId: 'chat-1', turnId: 'turn-a', outcome: 'ok' }]);
+  });
+
+  it('preserves outcome=error when parent exited with an error', () => {
+    registerTurn('chat-1', 'turn-a');
+    incrementSubagent('turn-a');
+    markParentExited('turn-a', 'error');
+    decrementSubagent('turn-a');
+    expect(ended).toEqual([{ chatId: 'chat-1', turnId: 'turn-a', outcome: 'error' }]);
+  });
+
+  it('ignores decrements below zero and extra markParentExited calls', () => {
+    registerTurn('chat-1', 'turn-a');
+    decrementSubagent('turn-a'); // no-op
+    markParentExited('turn-a', 'ok');
+    markParentExited('turn-a', 'error'); // ignored
+    expect(ended).toEqual([{ chatId: 'chat-1', turnId: 'turn-a', outcome: 'ok' }]);
+  });
+
+  it('force-fires turnEnded with outcome=error when the timeout elapses', () => {
+    vi.useFakeTimers();
+    try {
+      registerTurn('chat-1', 'turn-a', 100);
+      incrementSubagent('turn-a');
+      markParentExited('turn-a', 'ok');
+      expect(ended).toEqual([]);
+      vi.advanceTimersByTime(150);
+      expect(ended).toEqual([{ chatId: 'chat-1', turnId: 'turn-a', outcome: 'error' }]);
+      // A later decrement after force-fire is a no-op (turn already removed).
+      decrementSubagent('turn-a');
+      expect(ended).toHaveLength(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('is a no-op for unknown turnIds and undefined turnIds', () => {
+    incrementSubagent(undefined);
+    decrementSubagent(undefined);
+    incrementSubagent('never-registered');
+    decrementSubagent('never-registered');
+    markParentExited('never-registered', 'ok');
+    expect(ended).toEqual([]);
+  });
+});

package/src/daemon/agent/turn-registry.ts

@@ -0,0 +1,94 @@
+import { emitTurnEnded } from '../events.js';
+
+interface TurnState {
+  chatId: string;
+  outstanding: number;
+  parentExited: boolean;
+  outcome: 'ok' | 'error';
+  timeoutHandle: NodeJS.Timeout;
+}
+
+const turns = new Map<string, TurnState>();
+
+/**
+ * Watchdog for turns whose subagent count never drains. Pathological cases
+ * (crashed subagent, bug leaving the counter > 0) would otherwise pin the
+ * turn's activity log open indefinitely. Default is a guess — instrument
+ * before tuning.
+ */
+export const DEFAULT_TURN_MAX_DURATION_MS = 30 * 60 * 1000;
+
+export function registerTurn(
+  chatId: string,
+  turnId: string,
+  maxDurationMs: number = DEFAULT_TURN_MAX_DURATION_MS
+): void {
+  if (turns.has(turnId)) return;
+  const state: TurnState = {
+    chatId,
+    outstanding: 0,
+    parentExited: false,
+    outcome: 'ok',
+    timeoutHandle: setTimeout(() => {
+      const s = turns.get(turnId);
+      if (!s) return;
+      console.warn(
+        `Turn ${turnId} force-ended after ${maxDurationMs}ms (outstanding=${s.outstanding}).`
+      );
+      turns.delete(turnId);
+      emitTurnEnded({ chatId: s.chatId, turnId, outcome: 'error' });
+    }, maxDurationMs),
+  };
+  state.timeoutHandle.unref();
+  turns.set(turnId, state);
+}
+
+export function incrementSubagent(turnId: string | undefined): void {
+  if (!turnId) return;
+  const state = turns.get(turnId);
+  if (!state) return;
+  state.outstanding++;
+}
+
+export function decrementSubagent(turnId: string | undefined): void {
+  if (!turnId) return;
+  const state = turns.get(turnId);
+  if (!state) return;
+  state.outstanding = Math.max(0, state.outstanding - 1);
+  maybeFinalize(turnId, state);
+}
+
+/**
+ * Called once, when the parent agent's initial `handleMessage` promise
+ * settles. Records the outcome; the turn actually ends (emits `turnEnded`)
+ * only once the outstanding subagent count also reaches zero.
+ */
+export function markParentExited(turnId: string, outcome: 'ok' | 'error'): void {
+  const state = turns.get(turnId);
+  if (!state) return;
+  if (state.parentExited) return;
+  state.parentExited = true;
+  state.outcome = outcome;
+  maybeFinalize(turnId, state);
+}
+
+function maybeFinalize(turnId: string, state: TurnState): void {
+  if (!state.parentExited) return;
+  if (state.outstanding > 0) return;
+  clearTimeout(state.timeoutHandle);
+  turns.delete(turnId);
+  emitTurnEnded({ chatId: state.chatId, turnId, outcome: state.outcome });
+}
+
+/** Test hook: drop all state without emitting events. */
+export function _resetTurnRegistryForTests(): void {
+  for (const state of turns.values()) {
+    clearTimeout(state.timeoutHandle);
+  }
+  turns.clear();
+}
+
+/** Test hook: inspect registry state. */
+export function _getTurnStateForTests(turnId: string): Readonly<TurnState> | undefined {
+  return turns.get(turnId);
+}

package/src/daemon/agent/types.ts

@@ -30,6 +30,7 @@ export interface Logger {
     event: SystemMessage['event'];
     messageId?: string;
     displayRole?: 'user' | 'agent';
+    jobId?: string;
   }): Promise<SystemMessage>;
   logSubagentStatus(options: {
     subagentId: string;
@@ -56,6 +57,7 @@ export interface Message {
   id: string;
   content: string;
   env: Record<string, string>;
+  turnId?: string;
 }
 
 export interface ExecutionResponse {

package/src/daemon/api/agent-policy-endpoints.ts

@@ -0,0 +1,263 @@
+import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { apiProcedure } from './trpc.js';
+import { getWorkspaceRoot, readPoliciesForPath, getClawminiDir } from '../../shared/workspace.js';
+import { pathIsInsideDir } from '../../shared/utils/fs.js';
+import { resolveAgentDir } from './router-utils.js';
+import { PolicyRequestService } from '../policy-request-service.js';
+import { RequestStore } from '../request-store.js';
+import {
+  executeSafe,
+  generateRequestPreview,
+  executeRequest,
+  resolveRequestCwd,
+  truncateLargeOutput,
+} from '../policy-utils.js';
+import { appendMessage, type PolicyRequestMessage } from '../chats.js';
+
+const MAX_POLICY_SCRIPT_BYTES = 1 * 1024 * 1024;
+// Above this, the script is copied into the agent's tmp/ instead of being
+// inlined in the response, so `requests show` does not flood the agent's
+// context with a long script body. Mirrors truncateLargeOutput in policy-utils.
+const MAX_INLINE_SCRIPT_LENGTH = 4000;
+
+export const listPolicies = apiProcedure.query(async ({ ctx }) => {
+  const workspaceRoot = getWorkspaceRoot();
+  const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+  const config = await readPoliciesForPath(agentDir, workspaceRoot);
+  return { policies: config?.policies || {} };
+});
+
+// Returns the contents of a policy's script file. Restricted to scripts inside
+// `.clawmini/policy-scripts/` so an arbitrary `command` path (e.g. `/etc/passwd`
+// or a built-in node binary) cannot be exfiltrated through this endpoint.
+export const readPolicyScript = apiProcedure
+  .input(z.object({ commandName: z.string() }))
+  .query(async ({ input, ctx }) => {
+    const workspaceRoot = getWorkspaceRoot();
+    const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+    const config = await readPoliciesForPath(agentDir, workspaceRoot);
+    const policy = config?.policies?.[input.commandName];
+
+    if (!policy) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Policy not found: ${input.commandName}`,
+      });
+    }
+
+    const scriptsDir = path.join(getClawminiDir(), 'policy-scripts');
+    const resolvedCommand = path.resolve(policy.command);
+
+    if (!pathIsInsideDir(resolvedCommand, scriptsDir, { allowSameDir: false })) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Policy '${input.commandName}' does not point at a script in policy-scripts/.`,
+      });
+    }
+
+    // realpath resolves symlinks in both paths; without this, a symlink inside
+    // policy-scripts/ pointing at /etc/passwd would pass the string-prefix
+    // check above, then fs.stat/readFile would dereference and exfiltrate.
+    let realCommand: string;
+    let realScriptsDir: string;
+    try {
+      realCommand = await fs.realpath(resolvedCommand);
+    } catch (err) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Script file not found for policy '${input.commandName}': ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      });
+    }
+    try {
+      realScriptsDir = await fs.realpath(scriptsDir);
+    } catch {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Policy '${input.commandName}' does not point at a script in policy-scripts/.`,
+      });
+    }
+    if (!pathIsInsideDir(realCommand, realScriptsDir, { allowSameDir: false })) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Policy '${input.commandName}' does not point at a script in policy-scripts/.`,
+      });
+    }
+
+    let stat;
+    try {
+      stat = await fs.stat(realCommand);
+    } catch (err) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Script file not found for policy '${input.commandName}': ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      });
+    }
+
+    if (!stat.isFile()) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Script path for policy '${input.commandName}' is not a regular file.`,
+      });
+    }
+
+    if (stat.size > MAX_POLICY_SCRIPT_BYTES) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Script file exceeds the ${MAX_POLICY_SCRIPT_BYTES}-byte limit.`,
+      });
+    }
+
+    if (stat.size > MAX_INLINE_SCRIPT_LENGTH) {
+      const tmpDir = path.join(agentDir, 'tmp');
+      await fs.mkdir(tmpDir, { recursive: true });
+      const ext = path.extname(realCommand);
+      const safeName = input.commandName.replace(/[^a-zA-Z0-9._-]/g, '_');
+      const destPath = path.join(tmpDir, `policy-script-${safeName}${ext}`);
+      await fs.copyFile(realCommand, destPath);
+      return {
+        path: realCommand,
+        size: stat.size,
+        spilledTo: `./tmp/policy-script-${safeName}${ext}`,
+      };
+    }
+
+    const content = await fs.readFile(realCommand, 'utf8');
+    return { path: realCommand, size: stat.size, content };
+  });
+
+export const executePolicyHelp = apiProcedure
+  .input(z.object({ commandName: z.string() }))
+  .query(async ({ input, ctx }) => {
+    const workspaceRoot = getWorkspaceRoot();
+    const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+    const config = await readPoliciesForPath(agentDir, workspaceRoot);
+    const policy = config?.policies?.[input.commandName];
+
+    if (!policy) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Policy not found: ${input.commandName}`,
+      });
+    }
+
+    if (!policy.allowHelp) {
+      return { stdout: '', stderr: 'This command does not support --help\n', exitCode: 1 };
+    }
+
+    const fullArgs = [...(policy.args || []), '--help'];
+    const { stdout, stderr, exitCode } = await executeSafe(policy.command, fullArgs, {
+      cwd: getWorkspaceRoot(),
+    });
+
+    return { stdout, stderr, exitCode };
+  });
+
+export const createPolicyRequest = apiProcedure
+  .input(
+    z.object({
+      commandName: z.string(),
+      args: z.array(z.string()),
+      fileMappings: z.record(z.string(), z.string()),
+      // Path traversal is guarded by assertPathInsideDir in resolveRequestCwd
+      // (policy-utils.ts), which realpath-resolves the cwd before comparing —
+      // so it covers encoded separators, symlinks, etc.
+      cwd: z.string().optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const workspaceRoot = getWorkspaceRoot(process.cwd());
+    const snapshotDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'snapshots');
+    const store = new RequestStore(process.cwd());
+    const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+    const service = new PolicyRequestService(store, agentDir, snapshotDir);
+
+    const chatId = ctx.tokenPayload.chatId;
+    const agentId = ctx.tokenPayload.agentId;
+
+    const config = await readPoliciesForPath(agentDir, workspaceRoot);
+    const policy = config?.policies?.[input.commandName];
+
+    if (!policy) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Policy not found: ${input.commandName}`,
+      });
+    }
+
+    const isAutoApprove = !!policy.autoApprove;
+
+    const request = await service.createRequest(
+      input.commandName,
+      input.args,
+      input.fileMappings,
+      chatId,
+      agentId,
+      isAutoApprove,
+      ctx.tokenPayload.subagentId,
+      input.cwd
+    );
+
+    if (isAutoApprove) {
+      const hostCwd = await resolveRequestCwd(request.cwd, agentId, workspaceRoot);
+
+      const result = await executeRequest(request, policy, hostCwd);
+      const { exitCode, commandStr } = result;
+      const { stdout, stderr } = await truncateLargeOutput(
+        result.stdout,
+        result.stderr,
+        request.id,
+        agentId
+      );
+
+      request.executionResult = { stdout, stderr, exitCode };
+
+      const logMsg: PolicyRequestMessage = {
+        id: randomUUID(),
+        // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
+        messageId: randomUUID(),
+        role: 'policy',
+        requestId: request.id,
+        commandName: input.commandName,
+        args: input.args,
+        status: 'approved',
+        content: `[Auto-approved] Policy ${input.commandName} was executed.\n\nCommand: ${commandStr}\nExit Code: ${exitCode}\n\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
+        timestamp: new Date().toISOString(),
+        sessionId: ctx.tokenPayload.sessionId,
+        ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+        ...(ctx.tokenPayload.turnId ? { turnId: ctx.tokenPayload.turnId } : {}),
+      };
+
+      await appendMessage(chatId, logMsg);
+      return request;
+    }
+
+    const previewContent = await generateRequestPreview(request);
+
+    const logMsg: PolicyRequestMessage = {
+      id: randomUUID(),
+      // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
+      messageId: randomUUID(),
+      role: 'policy',
+      requestId: request.id,
+      commandName: input.commandName,
+      args: input.args,
+      status: 'pending',
+      content: previewContent,
+      timestamp: new Date().toISOString(),
+      displayRole: 'agent',
+      sessionId: ctx.tokenPayload.sessionId,
+      ...(ctx.tokenPayload.turnId ? { turnId: ctx.tokenPayload.turnId } : {}),
+    };
+
+    await appendMessage(chatId, logMsg);
+    return request;
+  });

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

@@ -1,19 +1,14 @@
 import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
-import path from 'node:path';
 import { TRPCError } from '@trpc/server';
 import {
   appendMessage,
   type CommandLogMessage,
   type AgentReplyMessage,
   type ToolMessage,
-  type PolicyRequestMessage,
 } from '../chats.js';
-import { executeSafe, generateRequestPreview, executeRequest } from '../policy-utils.js';
-import { getWorkspaceRoot, readPolicies, getClawminiDir } from '../../shared/workspace.js';
-import { PolicyRequestService } from '../policy-request-service.js';
-import { RequestStore } from '../request-store.js';
-import { CronJobSchema } from '../../shared/config.js';
+import { getWorkspaceRoot } from '../../shared/workspace.js';
+import type { CronJob } from '../../shared/config.js';
 import { apiProcedure, router } from './trpc.js';
 import { taskScheduler } from '../agent/task-scheduler.js';
 import { formatPendingMessages } from '../agent/utils.js';
@@ -62,7 +57,9 @@ export const logMessage = apiProcedure
       command: `clawmini-lite log${filesArgStr}`,
       cwd: process.cwd(),
       exitCode: 0,
+      sessionId: ctx.tokenPayload.sessionId,
       ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+      ...(ctx.tokenPayload.turnId ? { turnId: ctx.tokenPayload.turnId } : {}),
       ...(filePaths.length > 0 ? { files: filePaths } : {}),
     };
 
@@ -99,7 +96,9 @@ export const logReplyMessage = apiProcedure
       role: 'agent',
       content: input.message,
       timestamp,
+      sessionId: ctx.tokenPayload.sessionId,
       ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+      ...(ctx.tokenPayload.turnId ? { turnId: ctx.tokenPayload.turnId } : {}),
       ...(filePaths.length > 0 ? { files: filePaths } : {}),
     };
 
@@ -141,7 +140,9 @@ export const logToolMessage = apiProcedure
       payload: payloadObj,
       content: contentStr,
       timestamp,
+      sessionId: ctx.tokenPayload.sessionId,
       ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+      ...(ctx.tokenPayload.turnId ? { turnId: ctx.tokenPayload.turnId } : {}),
     };
 
     await appendMessage(chatId, logMsg);
@@ -154,12 +155,42 @@ export const agentListCronJobs = apiProcedure.query(async ({ ctx }) => {
   return listCronJobsShared(chatId);
 });
 
+// Agents may only set a restricted subset of CronJob fields. The remaining
+// fields (agentId, createdAt, env, nextSessionId, action, jobs) are reserved
+// for internal use and filled in by the server.
+export const AgentCronJobInputSchema = z.strictObject({
+  id: z.string().min(1),
+  message: z.string().default(''),
+  reply: z.string().optional(),
+  session: z
+    .union([
+      z.strictObject({ type: z.literal('new') }),
+      z.strictObject({ type: z.literal('existing'), id: z.string() }),
+    ])
+    .optional(),
+  schedule: z.union([
+    z.strictObject({ cron: z.string() }),
+    z.strictObject({ every: z.string() }),
+    z.strictObject({ at: z.string() }),
+  ]),
+});
+
+export type AgentCronJobInput = z.infer<typeof AgentCronJobInputSchema>;
+
 export const agentAddCronJob = apiProcedure
-  .input(z.object({ job: CronJobSchema }))
+  .input(z.object({ job: AgentCronJobInputSchema }))
   .mutation(async ({ input, ctx }) => {
     if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
     const chatId = ctx.tokenPayload.chatId;
-    const job = { ...input.job, agentId: ctx.tokenPayload.agentId };
+    const job: CronJob = {
+      id: input.job.id,
+      message: input.job.message,
+      schedule: input.job.schedule,
+      createdAt: new Date().toISOString(),
+      agentId: ctx.tokenPayload.agentId,
+      ...(input.job.reply !== undefined ? { reply: input.job.reply } : {}),
+      ...(input.job.session !== undefined ? { session: input.job.session } : {}),
+    };
     return addCronJobShared(chatId, job);
   });
 
@@ -171,123 +202,12 @@ export const agentDeleteCronJob = apiProcedure
     return deleteCronJobShared(chatId, input.id);
   });
 
-export const listPolicies = apiProcedure.query(async () => {
-  return await readPolicies();
-});
-
-export const executePolicyHelp = apiProcedure
-  .input(z.object({ commandName: z.string() }))
-  .query(async ({ input }) => {
-    const config = await readPolicies();
-    const policy = config?.policies?.[input.commandName];
-
-    if (!policy) {
-      throw new TRPCError({
-        code: 'NOT_FOUND',
-        message: `Policy not found: ${input.commandName}`,
-      });
-    }
-
-    if (!policy.allowHelp) {
-      return { stdout: '', stderr: 'This command does not support --help\n', exitCode: 1 };
-    }
-
-    const fullArgs = [...(policy.args || []), '--help'];
-    const { stdout, stderr, exitCode } = await executeSafe(policy.command, fullArgs, {
-      cwd: getWorkspaceRoot(),
-    });
-
-    return { stdout, stderr, exitCode };
-  });
-
-export const createPolicyRequest = apiProcedure
-  .input(
-    z.object({
-      commandName: z.string(),
-      args: z.array(z.string()),
-      fileMappings: z.record(z.string(), z.string()),
-    })
-  )
-  .mutation(async ({ input, ctx }) => {
-    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
-    const workspaceRoot = getWorkspaceRoot(process.cwd());
-    const snapshotDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'snapshots');
-    const store = new RequestStore(process.cwd());
-    const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
-    const service = new PolicyRequestService(store, agentDir, snapshotDir);
-
-    const chatId = ctx.tokenPayload.chatId;
-    const agentId = ctx.tokenPayload.agentId;
-
-    const config = await readPolicies();
-    const policy = config?.policies?.[input.commandName];
-
-    if (!policy) {
-      throw new TRPCError({
-        code: 'NOT_FOUND',
-        message: `Policy not found: ${input.commandName}`,
-      });
-    }
-
-    const isAutoApprove = !!policy.autoApprove;
-
-    const request = await service.createRequest(
-      input.commandName,
-      input.args,
-      input.fileMappings,
-      chatId,
-      agentId,
-      isAutoApprove,
-      ctx.tokenPayload.subagentId
-    );
-
-    if (isAutoApprove) {
-      const { stdout, stderr, exitCode, commandStr } = await executeRequest(
-        request,
-        policy,
-        getWorkspaceRoot()
-      );
-
-      request.executionResult = { stdout, stderr, exitCode };
-      await store.save(request);
-
-      const logMsg: PolicyRequestMessage = {
-        id: randomUUID(),
-        // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
-        messageId: randomUUID(),
-        role: 'policy',
-        requestId: request.id,
-        commandName: input.commandName,
-        args: input.args,
-        status: 'approved',
-        content: `[Auto-approved] Policy ${input.commandName} was executed.\n\nCommand: ${commandStr}\nExit Code: ${exitCode}\n\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
-        timestamp: new Date().toISOString(),
-        ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
-      };
-
-      await appendMessage(chatId, logMsg);
-      return request;
-    }
-
-    const previewContent = await generateRequestPreview(request);
-
-    const logMsg: PolicyRequestMessage = {
-      id: randomUUID(),
-      // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
-      messageId: randomUUID(),
-      role: 'policy',
-      requestId: request.id,
-      commandName: input.commandName,
-      args: input.args,
-      status: 'pending',
-      content: previewContent,
-      timestamp: new Date().toISOString(),
-      displayRole: 'agent',
-    };
-
-    await appendMessage(chatId, logMsg);
-    return request;
-  });
+import {
+  listPolicies,
+  executePolicyHelp,
+  createPolicyRequest,
+  readPolicyScript,
+} from './agent-policy-endpoints.js';
 
 import { ping } from './user-router.js';
 
@@ -325,6 +245,7 @@ export const agentRouter = router({
   listPolicies,
   executePolicyHelp,
   createPolicyRequest,
+  readPolicyScript,
   fetchPendingMessages,
   ping,
   subagentSpawn,