feat(session): surface provisioned requests in TUI timeline

Add a 'provisioned' status for auto-accepted requests and expose the
standing provision that was set by the user when accepting with keybind 2.

- `SessionHistoryEntry` gains status 'provisioned' and optional `provision` field
- `Channel.record()` inserts a pre-decided entry without blocking subscribers
- `Session.recordProvisioned()` records an auto-accepted request synchronously
- `session.record` RPC dispatches to `recordProvisioned` in the daemon
- hook fires-and-forgets `recordProvisioned` when the vat returns 'allow'
- TUI: ◆ for user-accepted-with-provision, → for auto-provisioned
- TUI: expanded view shows provision patterns; provisioned entries show '→ standing provision' instead of decided time

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: grypez

packages/caprock/bin/hook.ts

@@ -38,6 +38,7 @@ import {
   decodeCapData,
   createKernelSession,
   authorizeRequest,
+  recordProvisioned,
 } from '../src/rpc.ts';
 import {
   loadSessionState,
@@ -517,6 +518,15 @@ async function onPreToolUse(payload: PreToolUsePayload): Promise<void> {
   });
 
   if (vatResponse === 'allow') {
+    if (state.kernelSessionId) {
+      const autoDescription = `Allow ${tool_name}(${JSON.stringify(tool_input)})`;
+      recordProvisioned(
+        SOCKET_PATH,
+        state.kernelSessionId,
+        autoDescription,
+        invocations === null ? undefined : { invocations },
+      ).catch(() => undefined);
+    }
     process.stdout.write(JSON.stringify({ continue: true }));
     return;
   }

packages/caprock/src/rpc.ts

@@ -265,6 +265,28 @@ export async function authorizeRequest(
   return response.result as Decision;
 }
 
+/**
+ * Record a request that was auto-accepted by a standing provision.
+ *
+ * @param socketPath - The UNIX socket path.
+ * @param sessionId - The kernel session ID.
+ * @param description - Human-readable description of the auto-accepted operation.
+ * @param options - Optional parameters.
+ * @param options.invocations - Parsed invocations to forward to the TUI.
+ */
+export async function recordProvisioned(
+  socketPath: string,
+  sessionId: string,
+  description: string,
+  options?: { invocations?: ParsedInvocation[] },
+): Promise<void> {
+  const params: Record<string, unknown> = { sessionId, description };
+  if (options?.invocations !== undefined) {
+    params.invocations = options.invocations;
+  }
+  await sendCommand({ socketPath, method: 'session.record', params });
+}
+
 /**
  * Decode a CapData body to a JavaScript value.
  *

packages/kernel-node-runtime/src/daemon/rpc-socket-server.test.ts

@@ -73,6 +73,7 @@ function makeTestSession(overrides: Partial<Session> = {}): Session {
       verdict: 'accept' as const,
       feedback: '',
     }),
+    recordProvisioned: vi.fn(),
     subscribe: vi.fn(),
     ...overrides,
   };
@@ -343,6 +344,38 @@ describe('startRpcSocketServer — session.* methods', () => {
     });
   });
 
+  it('session.record calls recordProvisioned with description and invocations', async () => {
+    const { startRpcSocketServer } = await import('./rpc-socket-server.ts');
+    const socketPath = makeSocketPath();
+    const existing = makeTestSession({
+      sessionId: 'alice',
+      ocapUrl: 'ocap://alice',
+      startedAt: '2026-01-01T00:00:00.000Z',
+    });
+    const registry = makeTestRegistry([existing]);
+
+    handle = await startRpcSocketServer({
+      socketPath,
+      kernel: {} as never,
+      kernelDatabase: { executeQuery: vi.fn() } as never,
+      channelFactory: {} as never,
+      sessionRegistry: registry,
+    });
+
+    const invocations = [{ name: 'git', argv: ['status'] }];
+    const response = await sendRequest(socketPath, 'session.record', {
+      sessionId: 'alice',
+      description: 'Allow Bash({"command":"git status"})',
+      invocations,
+    });
+
+    expect(response.result).toBeNull();
+    expect(existing.recordProvisioned).toHaveBeenCalledWith(
+      'Allow Bash({"command":"git status"})',
+      { invocations },
+    );
+  });
+
   it('session.authorize returns the decision from authorizeRequest()', async () => {
     const { startRpcSocketServer } = await import('./rpc-socket-server.ts');
     const socketPath = makeSocketPath();

packages/kernel-node-runtime/src/daemon/rpc-socket-server.ts

@@ -316,6 +316,22 @@ async function handleSessionRequest(
         return ok(decision);
       }
 
+      case 'session.record': {
+        const session = requireSession(args.sessionId);
+        const description =
+          typeof args.description === 'string'
+            ? args.description
+            : 'Auto-accepted request';
+        const invocations = Array.isArray(args.invocations)
+          ? (args.invocations as ParsedInvocation[])
+          : undefined;
+        session.recordProvisioned(
+          description,
+          invocations === undefined ? undefined : { invocations },
+        );
+        return ok(null);
+      }
+
       case 'session.decide': {
         const session = requireSession(args.sessionId);
         const { token } = args;

packages/kernel-tui/src/components/session-detail-view.tsx

@@ -29,6 +29,7 @@ const STATUS_ICON: Record<SessionHistoryEntry['status'], string> = {
   pending: '…',
   accepted: '✓',
   rejected: '✗',
+  provisioned: '→',
 };
 
 const STATUS_COLOR: Record<
@@ -38,6 +39,7 @@ const STATUS_COLOR: Record<
   pending: 'yellow',
   accepted: 'green',
   rejected: 'red',
+  provisioned: 'green',
 };
 
 /**
@@ -339,9 +341,12 @@ function entryRowCount(
   const contentRows = contentLines.reduce((sum, line) => {
     return sum + Math.max(1, Math.ceil(line.length / effectiveWidth));
   }, 0);
+  const provisionRows =
+    entry.provision === undefined ? 0 : 1 + entry.provision.patterns.length;
   const extras =
     (entry.decidedAt === undefined ? 0 : 1) +
-    (entry.guard.body === '#{}' ? 0 : 1);
+    (entry.guard.body === '#{}' ? 0 : 1) +
+    provisionRows;
   return 1 + contentRows + extras;
 }
 
@@ -819,8 +824,12 @@ export function SessionDetailView({
           const isExpanded = expanded.has(entry.token);
           const isEditingThis =
             editingProvision && isFocused && entry.status === 'pending';
-          const icon = STATUS_ICON[entry.status];
+          const icon =
+            entry.status === 'accepted' && entry.provision !== undefined
+              ? '◆'
+              : STATUS_ICON[entry.status];
           const color = STATUS_COLOR[entry.status];
+          const isDimStatus = entry.status === 'provisioned';
 
           const { label } = parseDescription(entry.description);
 
@@ -838,7 +847,9 @@ export function SessionDetailView({
             <Box key={entry.token} flexDirection="column" marginTop={0}>
               <Box gap={1}>
                 <Text>{isFocused ? '►' : ' '}</Text>
-                <Text color={color}>{icon}</Text>
+                <Text color={color} dimColor={isDimStatus}>
+                  {icon}
+                </Text>
                 <Text color="cyan" dimColor>
                   {formatTime(entry.queuedAt)}
                 </Text>
@@ -866,7 +877,32 @@ export function SessionDetailView({
               ))}
               {isExpanded &&
                 !isEditingThis &&
-                entry.decidedAt !== undefined && (
+                entry.provision !== undefined && (
+                  <Box paddingLeft={4} flexDirection="column">
+                    <Text dimColor>provision:</Text>
+                    {entry.provision.patterns.map((pattern, patIdx) => (
+                      <Box key={patIdx} paddingLeft={2} gap={1} flexWrap="wrap">
+                        <Text color="yellow">{pattern.name}</Text>
+                        {pattern.argPatterns.map((argPat, argIdx) => (
+                          <Text key={argIdx} dimColor>
+                            {argPatternDisplay(argPat)}
+                          </Text>
+                        ))}
+                      </Box>
+                    ))}
+                  </Box>
+                )}
+              {isExpanded &&
+                !isEditingThis &&
+                entry.status === 'provisioned' && (
+                  <Box paddingLeft={4}>
+                    <Text dimColor>→ standing provision</Text>
+                  </Box>
+                )}
+              {isExpanded &&
+                !isEditingThis &&
+                entry.decidedAt !== undefined &&
+                entry.status !== 'provisioned' && (
                   <Box paddingLeft={4}>
                     <Text dimColor>decided {formatTime(entry.decidedAt)}</Text>
                   </Box>

packages/kernel-utils/src/session/channel.ts

@@ -4,6 +4,7 @@ import type { PromiseKit } from '@endo/promise-kit';
 import { ifDefined } from '../misc.ts';
 import type {
   Decision,
+  Provision,
   SectionNotification,
   SessionHistoryEntry,
 } from './types.ts';
@@ -63,6 +64,14 @@ export type Channel = {
    * @param decision - The decision to apply.
    */
   decide(decision: Decision): void;
+
+  /**
+   * Record a notification as already decided by a standing provision, without
+   * routing it through `pending` or notifying subscribers.
+   *
+   * @param notification - The section notification to record.
+   */
+  record(notification: SectionNotification): void;
 };
 
 type PendingEntry = {
@@ -74,8 +83,9 @@ type PendingEntry = {
 type HistoryEntry = {
   notification: SectionNotification;
   queuedAt: string;
-  verdict: 'accepted' | 'rejected';
+  verdict: 'accepted' | 'rejected' | 'provisioned';
   decidedAt: string;
+  provision?: Provision;
 };
 
 /**
@@ -110,6 +120,7 @@ export function makeChannel(): Channel {
       queuedAt: entry.queuedAt,
       verdict: decision.verdict === 'accept' ? 'accepted' : 'rejected',
       decidedAt: new Date().toISOString(),
+      ...ifDefined({ provision: decision.provision }),
     });
     entry.kit.resolve(decision);
   }
@@ -183,6 +194,7 @@ export function makeChannel(): Channel {
         status: hist.verdict,
         decidedAt: hist.decidedAt,
         ...ifDefined({ invocations: hist.notification.invocations }),
+        ...ifDefined({ provision: hist.provision }),
       }));
       const stillPending: SessionHistoryEntry[] = Array.from(
         pending.values(),
@@ -209,5 +221,15 @@ export function makeChannel(): Channel {
     decide(decision: Decision): void {
       routeDecision(decision);
     },
+
+    record(notification: SectionNotification): void {
+      const stamp = new Date().toISOString();
+      history.push({
+        notification,
+        queuedAt: stamp,
+        verdict: 'provisioned',
+        decidedAt: stamp,
+      });
+    },
   });
 }

packages/kernel-utils/src/session/session-registry.test.ts

@@ -155,6 +155,27 @@ describe('makeSessionRegistry', () => {
     expect(result).toStrictEqual(decision);
   });
 
+  it('recordProvisioned adds a provisioned entry to history', async () => {
+    const registry = makeSessionRegistry(makeChannelBundle());
+    const session = await registry.createSession();
+
+    session.recordProvisioned('Allow Bash({"command":"git status"})', {
+      invocations: [{ name: 'git', argv: ['status'] }],
+    });
+
+    const history = session.listHistory();
+    expect(history).toHaveLength(1);
+    expect(history[0]).toMatchObject({
+      description: 'Allow Bash({"command":"git status"})',
+      reason: 'Auto-accepted by provision',
+      status: 'provisioned',
+      invocations: [{ name: 'git', argv: ['status'] }],
+    });
+    expect(typeof history[0]?.token).toBe('string');
+    expect(typeof history[0]?.queuedAt).toBe('string');
+    expect(history[0]?.queuedAt).toBe(history[0]?.decidedAt);
+  });
+
   it('authorizeRequest rejects with timeout error after timeoutMs elapses', async () => {
     vi.useFakeTimers();
     try {

packages/kernel-utils/src/session/session-registry.ts

@@ -35,6 +35,10 @@ export type Session = {
       invocations?: ParsedInvocation[];
     },
   ): Promise<Decision>;
+  recordProvisioned(
+    description: string,
+    options?: { invocations?: ParsedInvocation[] },
+  ): void;
   subscribe(stream: ModalStream): void;
 };
 
@@ -141,6 +145,18 @@ function makeSession(
       ]);
     },
 
+    recordProvisioned(
+      description: string,
+      options: { invocations?: ParsedInvocation[] } = {},
+    ): void {
+      const notification = makeNotification(
+        description,
+        'Auto-accepted by provision',
+        options.invocations,
+      );
+      channel.record(notification);
+    },
+
     subscribe(stream: ModalStream): void {
       channel.subscribe(stream);
     },

packages/kernel-utils/src/session/types.ts

@@ -109,10 +109,12 @@ export type SessionHistoryEntry = {
   reason: string;
   guard: { body: string; slots: string[] };
   queuedAt: string;
-  status: 'pending' | 'accepted' | 'rejected';
+  status: 'pending' | 'accepted' | 'rejected' | 'provisioned';
   decidedAt?: string;
   /** Parsed invocations — present when routed through the PreToolUse hook. */
   invocations?: ParsedInvocation[];
+  /** Standing provision that was granted — present when the user accepted with a provision. */
+  provision?: Provision;
 };
 
 /**