auto-mode 0.10.0 → 0.11.0

package/mods/auto-mode/hooks/register.claude-check.ts

@@ -1127,3 +1127,100 @@ test('it identifies a subprocess failure without copying the exception', async (
     'auto-mode action unavailable: manual approval retained; subprocess failure',
   ]);
 });
+
+test('it records a finished scope-creating Bash call with its result', async ($, on) => {
+  let invocation: unknown;
+  let stdin = '';
+
+  on('session.cwd', () => ({ value: '/repo' }));
+  on('classic.SessionStart', () => ({}));
+
+  on('tool.call', () => ({
+    result: { stdout: 'https://github.com/dev/app/pull/3\n', stderr: '' },
+    text: 'https://github.com/dev/app/pull/3\n',
+  }));
+
+  on('process.run', (_api, e) => {
+    invocation = e;
+    stdin = e.init?.stdin ?? '';
+
+    return {
+      value: {
+        exitCode: 0,
+        stdout: '',
+        stderr: '',
+        isStdoutTruncated: false,
+        isStderrTruncated: false,
+      },
+    };
+  });
+
+  // oxlint-disable-next-line new-cap -- The host event API retains its event spelling.
+  await $.classic.SessionStart({
+    source: 'startup',
+    session_id: 'session-1',
+    cwd: '/repo',
+    transcript_path: '/repo/transcript.jsonl',
+  });
+
+  const result = await $.tool.call({
+    tool: 'Bash',
+    tool_use_id: 'call-1',
+    command: 'gh pr create --fill',
+  });
+
+  expect(result).toMatchObject({ text: 'https://github.com/dev/app/pull/3\n' });
+
+  expect(invocation).toMatchObject({
+    argv: ['auto-mode', 'record'],
+    init: { timeoutMs: 8000, stdin: expect.any(String) },
+  });
+
+  expect(JSON.parse(stdin)).toStrictEqual({
+    sessionID: 'session-1',
+    cwd: '/repo',
+    startedAt: expect.any(Number),
+    command: 'gh pr create --fill',
+    resultText: 'https://github.com/dev/app/pull/3\n',
+  });
+});
+
+test('it records nothing for a Bash call that cannot create scope or a call that was denied', async ($, on) => {
+  let calls = 0;
+
+  on('session.cwd', () => ({ value: '/repo' }));
+  on('classic.SessionStart', () => ({}));
+
+  on('tool.call', (_api, e) =>
+    e.command === 'git checkout -b x'
+      ? { deny: 'no' }
+      : { result: { stdout: '', stderr: '' }, text: '' },
+  );
+
+  on('process.run', () => {
+    calls += 1;
+
+    return {
+      value: {
+        exitCode: 0,
+        stdout: '',
+        stderr: '',
+        isStdoutTruncated: false,
+        isStderrTruncated: false,
+      },
+    };
+  });
+
+  // oxlint-disable-next-line new-cap -- The host event API retains its event spelling.
+  await $.classic.SessionStart({
+    source: 'startup',
+    session_id: 'session-1',
+    cwd: '/repo',
+    transcript_path: '/repo/transcript.jsonl',
+  });
+
+  await $.tool.call({ tool: 'Bash', tool_use_id: 'call-1', command: 'bun test' });
+  await $.tool.call({ tool: 'Bash', tool_use_id: 'call-2', command: 'git checkout -b x' });
+
+  expect(calls).toBe(0);
+});

package/mods/auto-mode/hooks/register.ts

@@ -2,6 +2,15 @@ import { buildPromptContext } from './build-prompt-context.ts';
 import { parseDecision } from './parse-decision.ts';
 import type { ModOn, ModOptions, PromptContext } from './types.ts';
 
+// Commands that can create a worktree, a branch, or a PR. Any other call skips
+// the record subprocess, so ordinary calls pay nothing for the session scope.
+const SCOPE_COMMAND =
+  /\bgit\s[^\n]*?\b(?:worktree\s+add|checkout|switch|branch)\b|\bgh\s+pr\s+create\b/u;
+
+// The record may look up a created PR's head branch with gh, which the CLI
+// bounds at 5 seconds.
+const RECORD_TIMEOUT_MS = 8000;
+
 export function register(on: ModOn, options: ModOptions): void {
   let sessionID: string | null = null;
 
@@ -52,18 +61,43 @@ export function register(on: ModOn, options: ModOptions): void {
     return result;
   });
 
-  on('tool.call', async (_api, e, next) => {
+  on('tool.call', async ($, e, next) => {
     if (e.tool_use_id === undefined) {
       return next(e);
     }
 
     activeCalls.set(e.tool_use_id, e.agentId ?? null);
 
+    const command =
+      e.tool === 'Bash' && typeof e.command === 'string' && SCOPE_COMMAND.test(e.command)
+        ? e.command
+        : null;
+
+    const startedAt = Date.now();
+    const cwd = command === null || sessionID === null ? null : await $.session.cwd();
+    let result;
+
     try {
-      return await next(e);
+      result = await next(e);
     } finally {
       activeCalls.delete(e.tool_use_id);
     }
+
+    if (command !== null && cwd !== null && sessionID !== null && result.deny === undefined) {
+      const executable = typeof options.command === 'string' ? options.command : 'auto-mode';
+      const request = { sessionID, cwd, startedAt, command, resultText: result.text ?? '' };
+
+      try {
+        await $.process.run([executable, 'record'], {
+          timeoutMs: RECORD_TIMEOUT_MS,
+          stdin: JSON.stringify(request),
+        });
+      } catch {
+        $.ui.log('auto-mode: session scope not recorded; subprocess failure', { to: 'debug' });
+      }
+    }
+
+    return result;
   });
 
   on('tool.check', async ($, e, next) => {

package/mods/auto-mode/hooks/types.ts

@@ -35,6 +35,14 @@ interface CallInput {
   readonly tool: string;
   readonly tool_use_id?: string;
   readonly agentId?: string;
+  readonly command?: unknown;
+}
+
+interface CallResult {
+  readonly result?: unknown;
+  readonly deny?: string;
+  readonly text?: string;
+  readonly isError?: true;
 }
 
 export interface UserTask {
@@ -70,7 +78,7 @@ interface ModEvents {
     readonly input: SpawnInput;
     readonly result: { readonly agentId?: string; readonly model?: string; readonly deny?: string };
   };
-  readonly 'tool.call': { readonly input: CallInput; readonly result: object };
+  readonly 'tool.call': { readonly input: CallInput; readonly result: CallResult };
   readonly 'tool.check': { readonly input: CheckInput; readonly result: PermissionDecision };
   readonly 'process.run': {
     readonly input: ProcessInput;
@@ -100,7 +108,10 @@ export interface ModAPI {
     readonly run: (argv: readonly string[], init?: ProcessInput['init']) => Promise<ProcessResult>;
   };
   readonly prompt: { readonly submit: (input: PromptInput) => Promise<object> };
-  readonly tool: { readonly check: (input: CheckInput) => Promise<PermissionDecision> };
+  readonly tool: {
+    readonly check: (input: CheckInput) => Promise<PermissionDecision>;
+    readonly call: (input: CallInput) => Promise<CallResult>;
+  };
   readonly classic: {
     readonly SessionStart: (
       input: Partial<SessionContext> & { readonly source: string },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-mode",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A permission classifier library and Claude Code mod, so agents that are not Claude can run unattended",
   "keywords": [
     "agent",