@scotthuang/agent-knock-knock 0.2.47 → 0.2.49

package/dist/src/terminal-agent-bridge.d.ts

@@ -18,6 +18,7 @@ export interface TerminalBridgeStatus {
         label?: string;
         prompt_kind?: string;
         command?: string;
+        cwd?: string;
         tool_name?: string;
         request_detail?: string;
         reason?: string;
@@ -27,6 +28,8 @@ export interface TerminalBridgeStatus {
     };
     screen: {
         excerpt?: string;
+        /** SHA-256 of the raw capture. The raw terminal contents are never exposed here. */
+        digest?: string;
         approval?: Record<string, unknown>;
         error?: string;
     };
@@ -49,6 +52,7 @@ export interface TerminalApprovalExecution {
     label?: string;
     promptKind?: string;
     command?: string;
+    cwd?: string;
     toolName?: string;
     requestDetail?: string;
     fingerprint?: string;
@@ -56,6 +60,34 @@ export interface TerminalApprovalExecution {
     decisionMode?: "keys" | "structured";
     requestId?: string;
 }
+export interface TerminalIdentityVerificationRequest {
+    agent: ExecutorKind;
+    pid: number;
+    terminalControl: TerminalControlRef;
+}
+export interface TerminalIdentityVerificationResult {
+    terminalControl?: TerminalControlRef;
+}
+export type TerminalIdentityVerifier = (request: TerminalIdentityVerificationRequest) => Promise<TerminalIdentityVerificationResult | void>;
+export interface TerminalApprovalAuthorizationContext {
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    inspection: TerminalScreenInspection;
+    fingerprint?: string;
+    runtime?: TerminalRuntimeIdentity;
+}
+export interface TerminalApprovalAuthorizationDecision {
+    approved: boolean;
+    reason?: string;
+}
+export interface TerminalApprovalKeyDispatchContext {
+    agent: ExecutorKind;
+    terminalControl: TerminalControlRef;
+    inspection: TerminalScreenInspection;
+    fingerprint: string;
+    keys: readonly string[];
+    runtime?: TerminalRuntimeIdentity;
+}
 export interface TerminalMonitorPoll {
     status: TerminalBridgeStatus;
     inspection?: TerminalScreenInspection;
@@ -65,21 +97,27 @@ export interface TerminalMonitorPoll {
 export declare class TerminalAgentBridge {
     readonly registry: TerminalAgentAdapterRegistry;
     readonly terminalProvider: TerminalControlProvider;
+    private readonly verifyIdentity?;
     constructor(options: {
         registry: TerminalAgentAdapterRegistry;
         terminalProvider: TerminalControlProvider;
+        verifyIdentity?: TerminalIdentityVerifier;
     });
     adapterFor(agent: ExecutorKind | string): TerminalAgentAdapter;
     listProcesses(snapshots: readonly TerminalProcessSnapshot[], agents?: readonly ExecutorKind[]): Promise<ActiveTerminalProcess[]>;
     discoverProcesses(snapshots: readonly TerminalProcessSnapshot[], agents?: readonly ExecutorKind[]): Promise<ActiveTerminalProcess[]>;
-    attachProcesses<T extends ActiveTerminalProcess>(agent: ExecutorKind, processes: T[]): Promise<T[]>;
+    attachProcesses<T extends ActiveTerminalProcess>(agent: ExecutorKind, processes: T[], options?: {
+        processTree?: readonly TerminalProcessSnapshot[];
+    }): Promise<T[]>;
     terminalConversationId(process: Pick<ActiveTerminalProcess, "agent" | "pid" | "terminalControl">): string;
     resolveConversationId(conversationId: string | undefined): Promise<ResolvedTerminalConversation | undefined>;
     status(agent: ExecutorKind, terminalControl: TerminalControlRef, options?: {
         scrollbackLines?: number;
         runtime?: TerminalRuntimeIdentity;
     }): Promise<TerminalBridgeStatus>;
-    send(agent: ExecutorKind, terminalControl: TerminalControlRef, text: string): Promise<void>;
+    send(agent: ExecutorKind, terminalControl: TerminalControlRef, text: string, options?: {
+        runtime?: TerminalRuntimeIdentity;
+    }): Promise<void>;
     cancel(agent: ExecutorKind, terminalControl: TerminalControlRef, options?: {
         runtime?: TerminalRuntimeIdentity;
         scrollbackLines?: number;
@@ -96,6 +134,12 @@ export declare class TerminalAgentBridge {
         scrollbackLines?: number;
         runtime?: TerminalRuntimeIdentity;
         requiredDecisionMode?: "keys" | "structured";
+        authorize?: (context: TerminalApprovalAuthorizationContext) => TerminalApprovalAuthorizationDecision | Promise<TerminalApprovalAuthorizationDecision>;
+        /**
+         * Persist an at-most-once dispatch reservation after final prompt/identity validation
+         * and immediately before tmux receives the approval keys.
+         */
+        beforeKeyDispatch?: (context: TerminalApprovalKeyDispatchContext) => void | Promise<void>;
     }): Promise<TerminalApprovalExecution>;
     monitorPoll(options: {
         agent: ExecutorKind;
@@ -110,5 +154,9 @@ export declare class TerminalAgentBridge {
         durableRequest?: TerminalDurableCompletionRequest;
     }): Promise<TerminalMonitorPoll>;
     private captureInspection;
+    private verifyTerminalIdentity;
 }
-export declare function terminalApprovalFingerprint(agent: ExecutorKind, terminalControl: Pick<TerminalControlRef, "target">, inspection: TerminalScreenInspection): string | undefined;
+export declare function terminalApprovalFingerprint(agent: ExecutorKind, terminalControl: TerminalControlRef, inspection: TerminalScreenInspection, options?: {
+    screen?: string;
+    runtime?: TerminalRuntimeIdentity;
+}): string | undefined;

package/dist/src/terminal-agent-bridge.js

@@ -4,9 +4,11 @@ import { enrichActiveProcessesWithTerminalControl, terminalRefFromPane } from ".
 export class TerminalAgentBridge {
     registry;
     terminalProvider;
+    verifyIdentity;
     constructor(options) {
         this.registry = options.registry;
         this.terminalProvider = options.terminalProvider;
+        this.verifyIdentity = options.verifyIdentity;
     }
     adapterFor(agent) {
         return this.registry.require(agent);
@@ -24,17 +26,21 @@ export class TerminalAgentBridge {
                 .map((snapshot) => adapter.classifyProcess(snapshot))
                 .filter((process) => process !== undefined)
                 .map((process) => ({ ...process, agent: adapter.agent }));
-            discovered.push(...await this.attachProcesses(adapter.agent, classified));
+            discovered.push(...await enrichActiveProcessesWithTerminalControl(classified, this.terminalProvider, {
+                capabilities: terminalControlCapabilitiesForAdapter(adapter),
+                processTree: snapshots
+            }));
         }
         return discovered;
     }
     async discoverProcesses(snapshots, agents) {
         return this.listProcesses(snapshots, agents);
     }
-    async attachProcesses(agent, processes) {
+    async attachProcesses(agent, processes, options = {}) {
         const adapter = this.registry.require(agent);
         return enrichActiveProcessesWithTerminalControl(processes, this.terminalProvider, {
-            capabilities: terminalControlCapabilitiesForAdapter(adapter)
+            capabilities: terminalControlCapabilitiesForAdapter(adapter),
+            processTree: options.processTree
         });
     }
     terminalConversationId(process) {
@@ -55,17 +61,35 @@ export class TerminalAgentBridge {
         }
         const adapter = this.registry.require(parsed.agent);
         const panes = await this.terminalProvider.listPanes();
-        const pane = panes.find((candidate) => candidate.kind === parsed.kind && candidate.target === parsed.target);
-        if (!pane) {
+        const candidates = panes.filter((candidate) => candidate.kind === parsed.kind && candidate.target === parsed.target);
+        const verified = this.verifyIdentity
+            ? (await Promise.all(candidates.map(async (pane) => {
+                const terminalControl = terminalRefFromPane(pane, terminalControlCapabilitiesForAdapter(adapter));
+                try {
+                    const verifiedTerminalControl = await this.verifyTerminalIdentity(adapter.agent, terminalControl, { pid: parsed.pid });
+                    return { pane, terminalControl: verifiedTerminalControl };
+                }
+                catch {
+                    return undefined;
+                }
+            }))).filter((candidate) => candidate !== undefined)
+            : candidates.slice(0, 1).map((pane) => ({
+                pane,
+                terminalControl: terminalRefFromPane(pane, terminalControlCapabilitiesForAdapter(adapter))
+            }));
+        if (verified.length === 0) {
             throw new Error(`terminal-controlled session ${parsed.conversationId} is no longer available`);
         }
+        if (verified.length > 1) {
+            throw new Error(`terminal-controlled session ${parsed.conversationId} matches multiple active panes`);
+        }
         return {
             conversationId: parsed.conversationId,
             agent: parsed.agent,
             pid: parsed.pid,
             legacy: parsed.legacy,
             adapter,
-            terminalControl: terminalRefFromPane(pane, terminalControlCapabilitiesForAdapter(adapter))
+            terminalControl: verified[0].terminalControl
         };
     }
     async status(agent, terminalControl, options = {}) {
@@ -75,8 +99,11 @@ export class TerminalAgentBridge {
             return unsupportedScreenStatus(adapter, terminalControl);
         }
         try {
-            const { inspection } = await this.captureInspection(adapter, terminalControl, options);
-            return statusFromInspection(adapter, terminalControl, inspection);
+            const captured = await this.captureInspection(adapter, terminalControl, options);
+            return statusFromInspection(adapter, captured.terminalControl, captured.inspection, {
+                screen: captured.screen,
+                runtime: options.runtime
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -98,7 +125,7 @@ export class TerminalAgentBridge {
             };
         }
     }
-    async send(agent, terminalControl, text) {
+    async send(agent, terminalControl, text, options = {}) {
         const adapter = this.registry.require(agent);
         if (!terminalControl.capabilities.includes("send_keys")) {
             throw new Error(`${adapter.displayName} terminal input is not supported`);
@@ -107,11 +134,29 @@ export class TerminalAgentBridge {
         if (!normalized) {
             throw new Error("terminal message is empty");
         }
-        await this.terminalProvider.sendText(terminalControl.target, normalized, {
-            socketPath: terminalControl.socketPath
+        const verifiedForText = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
+        await this.terminalProvider.sendText(verifiedForText.target, normalized, {
+            socketPath: verifiedForText.socketPath
         });
-        await this.terminalProvider.sendKeys(terminalControl.target, ["C-m"], {
-            socketPath: terminalControl.socketPath
+        // Text and Enter are separate tmux operations. Revalidate between them; if the
+        // identity changed, clear the line best-effort and never submit it.
+        let verifiedForEnter;
+        try {
+            verifiedForEnter = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
+        }
+        catch (error) {
+            try {
+                await this.terminalProvider.sendKeys(verifiedForText.target, ["C-u"], {
+                    socketPath: verifiedForText.socketPath
+                });
+            }
+            catch {
+                // Best effort only: preserving the identity failure is more important than cleanup.
+            }
+            throw error;
+        }
+        await this.terminalProvider.sendKeys(verifiedForEnter.target, ["C-m"], {
+            socketPath: verifiedForEnter.socketPath
         });
     }
     async cancel(agent, terminalControl, options = {}) {
@@ -121,15 +166,20 @@ export class TerminalAgentBridge {
             terminalControl.capabilities.includes("terminal_approval") &&
             adapter.capabilities.screenStatus &&
             terminalControl.capabilities.includes("screen_status")) {
-            const { inspection } = await this.captureInspection(adapter, terminalControl, options);
+            const captured = await this.captureInspection(adapter, terminalControl, options);
+            const { inspection } = captured;
             if (inspection.approval.approvable && inspection.approval.action.mode === "structured") {
-                const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, inspection);
+                const fingerprint = terminalApprovalFingerprint(adapter.agent, captured.terminalControl, inspection, {
+                    screen: captured.screen,
+                    runtime: options.runtime
+                });
                 if (!fingerprint) {
                     return {
                         cancelRequested: false,
                         reason: `${adapter.displayName} structured approval has no fingerprint`
                     };
                 }
+                await this.verifyTerminalIdentity(adapter.agent, captured.terminalControl, options.runtime);
                 const decision = await adapter.resolveApproval({
                     decision: "deny",
                     expectedFingerprint: fingerprint,
@@ -160,8 +210,9 @@ export class TerminalAgentBridge {
                 reason: `${adapter.displayName} terminal cancellation is not supported`
             };
         }
-        await this.terminalProvider.sendKeys(terminalControl.target, adapter.cancelKeys, {
-            socketPath: terminalControl.socketPath
+        const verifiedForCancel = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
+        await this.terminalProvider.sendKeys(verifiedForCancel.target, adapter.cancelKeys, {
+            socketPath: verifiedForCancel.socketPath
         });
         return {
             cancelRequested: true,
@@ -179,7 +230,9 @@ export class TerminalAgentBridge {
                 reason: `${adapter.displayName} terminal approval is not supported`
             };
         }
-        const { inspection } = await this.captureInspection(adapter, terminalControl, options);
+        const captured = await this.captureInspection(adapter, terminalControl, options);
+        const { inspection } = captured;
+        const activeTerminalControl = captured.terminalControl;
         if (!inspection.approval.approvable) {
             return {
                 approved: false,
@@ -199,7 +252,10 @@ export class TerminalAgentBridge {
                 label: inspection.approval.action.label,
                 promptKind: inspection.approval.promptKind,
                 command: inspection.approval.command,
-                fingerprint: terminalApprovalFingerprint(adapter.agent, terminalControl, inspection),
+                fingerprint: terminalApprovalFingerprint(adapter.agent, activeTerminalControl, inspection, {
+                    screen: captured.screen,
+                    runtime: options.runtime
+                }),
                 screenExcerpt: inspection.screenExcerpt,
                 decisionMode,
                 requestId: inspection.approval.action.requestId
@@ -216,7 +272,33 @@ export class TerminalAgentBridge {
                 screenExcerpt: inspection.screenExcerpt
             };
         }
-        const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, inspection);
+        const fingerprint = terminalApprovalFingerprint(adapter.agent, activeTerminalControl, inspection, {
+            screen: captured.screen,
+            runtime: options.runtime
+        });
+        if (adapter.agent === "claude" &&
+            decisionMode === "keys" &&
+            !options.expectedFingerprint) {
+            return {
+                approved: false,
+                blocked: true,
+                reason: "screen approval requires the latest expected fingerprint",
+                key: inspection.approval.action.keys.length === 1
+                    ? inspection.approval.action.keys[0]
+                    : undefined,
+                keys: inspection.approval.action.keys,
+                label: inspection.approval.action.label,
+                promptKind: inspection.approval.promptKind,
+                command: inspection.approval.command,
+                cwd: inspection.approval.cwd,
+                toolName: inspection.approval.toolName,
+                requestDetail: inspection.approval.requestDetail,
+                fingerprint,
+                screenExcerpt: inspection.screenExcerpt,
+                decisionMode,
+                requestId: inspection.approval.action.requestId
+            };
+        }
         if (options.expectedFingerprint && options.expectedFingerprint !== fingerprint) {
             return {
                 approved: false,
@@ -235,6 +317,35 @@ export class TerminalAgentBridge {
                 requestId: inspection.approval.action.requestId
             };
         }
+        if (options.authorize) {
+            const authorization = await options.authorize({
+                agent: adapter.agent,
+                terminalControl: activeTerminalControl,
+                inspection,
+                fingerprint,
+                runtime: options.runtime
+            });
+            if (!authorization.approved) {
+                return {
+                    approved: false,
+                    blocked: true,
+                    reason: authorization.reason ?? "approval was not authorized",
+                    key: inspection.approval.action.keys.length === 1
+                        ? inspection.approval.action.keys[0]
+                        : undefined,
+                    keys: inspection.approval.action.keys,
+                    label: inspection.approval.action.label,
+                    promptKind: inspection.approval.promptKind,
+                    command: inspection.approval.command,
+                    toolName: inspection.approval.toolName,
+                    requestDetail: inspection.approval.requestDetail,
+                    fingerprint,
+                    screenExcerpt: inspection.screenExcerpt,
+                    decisionMode,
+                    requestId: inspection.approval.action.requestId
+                };
+            }
+        }
         if (decisionMode === "structured") {
             if (!options.expectedFingerprint) {
                 return {
@@ -261,6 +372,7 @@ export class TerminalAgentBridge {
                     requestId: inspection.approval.action.requestId
                 };
             }
+            await this.verifyTerminalIdentity(adapter.agent, activeTerminalControl, options.runtime);
             const resolved = await adapter.resolveApproval({
                 decision: "allow",
                 expectedFingerprint: options.expectedFingerprint,
@@ -281,21 +393,102 @@ export class TerminalAgentBridge {
                 requestId: resolved.requestId ?? inspection.approval.action.requestId
             };
         }
-        await this.terminalProvider.sendKeys(terminalControl.target, inspection.approval.action.keys, { socketPath: terminalControl.socketPath });
+        const recaptured = await this.captureInspection(adapter, activeTerminalControl, options);
+        const recapturedInspection = recaptured.inspection;
+        if (!recapturedInspection.approval.approvable) {
+            return {
+                approved: false,
+                blocked: true,
+                reason: "approval prompt is no longer approvable after authorization",
+                promptKind: recapturedInspection.approval.promptKind,
+                command: recapturedInspection.approval.command,
+                cwd: recapturedInspection.approval.cwd,
+                toolName: recapturedInspection.approval.toolName,
+                requestDetail: recapturedInspection.approval.requestDetail,
+                screenExcerpt: recapturedInspection.screenExcerpt
+            };
+        }
+        const recapturedDecisionMode = recapturedInspection.approval.action.mode ?? "keys";
+        const recapturedFingerprint = terminalApprovalFingerprint(adapter.agent, recaptured.terminalControl, recapturedInspection, {
+            screen: recaptured.screen,
+            runtime: options.runtime
+        });
+        if (recapturedDecisionMode !== decisionMode) {
+            return {
+                approved: false,
+                blocked: true,
+                reason: "approval decision mode changed after authorization",
+                key: recapturedInspection.approval.action.keys.length === 1
+                    ? recapturedInspection.approval.action.keys[0]
+                    : undefined,
+                keys: recapturedInspection.approval.action.keys,
+                label: recapturedInspection.approval.action.label,
+                promptKind: recapturedInspection.approval.promptKind,
+                command: recapturedInspection.approval.command,
+                cwd: recapturedInspection.approval.cwd,
+                toolName: recapturedInspection.approval.toolName,
+                requestDetail: recapturedInspection.approval.requestDetail,
+                fingerprint: recapturedFingerprint,
+                screenExcerpt: recapturedInspection.screenExcerpt,
+                decisionMode: recapturedDecisionMode,
+                requestId: recapturedInspection.approval.action.requestId
+            };
+        }
+        if (recapturedFingerprint !== fingerprint) {
+            return {
+                approved: false,
+                blocked: true,
+                reason: "approval fingerprint changed after authorization",
+                key: recapturedInspection.approval.action.keys.length === 1
+                    ? recapturedInspection.approval.action.keys[0]
+                    : undefined,
+                keys: recapturedInspection.approval.action.keys,
+                label: recapturedInspection.approval.action.label,
+                promptKind: recapturedInspection.approval.promptKind,
+                command: recapturedInspection.approval.command,
+                cwd: recapturedInspection.approval.cwd,
+                toolName: recapturedInspection.approval.toolName,
+                requestDetail: recapturedInspection.approval.requestDetail,
+                fingerprint: recapturedFingerprint,
+                screenExcerpt: recapturedInspection.screenExcerpt,
+                decisionMode: recapturedDecisionMode,
+                requestId: recapturedInspection.approval.action.requestId
+            };
+        }
+        const verifiedForApproval = await this.verifyTerminalIdentity(adapter.agent, recaptured.terminalControl, options.runtime);
+        if (!recapturedFingerprint) {
+            return {
+                approved: false,
+                blocked: true,
+                reason: "approval has no dispatch fingerprint",
+                screenExcerpt: recapturedInspection.screenExcerpt,
+                decisionMode: recapturedDecisionMode
+            };
+        }
+        await options.beforeKeyDispatch?.({
+            agent: adapter.agent,
+            terminalControl: verifiedForApproval,
+            inspection: recapturedInspection,
+            fingerprint: recapturedFingerprint,
+            keys: recapturedInspection.approval.action.keys,
+            runtime: options.runtime
+        });
+        await this.terminalProvider.sendKeys(verifiedForApproval.target, recapturedInspection.approval.action.keys, { socketPath: verifiedForApproval.socketPath });
         return {
             approved: true,
             blocked: false,
-            key: inspection.approval.action.keys.length === 1
-                ? inspection.approval.action.keys[0]
+            key: recapturedInspection.approval.action.keys.length === 1
+                ? recapturedInspection.approval.action.keys[0]
                 : undefined,
-            keys: inspection.approval.action.keys,
-            label: inspection.approval.action.label,
-            promptKind: inspection.approval.promptKind,
-            command: inspection.approval.command,
-            fingerprint,
-            screenExcerpt: inspection.screenExcerpt,
-            decisionMode,
-            requestId: inspection.approval.action.requestId
+            keys: recapturedInspection.approval.action.keys,
+            label: recapturedInspection.approval.action.label,
+            promptKind: recapturedInspection.approval.promptKind,
+            command: recapturedInspection.approval.command,
+            cwd: recapturedInspection.approval.cwd,
+            fingerprint: recapturedFingerprint,
+            screenExcerpt: recapturedInspection.screenExcerpt,
+            decisionMode: recapturedDecisionMode,
+            requestId: recapturedInspection.approval.action.requestId
         };
     }
     async monitorPoll(options) {
@@ -307,7 +500,10 @@ export class TerminalAgentBridge {
             try {
                 const captured = await this.captureInspection(adapter, options.terminalControl, options.screenOptions);
                 inspection = captured.inspection;
-                status = statusFromInspection(adapter, options.terminalControl, inspection);
+                status = statusFromInspection(adapter, captured.terminalControl, inspection, {
+                    screen: captured.screen,
+                    runtime: options.screenOptions?.runtime
+                });
             }
             catch (error) {
                 status = failedScreenStatus(adapter, options.terminalControl, error);
@@ -346,11 +542,13 @@ export class TerminalAgentBridge {
         };
     }
     async captureInspection(adapter, terminalControl, options = {}) {
-        const screen = await this.terminalProvider.capture(terminalControl.target, {
+        const verifiedTerminalControl = await this.verifyTerminalIdentity(adapter.agent, terminalControl, options.runtime);
+        const screen = await this.terminalProvider.capture(verifiedTerminalControl.target, {
             scrollbackLines: options.scrollbackLines ?? 120,
-            socketPath: terminalControl.socketPath
+            socketPath: verifiedTerminalControl.socketPath
         });
         return {
+            terminalControl: verifiedTerminalControl,
             screen,
             inspection: adapter.inspectScreen({
                 screen,
@@ -361,32 +559,65 @@ export class TerminalAgentBridge {
             })
         };
     }
+    async verifyTerminalIdentity(agent, terminalControl, runtime) {
+        if (!this.verifyIdentity) {
+            return terminalControl;
+        }
+        if (!Number.isInteger(runtime?.pid) || Number(runtime?.pid) <= 0) {
+            throw new Error(`refusing terminal access for ${agent}:${terminalControl.target} without an exact agent pid; reattach this legacy tmux session before controlling it`);
+        }
+        const result = await this.verifyIdentity({
+            agent,
+            pid: Number(runtime?.pid),
+            terminalControl
+        });
+        return result?.terminalControl ?? terminalControl;
+    }
 }
-export function terminalApprovalFingerprint(agent, terminalControl, inspection) {
+export function terminalApprovalFingerprint(agent, terminalControl, inspection, options = {}) {
     if (!inspection.approval.approvable) {
         return undefined;
     }
     const decisionMode = inspection.approval.action.mode ?? "keys";
+    const rawScreenDigest = decisionMode === "keys" && options.screen !== undefined
+        ? createHash("sha256").update(options.screen).digest("hex")
+        : undefined;
     return createHash("sha256")
         .update(JSON.stringify({
         agent,
         provider: "tmux",
-        target: terminalControl.target,
+        terminal: {
+            target: terminalControl.target,
+            socket_path: terminalControl.socketPath,
+            session: terminalControl.session,
+            window: terminalControl.window,
+            pane: terminalControl.pane,
+            pane_pid: terminalControl.panePid
+        },
+        runtime: {
+            pid: options.runtime?.pid,
+            session_id: options.runtime?.sessionId,
+            cwd: options.runtime?.cwd,
+            conversation_id: options.runtime?.conversationId,
+            message_id: options.runtime?.messageId,
+            terminal_target: options.runtime?.terminalTarget
+        },
         keys: inspection.approval.action.keys,
         label: inspection.approval.action.label,
         prompt_kind: inspection.approval.promptKind,
         command: inspection.approval.command,
+        cwd: inspection.approval.cwd,
         tool_name: inspection.approval.toolName,
         request_detail: inspection.approval.requestDetail,
-        screen_excerpt: decisionMode === "structured" ? undefined : inspection.screenExcerpt,
+        raw_screen_sha256: rawScreenDigest,
         decision_mode: decisionMode,
         request_id: inspection.approval.action.requestId
     }))
         .digest("hex");
 }
-function statusFromInspection(adapter, terminalControl, inspection) {
+function statusFromInspection(adapter, terminalControl, inspection, options = {}) {
     const approval = inspection.approval;
-    const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, inspection);
+    const fingerprint = terminalApprovalFingerprint(adapter.agent, terminalControl, inspection, options);
     return {
         provider: terminalControl.kind,
         target: terminalControl.target,
@@ -406,6 +637,7 @@ function statusFromInspection(adapter, terminalControl, inspection) {
             label: approval.approvable ? approval.action.label : undefined,
             prompt_kind: approval.promptKind,
             command: approval.command,
+            cwd: approval.cwd,
             tool_name: approval.toolName,
             request_detail: approval.requestDetail,
             reason: approval.approvable ? undefined : approval.reason,
@@ -415,6 +647,9 @@ function statusFromInspection(adapter, terminalControl, inspection) {
         },
         screen: {
             excerpt: inspection.screenExcerpt,
+            digest: options.screen === undefined
+                ? undefined
+                : createHash("sha256").update(options.screen).digest("hex"),
             approval: approvalOutput(approval)
         }
     };
@@ -446,6 +681,7 @@ function approvalOutput(approval) {
             reason: approval.reason,
             promptKind: approval.promptKind,
             command: approval.command,
+            cwd: approval.cwd,
             toolName: approval.toolName,
             requestDetail: approval.requestDetail
         };
@@ -458,6 +694,7 @@ function approvalOutput(approval) {
         label: approval.action.label,
         promptKind: approval.promptKind,
         command: approval.command,
+        cwd: approval.cwd,
         toolName: approval.toolName,
         requestDetail: approval.requestDetail,
         decisionMode: approval.action.mode ?? "keys",