feat(session): identify matched provision and add active-provisions panel

Tweak 1 — show which provision auto-accepted a request:
- Add findMatch(tool, invocations) and listProvisions() to permission-tracker vat
- Hook calls vatFindMatch after vatRoute returns 'allow' and passes the result
  to recordProvisioned, threading it through rpc.ts → session.record RPC →
  channel.record() → HistoryEntry.provision
- TUI: provisioned entries show '→ by provision: git log * | head *' (compact
  one-liner) instead of '→ standing provision'; detailed pattern block reserved
  for user-accepted-with-provision (◆) entries

Tweak 2 — active-provisions panel (P keybind):
- ProvisionsPanel component derives unique active provisions from session history
- Press P in session detail view to open; Esc to close
- Lists each provision as '◆ tool  name arg1 arg2 | name2 arg1'
- Status bar hint updated

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

Author: grypez

packages/caprock/bin/hook.ts

@@ -263,6 +263,31 @@ async function vatAddSection(
   });
 }
 
+/**
+ * Return the first provision that matches the given tool and invocations,
+ * or null if none match.
+ *
+ * @param rootKref - The vat's root kref.
+ * @param tool - The tool name.
+ * @param invocations - The parsed command components.
+ * @returns The matching provision, or null.
+ */
+async function vatFindMatch(
+  rootKref: string,
+  tool: string,
+  invocations: ParsedInvocation[],
+): Promise<Provision | null> {
+  const response = await sendCommand({
+    socketPath: SOCKET_PATH,
+    method: 'queueMessage',
+    params: [rootKref, 'findMatch', [tool, invocations]],
+  });
+  if (isJsonRpcFailure(response)) {
+    return null;
+  }
+  return decodeCapData(response.result as CapData) as Provision | null;
+}
+
 /**
  * Return the number of entries in the permission vat's allow set.
  *
@@ -518,14 +543,21 @@ async function onPreToolUse(payload: PreToolUsePayload): Promise<void> {
   });
 
   if (vatResponse === 'allow') {
-    if (state.kernelSessionId) {
+    if (state.kernelSessionId && invocations !== null) {
       const autoDescription = `Allow ${tool_name}(${JSON.stringify(tool_input)})`;
-      recordProvisioned(
-        SOCKET_PATH,
-        state.kernelSessionId,
-        autoDescription,
-        invocations === null ? undefined : { invocations },
-      ).catch(() => undefined);
+      vatFindMatch(state.rootKref, tool_name, invocations)
+        .then(async (matched) =>
+          recordProvisioned(
+            SOCKET_PATH,
+            state.kernelSessionId,
+            autoDescription,
+            {
+              invocations,
+              ...(matched === null ? {} : { provision: matched }),
+            },
+          ),
+        )
+        .catch(() => undefined);
     }
     process.stdout.write(JSON.stringify({ continue: true }));
     return;
@@ -556,7 +588,9 @@ async function onPreToolUse(payload: PreToolUsePayload): Promise<void> {
     if (!isNoSubscriber && errorStr.includes('Session not found')) {
       try {
         const ks = await createKernelSession(SOCKET_PATH, session_id);
+        // eslint-disable-next-line require-atomic-updates
         state.kernelSessionId = ks.sessionId;
+        // eslint-disable-next-line require-atomic-updates
         state.ocapUrl = ks.ocapUrl;
         await saveSessionState(session_id, state);
         connectId = ks.sessionId;

packages/caprock/src/rpc.ts

@@ -1,4 +1,7 @@
-import type { ParsedInvocation } from '@metamask/kernel-utils/session/provision';
+import type {
+  ParsedInvocation,
+  Provision,
+} from '@metamask/kernel-utils/session/provision';
 import type { JsonRpcResponse } from '@metamask/utils';
 import { assertIsJsonRpcResponse, isJsonRpcFailure } from '@metamask/utils';
 import { randomUUID } from 'node:crypto';
@@ -273,17 +276,21 @@ export async function authorizeRequest(
  * @param description - Human-readable description of the auto-accepted operation.
  * @param options - Optional parameters.
  * @param options.invocations - Parsed invocations to forward to the TUI.
+ * @param options.provision - The standing provision that approved the request.
  */
 export async function recordProvisioned(
   socketPath: string,
   sessionId: string,
   description: string,
-  options?: { invocations?: ParsedInvocation[] },
+  options?: { invocations?: ParsedInvocation[]; provision?: Provision },
 ): Promise<void> {
   const params: Record<string, unknown> = { sessionId, description };
   if (options?.invocations !== undefined) {
     params.invocations = options.invocations;
   }
+  if (options?.provision !== undefined) {
+    params.provision = options.provision;
+  }
   await sendCommand({ socketPath, method: 'session.record', params });
 }
 

packages/caprock/vat/permission-tracker.ts

@@ -22,7 +22,11 @@ import type {
   Provision,
   ParsedInvocation,
 } from '@metamask/kernel-utils/session';
-import { computeAuthority, matchPattern } from '@metamask/kernel-utils/session';
+import {
+  computeAuthority,
+  matchPattern,
+  matchProvision,
+} from '@metamask/kernel-utils/session';
 import {
   constant,
   leastAuthority,
@@ -162,6 +166,32 @@ export function buildRootObject(): ReturnType<typeof makeDefaultExo> {
       rebuildSection();
     },
 
+    /**
+     * Return the first provision that matches the given tool and invocations,
+     * or null if none match.
+     *
+     * @param tool - The tool name.
+     * @param invocations - The parsed command components.
+     * @returns The matching provision, or null.
+     */
+    findMatch(tool: string, invocations: ParsedInvocation[]): Provision | null {
+      for (const { provision } of sectionRecords) {
+        if (matchProvision(provision, tool, invocations)) {
+          return provision;
+        }
+      }
+      return null;
+    },
+
+    /**
+     * Return all provisions currently in the sheaf.
+     *
+     * @returns Array of provisions, oldest first.
+     */
+    listProvisions(): Provision[] {
+      return sectionRecords.map(({ provision }) => provision);
+    },
+
     /**
      * Return the current section count (for session_end stats).
      *

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

@@ -325,10 +325,14 @@ async function handleSessionRequest(
         const invocations = Array.isArray(args.invocations)
           ? (args.invocations as ParsedInvocation[])
           : undefined;
-        session.recordProvisioned(
-          description,
-          invocations === undefined ? undefined : { invocations },
-        );
+        const provision =
+          typeof args.provision === 'object' && args.provision !== null
+            ? (args.provision as Provision)
+            : undefined;
+        session.recordProvisioned(description, {
+          ...ifDefined({ invocations }),
+          ...ifDefined({ provision }),
+        });
         return ok(null);
       }