@fabric-harness/sdk 2.4.1 → 2.6.0

package/dist/session.js

@@ -1,29 +1,30 @@
-import { createHash } from 'node:crypto';
-import { CostBudgetTracker } from './cost-budget.js';
-import { inMemorySessionMemory } from './session-memory.js';
-import { FabricError } from './error.js';
-import { SessionHistory, buildModelMessagesFromHistory, findTrailingDanglingToolCalls, findTrailingUnfinishedTasks } from './history.js';
-import { getLogger } from './logger.js';
-import { defaultLoopRuntime } from './loop.js';
-import { defaultModelProvider, generateWithRuntime } from './model.js';
-import { clampCommandTimeout, evaluateCommandPolicy, evaluateToolCallPolicy } from './policy.js';
-import { buildResultRetryPrompt, validateResult } from './result.js';
-import { estimateSessionEntryTokens, evaluateContextBudget, isContextOverflowError } from './context-budget.js';
-import { policiedSandboxEnv, runWithSandboxPolicyApproval } from './policied-sandbox.js';
-import { currentSubmissionContext } from './submission-context.js';
-import { createSandboxEnv, createScopedSandboxEnv } from './sandbox.js';
-import { createFabricFs } from './filesystem.js';
-import { registerSandbox, serializeSandboxRef, unregisterSandbox } from './sandbox-ref.js';
-import path from 'node:path';
-import { defaultSessionStore } from './store.js';
-import { createActivateSkillTool, createBuiltinTools, createCommandTools, shellQuote } from './tools.js';
-import { formatPackagedSkillResourceList, readPackagedSkillFile } from './skills.js';
-import { MAX_TASK_DEPTH } from './types.js';
+import { createHash } from "node:crypto";
+import { CostBudgetTracker } from "./cost-budget.js";
+import { inMemorySessionMemory } from "./session-memory.js";
+import { FabricError } from "./error.js";
+import { approvalGrantFromState, approvalInputDigest, createApprovalGrant } from "./approval.js";
+import { SessionHistory, buildModelMessagesFromHistory, findTrailingDanglingToolCalls, findTrailingUnfinishedTasks, } from "./history.js";
+import { getLogger } from "./logger.js";
+import { defaultLoopRuntime } from "./loop.js";
+import { defaultModelProvider, generateWithRuntime } from "./model.js";
+import { clampCommandTimeout, evaluateCommandPolicy, evaluateToolCallPolicy } from "./policy.js";
+import { buildResultRetryPrompt, validateResult } from "./result.js";
+import { estimateSessionEntryTokens, evaluateContextBudget, isContextOverflowError, } from "./context-budget.js";
+import { policiedSandboxEnv, runWithSandboxPolicyApproval } from "./policied-sandbox.js";
+import { currentSubmissionContext } from "./submission-context.js";
+import { createSandboxEnv, createScopedSandboxEnv } from "./sandbox.js";
+import { createFabricFs } from "./filesystem.js";
+import { registerSandbox, serializeSandboxRef, unregisterSandbox } from "./sandbox-ref.js";
+import path from "node:path";
+import { defaultSessionStore } from "./store.js";
+import { createActivateSkillTool, createBuiltinTools, createCommandTools, shellQuote, } from "./tools.js";
+import { formatPackagedSkillResourceList, readPackagedSkillFile } from "./skills.js";
+import { MAX_TASK_DEPTH } from "./types.js";
 let nextTaskId = 0;
-const CROCKFORD_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+const CROCKFORD_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 const AFFINITY_KEY_REGEX = /^aff_[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
 function encodeBase32(buf, length) {
-    let result = '';
+    let result = "";
     let bitIndex = 0; // 0 = MSB of buf[0]
     for (let i = 0; i < length; i++) {
         let value = 0;
@@ -46,7 +47,7 @@ function encodeBase32(buf, length) {
  * with overwhelming probability.
  */
 export function generateAffinityKey(agentId, sessionId) {
-    const hash = createHash('sha256').update(agentId).update('\0').update(sessionId).digest();
+    const hash = createHash("sha256").update(agentId).update("\0").update(sessionId).digest();
     // Build a 128-bit buffer from the hash, clearing the top 5 bits of the
     // first byte so the first Crockford base32 char is in [0-7].
     const combined = Buffer.alloc(16);
@@ -57,7 +58,7 @@ export function generateAffinityKey(agentId, sessionId) {
 export function isValidAffinityKey(key) {
     return AFFINITY_KEY_REGEX.test(key);
 }
-const COMPACTION_SUMMARIZATION_SYSTEM_PROMPT = 'Summarize durable agent session history for future context. Preserve user goals, decisions, tool/command effects, files touched, errors, policy/approval events, and pending work. Do not include secrets.';
+const COMPACTION_SUMMARIZATION_SYSTEM_PROMPT = "Summarize durable agent session history for future context. Preserve user goals, decisions, tool/command effects, files touched, errors, policy/approval events, and pending work. Do not include secrets.";
 const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
 
 Summarize the prefix to provide context for the retained suffix:
@@ -126,20 +127,22 @@ export class StubFabricSession {
     }
     async prompt(text, promptOptions = {}) {
         const ambientSignal = promptOptions.signal === undefined ? currentSubmissionContext()?.signal : undefined;
-        const options = ambientSignal ? { ...promptOptions, signal: ambientSignal } : promptOptions;
+        const options = ambientSignal
+            ? { ...promptOptions, signal: ambientSignal }
+            : promptOptions;
         const durable = await this.getDurableRuntime();
         if (durable) {
             // Delegate to the durable runtime; the runtime is responsible for
             // recording entries / events on its own side. We still emit a single
             // local prompt_start/end pair so local subscribers see activity.
-            await this.emit('prompt_start', { text });
+            await this.emit("prompt_start", { text });
             try {
                 const result = await durable.prompt({ text, ...(options ? { options } : {}) });
-                await this.emit('prompt_end', { text });
+                await this.emit("prompt_end", { text });
                 return result;
             }
             catch (error) {
-                await this.emit('error', { error: error instanceof Error ? error.message : String(error) });
+                await this.emit("error", { error: error instanceof Error ? error.message : String(error) });
                 throw error;
             }
         }
@@ -149,7 +152,7 @@ export class StubFabricSession {
             this.eventSubscribers.add(promptSubscriber);
         try {
             await this.repairDanglingToolCalls();
-            await this.emit('prompt_start', { text, ...(role ? { role: role.name } : {}) });
+            await this.emit("prompt_start", { text, ...(role ? { role: role.name } : {}) });
             const sandbox = createScopedSandboxEnv(await this.sandbox, options.cwd);
             const tools = this.resolveTools(sandbox, options.tools, options.commands);
             // Submission-correlated prompts are idempotent by submission id: a
@@ -159,10 +162,11 @@ export class StubFabricSession {
             if (options.submission) {
                 const prior = await this.history();
                 const submissionId = options.submission.submissionId;
-                inputAlreadyApplied = (prior.entries ?? []).some((entry) => entry.type === 'user_prompt' && entry.data?.submissionId === submissionId);
+                inputAlreadyApplied = (prior.entries ?? []).some((entry) => entry.type === "user_prompt" &&
+                    entry.data?.submissionId === submissionId);
             }
             if (!inputAlreadyApplied) {
-                await this.recordEntry('user_prompt', {
+                await this.recordEntry("user_prompt", {
                     text,
                     ...(role ? { role: role.name } : {}),
                     ...(options.submission ? { submissionId: options.submission.submissionId } : {}),
@@ -175,13 +179,13 @@ export class StubFabricSession {
             await options.submission?.onInputApplied?.();
             const sessionData = await this.history();
             let messages = buildModelMessagesFromHistory(sessionData, role);
-            if (!messages.some((message) => message.role === 'user' && message.content === text))
-                messages.push({ role: 'user', content: text });
+            if (!messages.some((message) => message.role === "user" && message.content === text))
+                messages.push({ role: "user", content: text });
             messages = await this.autoCompactIfNeeded(messages, role, options);
             if (options.toolCalls?.length) {
                 const results = await this.executeToolCalls(options.toolCalls, tools, sandbox, options.policy, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval, undefined, options.signal);
-                await this.recordEntry('result', { result: results });
-                await this.emit('prompt_end', { text, result: results });
+                await this.recordEntry("result", { result: results });
+                await this.emit("prompt_end", { text, result: results });
                 return validateResult(results, options.result, options.resultExtraction);
             }
             // Use tool-based result extraction when a validator is provided and the caller
@@ -190,25 +194,44 @@ export class StubFabricSession {
             const runtime = options.loopRuntime ?? this.options.loopRuntime ?? defaultLoopRuntime;
             const runRuntime = () => runtime.runPrompt({
                 sessionId: this.id,
-                ...(sessionData.affinityKey !== undefined ? { affinityKey: sessionData.affinityKey } : {}),
+                ...(sessionData.affinityKey !== undefined
+                    ? { affinityKey: sessionData.affinityKey }
+                    : {}),
                 text,
                 messages,
                 tools,
                 sandbox,
-                ...(typeof (options.model ?? this.options.model ?? this.agent.model) === 'string' ? { model: (options.model ?? this.options.model ?? this.agent.model) } : {}),
-                ...((options.thinkingLevel ?? this.options.thinkingLevel ?? this.agent.thinkingLevel) !== undefined ? { thinkingLevel: options.thinkingLevel ?? this.options.thinkingLevel ?? this.agent.thinkingLevel } : {}),
-                ...((options.modelProvider ?? this.options.modelProvider) !== undefined ? { modelProvider: options.modelProvider ?? this.options.modelProvider } : {}),
+                ...(typeof (options.model ?? this.options.model ?? this.agent.model) === "string"
+                    ? { model: (options.model ?? this.options.model ?? this.agent.model) }
+                    : {}),
+                ...((options.thinkingLevel ?? this.options.thinkingLevel ?? this.agent.thinkingLevel) !==
+                    undefined
+                    ? {
+                        thinkingLevel: options.thinkingLevel ?? this.options.thinkingLevel ?? this.agent.thinkingLevel,
+                    }
+                    : {}),
+                ...((options.modelProvider ?? this.options.modelProvider) !== undefined
+                    ? { modelProvider: options.modelProvider ?? this.options.modelProvider }
+                    : {}),
                 ...(options.maxIterations !== undefined ? { maxIterations: options.maxIterations } : {}),
-                ...(options.modelTimeoutMs !== undefined ? { modelTimeoutMs: options.modelTimeoutMs } : {}),
+                ...(options.modelTimeoutMs !== undefined
+                    ? { modelTimeoutMs: options.modelTimeoutMs }
+                    : {}),
                 ...(options.modelRetries !== undefined ? { modelRetries: options.modelRetries } : {}),
-                ...(options.modelRetryDelayMs !== undefined ? { modelRetryDelayMs: options.modelRetryDelayMs } : {}),
+                ...(options.modelRetryDelayMs !== undefined
+                    ? { modelRetryDelayMs: options.modelRetryDelayMs }
+                    : {}),
                 ...(options.signal !== undefined ? { signal: options.signal } : {}),
                 ...(options.policy !== undefined ? { policy: options.policy } : {}),
-                ...((options.approvalTimeoutMs ?? this.options.approvalTimeoutMs) !== undefined ? { approvalTimeoutMs: options.approvalTimeoutMs ?? this.options.approvalTimeoutMs } : {}),
-                ...(this.costBudget.enabled() ? {
-                    costBudget: this.costBudget,
-                    requestCostLimitApproval: (ctx) => this.requestCostLimitApproval(ctx, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval),
-                } : {}),
+                ...((options.approvalTimeoutMs ?? this.options.approvalTimeoutMs) !== undefined
+                    ? { approvalTimeoutMs: options.approvalTimeoutMs ?? this.options.approvalTimeoutMs }
+                    : {}),
+                ...(this.costBudget.enabled()
+                    ? {
+                        costBudget: this.costBudget,
+                        requestCostLimitApproval: (ctx) => this.requestCostLimitApproval(ctx, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval),
+                    }
+                    : {}),
                 ...(useResultTools ? { resultValidator: options.result } : {}),
                 agentId: this.agent.id,
                 ...(this.options.tenantId !== undefined ? { tenantId: this.options.tenantId } : {}),
@@ -225,11 +248,13 @@ export class StubFabricSession {
                 const recoverFromOverflow = options.recoverContextOverflow ?? compactionSettings?.recoverFromOverflow ?? true;
                 if (!isContextOverflowError(error) || !recoverFromOverflow)
                     throw error;
-                await this.emit('error', { error: 'Context overflow detected; compacting and retrying once.' });
+                await this.emit("error", {
+                    error: "Context overflow detected; compacting and retrying once.",
+                });
                 await this.compact({
                     keepRecentEntries: options.compactionKeepRecentEntries ?? compactionSettings?.keepRecentEntries ?? 20,
                     generateSummary: true,
-                    reason: 'overflow',
+                    reason: "overflow",
                 });
                 messages = buildModelMessagesFromHistory(await this.history(), role);
                 result = await runRuntime();
@@ -247,13 +272,28 @@ export class StubFabricSession {
                     if (attempt >= resultRetries)
                         throw error;
                     const message = error instanceof Error ? error.message : String(error);
-                    await this.recordEntry('result_retry', { error: message, retryAttempt: attempt + 1, maxRetries: resultRetries });
-                    await this.emit('result_retry', { error: message, retryAttempt: attempt + 1, maxRetries: resultRetries });
-                    messages.push({ role: 'user', content: buildResultRetryPrompt(error, options.resultExtraction) });
+                    await this.recordEntry("result_retry", {
+                        error: message,
+                        retryAttempt: attempt + 1,
+                        maxRetries: resultRetries,
+                    });
+                    await this.emit("result_retry", {
+                        error: message,
+                        retryAttempt: attempt + 1,
+                        maxRetries: resultRetries,
+                    });
+                    messages.push({
+                        role: "user",
+                        content: buildResultRetryPrompt(error, options.resultExtraction),
+                    });
                     result = await runRuntime();
                 }
             }
-            throw new FabricError({ code: 'RESULT_VALIDATION_FAILED', message: 'Typed result validation failed.', retryable: true });
+            throw new FabricError({
+                code: "RESULT_VALIDATION_FAILED",
+                message: "Typed result validation failed.",
+                retryable: true,
+            });
         }
         finally {
             if (promptSubscriber)
@@ -304,34 +344,44 @@ export class StubFabricSession {
     }
     async skill(name, options = {}) {
         const skill = this.resolveSkill(name);
-        await this.recordEntry('skill_start', { skill: name });
-        await this.emit('skill_start', { skill: name });
+        await this.recordEntry("skill_start", { skill: name });
+        await this.emit("skill_start", { skill: name });
         if (!skill)
-            throw new FabricError({ code: 'SKILL_NOT_FOUND', message: `Skill not found: ${name}`, details: { skill: name } });
-        const argsText = options.args ? `\n\nArguments:\n${JSON.stringify(options.args, null, 2)}` : '';
-        const packagedText = skill.packaged ? formatPackagedSkillResourceList(skill.packaged) : '';
-        const result = await this.prompt(`${skill.content ?? ''}${argsText}${packagedText}`, options);
-        await this.recordEntry('skill_end', { skill: name });
-        await this.emit('skill_end', { skill: name });
+            throw new FabricError({
+                code: "SKILL_NOT_FOUND",
+                message: `Skill not found: ${name}`,
+                details: { skill: name },
+            });
+        const argsText = options.args ? `\n\nArguments:\n${JSON.stringify(options.args, null, 2)}` : "";
+        const packagedText = skill.packaged ? formatPackagedSkillResourceList(skill.packaged) : "";
+        const result = await this.prompt(`${skill.content ?? ""}${argsText}${packagedText}`, options);
+        await this.recordEntry("skill_end", { skill: name });
+        await this.emit("skill_end", { skill: name });
         return result;
     }
     async task(text, options = {}) {
         const durable = await this.getDurableRuntime();
         if (durable) {
             const taskId = options.id ?? `${this.id}:task-${++nextTaskId}`;
-            await this.emit('task_start', { taskId, depth: 1, parentSessionId: this.id });
+            await this.emit("task_start", { taskId, depth: 1, parentSessionId: this.id });
             try {
                 const { id: _id, ...taskOptions } = options;
                 const result = await durable.task({
                     text,
                     taskId,
-                    ...(Object.keys(taskOptions).length ? { options: taskOptions } : {}),
+                    ...(Object.keys(taskOptions).length
+                        ? { options: taskOptions }
+                        : {}),
                 });
-                await this.emit('task_end', { taskId, depth: 1, parentSessionId: this.id });
+                await this.emit("task_end", { taskId, depth: 1, parentSessionId: this.id });
                 return result;
             }
             catch (error) {
-                await this.emit('task_failed', { taskId, status: 'failed', error: error instanceof Error ? error.message : String(error) });
+                await this.emit("task_failed", {
+                    taskId,
+                    status: "failed",
+                    error: error instanceof Error ? error.message : String(error),
+                });
                 throw error;
             }
         }
@@ -341,22 +391,42 @@ export class StubFabricSession {
             throw new Error(`Task nesting exceeds MAX_TASK_DEPTH (${MAX_TASK_DEPTH}). Refusing to spawn deeper child task at depth ${depth}.`);
         }
         const startedAt = new Date().toISOString();
-        await this.recordEntry('task_start', { taskId, text, status: 'running', startedAt, depth, ...(options.agent ? { agent: options.agent } : {}), ...(options.metadata ? { metadata: options.metadata } : {}) });
-        await this.emit('task_start', { taskId, depth, parentSessionId: this.id });
-        const checkpointLabel = typeof options.checkpoint === 'string' ? options.checkpoint : `task:${taskId}`;
+        await this.recordEntry("task_start", {
+            taskId,
+            text,
+            status: "running",
+            startedAt,
+            depth,
+            ...(options.agent ? { agent: options.agent } : {}),
+            ...(options.metadata ? { metadata: options.metadata } : {}),
+        });
+        await this.emit("task_start", { taskId, depth, parentSessionId: this.id });
+        const checkpointLabel = typeof options.checkpoint === "string" ? options.checkpoint : `task:${taskId}`;
         try {
             if (options.signal?.aborted)
                 throw abortError();
             if (options.checkpoint) {
-                const checkpoint = await this.createCheckpoint({ label: `${checkpointLabel}:before`, metadata: { taskId, phase: 'before' } });
-                await this.recordEntry('task_checkpoint', { taskId, phase: 'before', checkpoint: checkpoint, ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
-                await this.emit('task_checkpoint', { taskId, phase: 'before', ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+                const checkpoint = await this.createCheckpoint({
+                    label: `${checkpointLabel}:before`,
+                    metadata: { taskId, phase: "before" },
+                });
+                await this.recordEntry("task_checkpoint", {
+                    taskId,
+                    phase: "before",
+                    checkpoint: checkpoint,
+                    ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}),
+                });
+                await this.emit("task_checkpoint", {
+                    taskId,
+                    phase: "before",
+                    ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}),
+                });
             }
             const taskAbort = new AbortController();
             const stopCancellationWatcher = this.watchTaskCancellation(taskId, taskAbort);
             const forwardAbort = () => taskAbort.abort(options.signal?.reason);
             if (options.signal)
-                options.signal.addEventListener('abort', forwardAbort, { once: true });
+                options.signal.addEventListener("abort", forwardAbort, { once: true });
             try {
                 const child = new StubFabricSession(this.agent, taskId, {
                     ...this.options,
@@ -364,39 +434,65 @@ export class StubFabricSession {
                     store: this.store,
                     sandbox: await this.sandbox,
                     // Propagate depth so nested tasks can enforce MAX_TASK_DEPTH.
-                    metadata: { ...(this.options.metadata ?? {}), ...(options.metadata ?? {}), taskDepth: depth },
+                    metadata: {
+                        ...(this.options.metadata ?? {}),
+                        ...(options.metadata ?? {}),
+                        taskDepth: depth,
+                    },
                 });
                 const result = await child.prompt(text, { ...options, signal: taskAbort.signal });
                 if (taskAbort.signal.aborted)
                     throw abortError();
                 if (options.checkpoint) {
-                    const checkpoint = await this.createCheckpoint({ label: `${checkpointLabel}:after`, metadata: { taskId, phase: 'after' } });
-                    await this.recordEntry('task_checkpoint', { taskId, phase: 'after', checkpoint: checkpoint, ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
-                    await this.emit('task_checkpoint', { taskId, phase: 'after', ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}) });
+                    const checkpoint = await this.createCheckpoint({
+                        label: `${checkpointLabel}:after`,
+                        metadata: { taskId, phase: "after" },
+                    });
+                    await this.recordEntry("task_checkpoint", {
+                        taskId,
+                        phase: "after",
+                        checkpoint: checkpoint,
+                        ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}),
+                    });
+                    await this.emit("task_checkpoint", {
+                        taskId,
+                        phase: "after",
+                        ...(checkpoint.snapshotId ? { checkpointId: checkpoint.snapshotId } : {}),
+                    });
                 }
                 const completedAt = new Date().toISOString();
-                await this.recordEntry('task_end', { taskId, status: 'completed', completedAt, depth });
-                await this.emit('task_end', { taskId, depth, parentSessionId: this.id });
+                await this.recordEntry("task_end", { taskId, status: "completed", completedAt, depth });
+                await this.emit("task_end", { taskId, depth, parentSessionId: this.id });
                 return result;
             }
             finally {
                 stopCancellationWatcher();
                 if (options.signal)
-                    options.signal.removeEventListener('abort', forwardAbort);
+                    options.signal.removeEventListener("abort", forwardAbort);
             }
         }
         catch (error) {
             if (isAbortError(error) || options.signal?.aborted) {
                 const cancelledAt = new Date().toISOString();
-                const message = error instanceof Error ? error.message : 'Task cancelled';
-                await this.recordEntry('task_cancelled', { taskId, status: 'cancelled', cancelledAt, reason: message });
-                await this.emit('task_cancelled', { taskId, status: 'cancelled', cancelledAt, reason: message });
+                const message = error instanceof Error ? error.message : "Task cancelled";
+                await this.recordEntry("task_cancelled", {
+                    taskId,
+                    status: "cancelled",
+                    cancelledAt,
+                    reason: message,
+                });
+                await this.emit("task_cancelled", {
+                    taskId,
+                    status: "cancelled",
+                    cancelledAt,
+                    reason: message,
+                });
                 throw error;
             }
             const failedAt = new Date().toISOString();
             const message = error instanceof Error ? error.message : String(error);
-            await this.recordEntry('task_failed', { taskId, status: 'failed', failedAt, error: message });
-            await this.emit('task_failed', { taskId, status: 'failed', failedAt, error: message });
+            await this.recordEntry("task_failed", { taskId, status: "failed", failedAt, error: message });
+            await this.emit("task_failed", { taskId, status: "failed", failedAt, error: message });
             throw error;
         }
     }
@@ -419,11 +515,15 @@ export class StubFabricSession {
                     return;
                 try {
                     const entries = (await this.store.load(this.id))?.entries ?? [];
-                    if (entries.some((entry) => entry.type === 'task_cancelled' && entry.data?.taskId === taskId))
+                    if (entries.some((entry) => entry.type === "task_cancelled" && entry.data?.taskId === taskId))
                         controller.abort(abortError());
                 }
                 catch (error) {
-                    logger.warn('Task-cancellation poller failed to load session; will retry next interval.', { error: error instanceof Error ? error.message : String(error), taskId, sessionId: this.id });
+                    logger.warn("Task-cancellation poller failed to load session; will retry next interval.", {
+                        error: error instanceof Error ? error.message : String(error),
+                        taskId,
+                        sessionId: this.id,
+                    });
                 }
             })();
         }, 500);
@@ -432,9 +532,9 @@ export class StubFabricSession {
     async shell(command, options = {}) {
         const durable = await this.getDurableRuntime();
         if (durable) {
-            await this.emit('command_start', { command });
+            await this.emit("command_start", { command });
             const result = await durable.shell({ command, ...(options ? { options } : {}) });
-            await this.emit('command_end', { command, exitCode: result.exitCode });
+            await this.emit("command_end", { command, exitCode: result.exitCode });
             return result;
         }
         const sandbox = await this.sandbox;
@@ -445,24 +545,33 @@ export class StubFabricSession {
         if (!decision.allowed) {
             if (decision.approvalRequired) {
                 const approved = await this.requestApproval({
-                    kind: 'command',
+                    kind: "command",
                     command,
-                    input: { command, ...((options.cwd ?? this.options.cwd) ? { cwd: options.cwd ?? this.options.cwd } : {}) },
+                    input: {
+                        command,
+                        ...((options.cwd ?? this.options.cwd)
+                            ? { cwd: options.cwd ?? this.options.cwd }
+                            : {}),
+                    },
                     reason: decision.reason ?? `Approval required for command: ${command}`,
                     ...(decision.risk ? { risk: decision.risk } : {}),
                     ...(decision.matchedPattern ? { matchedPattern: decision.matchedPattern } : {}),
                 }, policy, options.approvalTimeoutMs ?? this.options.approvalTimeoutMs, options.onApproval);
                 if (!approved) {
-                    const message = decision.reason ?? 'Command approval denied or unavailable';
-                    await this.emit('error', { reason: message, command, approvalRequired: true });
-                    throw new FabricError({ code: 'COMMAND_DENIED', message, details: { command, approvalRequired: true } });
+                    const message = decision.reason ?? "Command approval denied or unavailable";
+                    await this.emit("error", { reason: message, command, approvalRequired: true });
+                    throw new FabricError({
+                        code: "COMMAND_DENIED",
+                        message,
+                        details: { command, approvalRequired: true },
+                    });
                 }
                 policyApproved = true;
             }
             else {
-                const message = decision.reason ?? 'Command denied by policy';
-                await this.emit('error', { reason: message, command });
-                throw new FabricError({ code: 'COMMAND_DENIED', message, details: { command } });
+                const message = decision.reason ?? "Command denied by policy";
+                await this.emit("error", { reason: message, command });
+                throw new FabricError({ code: "COMMAND_DENIED", message, details: { command } });
             }
         }
         if (options.cwd !== undefined)
@@ -474,17 +583,22 @@ export class StubFabricSession {
         const timeout = clampCommandTimeout(options.timeout, policy);
         if (timeout !== undefined)
             execOptions.timeout = timeout;
-        await this.emit('command_start', { command });
+        await this.emit("command_start", { command });
         const execute = () => sandbox.exec(command, execOptions);
         const result = policyApproved
-            ? await runWithSandboxPolicyApproval(sandbox, { tool: 'bash', input: { command } }, execute)
+            ? await runWithSandboxPolicyApproval(sandbox, { tool: "bash", input: { command } }, execute)
             : await execute();
         const redactedCommand = redactEnvValues(command, options.env);
         const toolCallId = `shell-${Date.now()}`;
-        await this.recordEntry('user_prompt', { text: `Run shell command: ${redactedCommand}` });
-        await this.recordEntry('tool_call', { tool: 'bash', input: { command: redactedCommand }, toolCallId, synthetic: true });
-        await this.recordEntry('tool_result', {
-            tool: 'bash',
+        await this.recordEntry("user_prompt", { text: `Run shell command: ${redactedCommand}` });
+        await this.recordEntry("tool_call", {
+            tool: "bash",
+            input: { command: redactedCommand },
+            toolCallId,
+            synthetic: true,
+        });
+        await this.recordEntry("tool_result", {
+            tool: "bash",
             output: {
                 stdout: redactEnvValues(result.stdout, options.env),
                 stderr: redactEnvValues(result.stderr, options.env),
@@ -493,47 +607,75 @@ export class StubFabricSession {
             toolCallId,
             synthetic: true,
         });
-        await this.emit('command_end', { command, exitCode: result.exitCode, ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}) });
+        await this.emit("command_end", {
+            command,
+            exitCode: result.exitCode,
+            ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+        });
         return result;
     }
     async mount(mountAt, source, options = {}) {
-        if (!mountAt || typeof mountAt !== 'string') {
-            throw new FabricError({ code: 'MOUNT_INVALID_PATH', message: 'mount() requires a non-empty mountAt path.' });
+        if (!mountAt || typeof mountAt !== "string") {
+            throw new FabricError({
+                code: "MOUNT_INVALID_PATH",
+                message: "mount() requires a non-empty mountAt path.",
+            });
         }
         const sandbox = await this.sandbox;
         const root = resolveMountPath(sandbox.cwd, mountAt);
-        if (!await sandbox.exists(root))
+        if (!(await sandbox.exists(root)))
             await sandbox.mkdir(root, { recursive: true });
-        const mode = options.mode ?? 'read';
+        const mode = options.mode ?? "read";
         let files = 0;
         let bytes = 0;
         for await (const entry of source.entries()) {
-            const relative = entry.path.replace(/^\/+/, '');
+            const relative = entry.path.replace(/^\/+/, "");
             const target = path.posix.join(root, relative);
             const parent = path.posix.dirname(target);
-            if (parent && parent !== '.' && parent !== '/') {
-                if (!await sandbox.exists(parent))
+            if (parent && parent !== "." && parent !== "/") {
+                if (!(await sandbox.exists(parent)))
                     await sandbox.mkdir(parent, { recursive: true });
             }
             await sandbox.writeFile(target, entry.content);
             files += 1;
-            bytes += typeof entry.content === 'string' ? Buffer.byteLength(entry.content, 'utf8') : entry.content.byteLength;
+            bytes +=
+                typeof entry.content === "string"
+                    ? Buffer.byteLength(entry.content, "utf8")
+                    : entry.content.byteLength;
         }
         this.mounts.push({ mountAt: root, mode });
-        const result = { mountAt: root, files, bytes, mode, ...(source.name ? { source: source.name } : {}) };
-        await this.recordEntry('mount', { mountAt: root, files, bytes, mode, ...(source.name ? { source: source.name } : {}) });
-        await this.emit('mount', { mountAt: root, files, bytes, mode, ...(source.name ? { source: source.name } : {}) });
+        const result = {
+            mountAt: root,
+            files,
+            bytes,
+            mode,
+            ...(source.name ? { source: source.name } : {}),
+        };
+        await this.recordEntry("mount", {
+            mountAt: root,
+            files,
+            bytes,
+            mode,
+            ...(source.name ? { source: source.name } : {}),
+        });
+        await this.emit("mount", {
+            mountAt: root,
+            files,
+            bytes,
+            mode,
+            ...(source.name ? { source: source.name } : {}),
+        });
         return result;
     }
     checkMountWriteAccess(call) {
-        const writeTools = new Set(['write', 'edit', 'mkdir', 'rm']);
+        const writeTools = new Set(["write", "edit", "mkdir", "rm"]);
         if (!writeTools.has(call.tool) || this.mounts.length === 0)
             return undefined;
-        const targetPath = readStringPropertyFromInput(call.input, 'path');
+        const targetPath = readStringPropertyFromInput(call.input, "path");
         if (!targetPath)
             return undefined;
         for (const mount of this.mounts) {
-            if (mount.mode !== 'read')
+            if (mount.mode !== "read")
                 continue;
             if (targetPath === mount.mountAt || targetPath.startsWith(`${mount.mountAt}/`)) {
                 return {
@@ -549,7 +691,7 @@ export class StubFabricSession {
         return this.ensureData();
     }
     async createSignalEntry(data) {
-        return this.recordEntry('signal', data);
+        return this.recordEntry("signal", data);
     }
     async sandboxRef(options) {
         const sandbox = await this.sandbox;
@@ -566,7 +708,11 @@ export class StubFabricSession {
                 await originalCleanup();
             };
         }
-        await this.recordEntry('metric', { event: 'sandbox_ref_created', refId: ref.id, ...(options?.portable ? { portable: true } : {}) });
+        await this.recordEntry("metric", {
+            event: "sandbox_ref_created",
+            refId: ref.id,
+            ...(options?.portable ? { portable: true } : {}),
+        });
         if (options?.portable) {
             return serializeSandboxRef(ref, this.id, this.options.tenantId);
         }
@@ -576,27 +722,31 @@ export class StubFabricSession {
         const sandbox = await this.sandbox;
         if (!sandbox.snapshot || !sandbox.fork) {
             throw new FabricError({
-                code: 'SANDBOX_UNAVAILABLE',
-                message: 'Sandbox does not support fork. Required capabilities: snapshot + fork.',
+                code: "SANDBOX_UNAVAILABLE",
+                message: "Sandbox does not support fork. Required capabilities: snapshot + fork.",
             });
         }
         const snapshot = await sandbox.snapshot();
         const sandboxFork = sandbox.fork;
         const agent = this.agent;
         const baseOptions = this.options;
-        await this.recordEntry('checkpoint_created', {
+        await this.recordEntry("checkpoint_created", {
             label: label ?? `fork:${snapshot.id}`,
             ...(label ? { metadata: { fork: true } } : { metadata: { fork: true } }),
             snapshotId: snapshot.id,
             snapshot: snapshot,
         });
-        await this.emit('checkpoint_created', { label: label ?? `fork:${snapshot.id}`, snapshotId: snapshot.id });
+        await this.emit("checkpoint_created", {
+            label: label ?? `fork:${snapshot.id}`,
+            snapshotId: snapshot.id,
+        });
         return {
             snapshotId: snapshot.id,
             ...(label !== undefined ? { label } : {}),
             async attach(attachOptions = {}) {
                 const newSandbox = await sandboxFork.call(sandbox, snapshot);
-                const newId = attachOptions.id ?? `${baseOptions.metadata?.parentSessionId ?? 'fork'}-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+                const newId = attachOptions.id ??
+                    `${baseOptions.metadata?.parentSessionId ?? "fork"}-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
                 const merged = {
                     ...baseOptions,
                     ...attachOptions,
@@ -613,21 +763,23 @@ export class StubFabricSession {
         };
     }
     async artifact(name, content, options = {}) {
-        const bytes = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+        const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
         const fallback = {
-            id: `${Date.now()}-${name.replace(/[^a-zA-Z0-9._-]/g, '_')}`,
+            id: `${Date.now()}-${name.replace(/[^a-zA-Z0-9._-]/g, "_")}`,
             sessionId: this.id,
             name,
             path: name,
             size: bytes.byteLength,
-            sha256: createHash('sha256').update(bytes).digest('hex'),
+            sha256: createHash("sha256").update(bytes).digest("hex"),
             createdAt: new Date().toISOString(),
             ...(options.contentType ? { contentType: options.contentType } : {}),
             ...(options.metadata ? { metadata: options.metadata } : {}),
         };
-        const ref = this.store.putArtifact ? await this.store.putArtifact(this.id, name, bytes, options) : fallback;
-        await this.recordEntry('artifact_created', { artifact: ref });
-        await this.emit('artifact_created', { artifact: ref });
+        const ref = this.store.putArtifact
+            ? await this.store.putArtifact(this.id, name, bytes, options)
+            : fallback;
+        await this.recordEntry("artifact_created", { artifact: ref });
+        await this.emit("artifact_created", { artifact: ref });
         return ref;
     }
     async compact(options = {}) {
@@ -661,12 +813,13 @@ export class StubFabricSession {
             isSplitTurn: false,
             fileRefs,
         };
-        const baseSummary = options.summary ?? (options.generateSummary
-            ? await this.generateCompactionSummary(summaryInput)
-            : summarizeEntries(compacted));
+        const baseSummary = options.summary ??
+            (options.generateSummary
+                ? await this.generateCompactionSummary(summaryInput)
+                : summarizeEntries(compacted));
         const summary = appendFileReferenceTags(baseSummary, fileRefs);
         const compactedEntries = compacted.length;
-        const entry = await this.recordEntry('compaction', {
+        const entry = await this.recordEntry("compaction", {
             summary,
             compactedEntries,
             ...(fileRefs.readFiles.length > 0 ? { readFiles: fileRefs.readFiles } : {}),
@@ -674,12 +827,12 @@ export class StubFabricSession {
             ...(firstKeptEntry ? { firstKeptEntryId: firstKeptEntry.id } : {}),
         });
         const messagesAfter = Math.max(0, entries.length - compactedEntries) + (compactedEntries > 0 ? 1 : 0);
-        await this.emit('compaction', {
+        await this.emit("compaction", {
             summary,
             compactedEntries,
             messagesBefore: options.messagesBefore ?? entries.length,
             messagesAfter,
-            ...(options.reason ? { reason: options.reason } : { reason: 'manual' }),
+            ...(options.reason ? { reason: options.reason } : { reason: "manual" }),
             ...(options.tokensBefore !== undefined ? { tokensBefore: options.tokensBefore } : {}),
         });
         return {
@@ -704,13 +857,20 @@ export class StubFabricSession {
             ...(contextWindowTokens !== undefined ? { contextWindowTokens } : {}),
             ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
             ...(reserveTokens !== undefined ? { reserveTokens } : {}),
-            ...(settings?.keepRecentTokens !== undefined ? { keepRecentTokens: settings.keepRecentTokens } : {}),
+            ...(settings?.keepRecentTokens !== undefined
+                ? { keepRecentTokens: settings.keepRecentTokens }
+                : {}),
         });
         if (!budget.shouldCompact)
             return messages;
         const messagesBefore = messages.length;
         const tokensBefore = budget.estimatedTokens;
-        const compactOpts = { generateSummary: true, reason: 'threshold', tokensBefore, messagesBefore };
+        const compactOpts = {
+            generateSummary: true,
+            reason: "threshold",
+            tokensBefore,
+            messagesBefore,
+        };
         if (keepRecentEntries !== undefined) {
             compactOpts.keepRecentEntries = keepRecentEntries;
         }
@@ -725,7 +885,7 @@ export class StubFabricSession {
         const provider = options.modelProvider ?? this.options.modelProvider;
         if (!provider)
             return undefined;
-        const model = typeof (options.model ?? this.options.model ?? this.agent.model) === 'string'
+        const model = typeof (options.model ?? this.options.model ?? this.agent.model) === "string"
             ? (options.model ?? this.options.model ?? this.agent.model)
             : undefined;
         return this.readProviderModelMetadata(provider, model)?.contextWindowTokens;
@@ -754,13 +914,19 @@ export class StubFabricSession {
         const deterministic = summarizeEntries(entries);
         const provider = this.options.modelProvider ?? defaultModelProvider;
         try {
-            const serialized = JSON.stringify(entries.map((entry) => ({ type: entry.type, timestamp: entry.timestamp, data: entry.data ?? {} })).slice(0, 200));
+            const serialized = JSON.stringify(entries
+                .map((entry) => ({
+                type: entry.type,
+                timestamp: entry.timestamp,
+                data: entry.data ?? {},
+            }))
+                .slice(0, 200));
             const userContent = prefixPrompt ? `${serialized}\n\n${prefixPrompt}` : serialized;
             const response = await generateWithRuntime(provider, {
                 ...(this.agent.model !== undefined ? { model: this.agent.model } : {}),
                 messages: [
-                    { role: 'system', content: COMPACTION_SUMMARIZATION_SYSTEM_PROMPT },
-                    { role: 'user', content: userContent },
+                    { role: "system", content: COMPACTION_SUMMARIZATION_SYSTEM_PROMPT },
+                    { role: "user", content: userContent },
                 ],
             }, { retries: 1, retryDelayMs: 250 });
             return response.message?.content?.trim() || deterministic;
@@ -772,25 +938,25 @@ export class StubFabricSession {
     async requestCustomApproval(input) {
         const timeoutMs = input.timeoutMs ?? this.options.approvalTimeoutMs;
         const approvalPromise = this.requestApproval({
-            kind: 'custom',
+            kind: "custom",
             reason: input.reason,
-            subject: input.subject ?? 'custom',
+            subject: input.subject ?? "custom",
             input: undefined,
             ...(input.risk ? { risk: input.risk } : {}),
             ...(input.idempotencyKey !== undefined ? { idempotencyKey: input.idempotencyKey } : {}),
         }, this.options.policy, timeoutMs, input.onApproval);
-        let approved;
+        let grant;
         if (timeoutMs !== undefined) {
             let timer;
             const timeoutPromise = new Promise((_, reject) => {
                 timer = setTimeout(() => reject(new FabricError({
-                    code: 'APPROVAL_REQUIRED',
+                    code: "APPROVAL_REQUIRED",
                     message: `Approval timed out after ${timeoutMs}ms.`,
                     retryable: false,
                 })), timeoutMs);
             });
             try {
-                approved = await Promise.race([approvalPromise, timeoutPromise]);
+                grant = await Promise.race([approvalPromise, timeoutPromise]);
             }
             finally {
                 if (timer)
@@ -798,11 +964,11 @@ export class StubFabricSession {
             }
         }
         else {
-            approved = await approvalPromise;
+            grant = await approvalPromise;
         }
-        if (!approved) {
+        if (!grant) {
             throw new FabricError({
-                code: 'APPROVAL_DENIED',
+                code: "APPROVAL_DENIED",
                 message: `Custom approval denied: ${input.reason}`,
                 retryable: false,
             });
@@ -813,38 +979,52 @@ export class StubFabricSession {
         const durable = await this.getDurableRuntime();
         if (durable)
             return durable.checkpointCreate({ options });
-        const input = typeof options === 'string' ? { label: options } : options;
+        const input = typeof options === "string" ? { label: options } : options;
         const sandbox = await this.sandbox;
         const snapshot = sandbox.snapshot ? await sandbox.snapshot() : undefined;
-        const entry = await this.recordEntry('checkpoint_created', {
+        const entry = await this.recordEntry("checkpoint_created", {
             label: input.label,
             ...(input.metadata ? { metadata: input.metadata } : {}),
             ...(snapshot ? { snapshotId: snapshot.id, snapshot: snapshot } : {}),
         });
-        await this.emit('checkpoint_created', { label: input.label, ...(snapshot ? { snapshotId: snapshot.id } : {}) });
-        return { label: input.label, entryId: entry.id, ...(snapshot ? { snapshotId: snapshot.id } : {}) };
+        await this.emit("checkpoint_created", {
+            label: input.label,
+            ...(snapshot ? { snapshotId: snapshot.id } : {}),
+        });
+        return {
+            label: input.label,
+            entryId: entry.id,
+            ...(snapshot ? { snapshotId: snapshot.id } : {}),
+        };
     }
     async restoreCheckpoint(options) {
         const durable = await this.getDurableRuntime();
         if (durable)
             return durable.checkpointRestore({ options });
-        const input = typeof options === 'string' ? { label: options } : options;
+        const input = typeof options === "string" ? { label: options } : options;
         const history = await this.history();
         const checkpoint = [...(history.entries ?? [])]
             .reverse()
-            .find((entry) => entry.type === 'checkpoint_created' && entry.data?.label === input.label);
+            .find((entry) => entry.type === "checkpoint_created" && entry.data?.label === input.label);
         if (!checkpoint)
-            throw new FabricError({ code: 'CHECKPOINT_NOT_FOUND', message: `Checkpoint not found: ${input.label}`, details: { label: input.label } });
+            throw new FabricError({
+                code: "CHECKPOINT_NOT_FOUND",
+                message: `Checkpoint not found: ${input.label}`,
+                details: { label: input.label },
+            });
         const sandbox = await this.sandbox;
         const snapshot = checkpoint.data?.snapshot;
         if (sandbox.restore && isSnapshot(snapshot))
             await sandbox.restore(snapshot);
-        const entry = await this.recordEntry('checkpoint_restored', {
+        const entry = await this.recordEntry("checkpoint_restored", {
             label: input.label,
             checkpointEntryId: checkpoint.id,
             ...(isSnapshot(snapshot) ? { snapshotId: snapshot.id } : {}),
         });
-        await this.emit('checkpoint_restored', { label: input.label, checkpointEntryId: checkpoint.id });
+        await this.emit("checkpoint_restored", {
+            label: input.label,
+            checkpointEntryId: checkpoint.id,
+        });
         return {
             label: input.label,
             entryId: entry.id,
@@ -854,12 +1034,19 @@ export class StubFabricSession {
     async createSandbox() {
         const sandbox = this.options.sandbox;
         let env;
-        if (typeof sandbox === 'object' && sandbox !== null && 'exec' in sandbox)
+        if (typeof sandbox === "object" && sandbox !== null && "exec" in sandbox)
             env = sandbox;
-        else if (typeof sandbox === 'function')
-            env = await sandbox({ sessionId: this.id, ...(this.options.cwd !== undefined ? { cwd: this.options.cwd } : {}) });
+        else if (typeof sandbox === "function")
+            env = await sandbox({
+                sessionId: this.id,
+                ...(this.options.cwd !== undefined ? { cwd: this.options.cwd } : {}),
+            });
         else
-            env = await createSandboxEnv({ backend: sandbox ?? 'empty', sessionId: this.id, ...(this.options.cwd !== undefined ? { cwd: this.options.cwd } : {}) });
+            env = await createSandboxEnv({
+                backend: sandbox ?? "empty",
+                sessionId: this.id,
+                ...(this.options.cwd !== undefined ? { cwd: this.options.cwd } : {}),
+            });
         const scoped = createScopedSandboxEnv(env, this.options.cwd);
         return wrapWithPolicy(scoped, this.options.policy, this.options.bypassPolicyEnforcement);
     }
@@ -868,39 +1055,56 @@ export class StubFabricSession {
         const policy = callPolicy ?? this.options.policy;
         for (const call of calls) {
             const approvedSandboxCalls = [];
+            let approvalGrant;
             const tool = tools.get(call.tool);
+            const executingPrincipal = toolExecutingPrincipal(tool);
             const mountDecision = this.checkMountWriteAccess(call);
             const policyCall = tool?.policyAlias ? { ...call, tool: tool.policyAlias } : call;
             const decision = mountDecision ?? evaluateToolCallPolicy(policyCall, policy);
             if (!decision.allowed) {
                 if (decision.approvalRequired) {
-                    const approved = await this.requestApproval({
-                        kind: 'tool',
+                    const grant = await this.requestApproval({
+                        kind: "tool",
                         tool: call.tool,
+                        toolCallId: call.id ?? `${this.id}:${call.tool}`,
+                        ...(executingPrincipal ? { executingPrincipal } : {}),
                         input: call.input,
                         reason: decision.reason ?? `Approval required for tool: ${call.tool}`,
                         ...(decision.risk ? { risk: decision.risk } : {}),
                         ...(decision.matchedPattern ? { matchedPattern: decision.matchedPattern } : {}),
                         ...(decision.approvalAudience ? { audience: decision.approvalAudience } : {}),
-                        ...(decision.approvalTtlSeconds !== undefined ? { ttlSeconds: decision.approvalTtlSeconds } : {}),
+                        ...(decision.approvalTtlSeconds !== undefined
+                            ? { ttlSeconds: decision.approvalTtlSeconds }
+                            : {}),
                         affectedPaths: affectedPathsFromInput(call.input),
                     }, policy, approvalTimeoutMs, approvalHandler);
-                    if (approved) {
+                    if (grant) {
+                        approvalGrant = grant;
                         approvedSandboxCalls.push(policyCall);
                     }
                     else {
                         const error = decision.reason ?? `Approval required for tool call: ${call.tool}`;
-                        results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
-                        await this.recordEntry('error', { tool: call.tool, error, approvalRequired: true });
-                        await this.emit('error', { tool: call.tool, error, approvalRequired: true });
+                        results.push({
+                            tool: call.tool,
+                            input: call.input,
+                            error,
+                            ...(call.id ? { id: call.id } : {}),
+                        });
+                        await this.recordEntry("error", { tool: call.tool, error, approvalRequired: true });
+                        await this.emit("error", { tool: call.tool, error, approvalRequired: true });
                         continue;
                     }
                 }
                 else {
                     const error = decision.reason ?? `Tool call denied by policy: ${call.tool}`;
-                    results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
-                    await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
-                    await this.emit('error', { tool: call.tool, error, approvalRequired: false });
+                    results.push({
+                        tool: call.tool,
+                        input: call.input,
+                        error,
+                        ...(call.id ? { id: call.id } : {}),
+                    });
+                    await this.recordEntry("error", { tool: call.tool, error, approvalRequired: false });
+                    await this.emit("error", { tool: call.tool, error, approvalRequired: false });
                     continue;
                 }
             }
@@ -908,87 +1112,160 @@ export class StubFabricSession {
             if (!commandDecision.allowed) {
                 if (commandDecision.approvalRequired) {
                     const command = this.commandTextForApproval(tool, call.input);
-                    const approved = await this.requestApproval({
-                        kind: 'command',
+                    const grant = await this.requestApproval({
+                        kind: "command",
                         tool: call.tool,
+                        toolCallId: call.id ?? `${this.id}:${call.tool}`,
+                        ...(executingPrincipal ? { executingPrincipal } : {}),
                         ...(command ? { command } : {}),
                         input: call.input,
                         reason: commandDecision.reason ?? `Approval required for command: ${call.tool}`,
                         ...(commandDecision.risk ? { risk: commandDecision.risk } : {}),
-                        ...(commandDecision.matchedPattern ? { matchedPattern: commandDecision.matchedPattern } : {}),
-                        ...(commandDecision.approvalAudience ? { audience: commandDecision.approvalAudience } : {}),
-                        ...(commandDecision.approvalTtlSeconds !== undefined ? { ttlSeconds: commandDecision.approvalTtlSeconds } : {}),
+                        ...(commandDecision.matchedPattern
+                            ? { matchedPattern: commandDecision.matchedPattern }
+                            : {}),
+                        ...(commandDecision.approvalAudience
+                            ? { audience: commandDecision.approvalAudience }
+                            : {}),
+                        ...(commandDecision.approvalTtlSeconds !== undefined
+                            ? { ttlSeconds: commandDecision.approvalTtlSeconds }
+                            : {}),
                         envKeys: commandEnvKeys(tool),
                         affectedPaths: affectedPathsFromInput(call.input),
                     }, policy, approvalTimeoutMs, approvalHandler);
-                    if (!approved) {
+                    if (!grant) {
                         const error = commandDecision.reason ?? `Approval required for command: ${call.tool}`;
-                        results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
-                        await this.recordEntry('error', { tool: call.tool, error, approvalRequired: true });
-                        await this.emit('error', { tool: call.tool, error, approvalRequired: true });
+                        results.push({
+                            tool: call.tool,
+                            input: call.input,
+                            error,
+                            ...(call.id ? { id: call.id } : {}),
+                        });
+                        await this.recordEntry("error", { tool: call.tool, error, approvalRequired: true });
+                        await this.emit("error", { tool: call.tool, error, approvalRequired: true });
                         continue;
                     }
+                    approvalGrant = grant;
                     const approvedCommand = this.commandTextForApproval(tool, call.input);
                     if (approvedCommand)
-                        approvedSandboxCalls.push({ tool: 'bash', input: { command: approvedCommand } });
+                        approvedSandboxCalls.push({ tool: "bash", input: { command: approvedCommand } });
                 }
                 else {
                     const error = commandDecision.reason ?? `Command denied by policy: ${call.tool}`;
-                    results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
-                    await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
-                    await this.emit('error', { tool: call.tool, error, approvalRequired: false });
+                    results.push({
+                        tool: call.tool,
+                        input: call.input,
+                        error,
+                        ...(call.id ? { id: call.id } : {}),
+                    });
+                    await this.recordEntry("error", { tool: call.tool, error, approvalRequired: false });
+                    await this.emit("error", { tool: call.tool, error, approvalRequired: false });
                     continue;
                 }
             }
-            await this.recordEntry('tool_call', { tool: call.tool, input: call.input, ...(tool?.metadata?.effect ? { effect: tool.metadata.effect } : {}), ...(call.id ? { toolCallId: call.id } : {}), ...(attribution ? { attribution: attribution } : {}) });
-            await this.emit('tool_start', { tool: call.tool, ...(attribution ? { attribution: attribution } : {}) });
+            await this.recordEntry("tool_call", {
+                tool: call.tool,
+                input: call.input,
+                ...(tool?.metadata?.effect ? { effect: tool.metadata.effect } : {}),
+                ...(call.id ? { toolCallId: call.id } : {}),
+                ...(attribution ? { attribution: attribution } : {}),
+            });
+            await this.emit("tool_start", {
+                tool: call.tool,
+                ...(attribution ? { attribution: attribution } : {}),
+            });
             if (!tool?.execute) {
                 const error = `Tool is not available: ${call.tool}`;
-                results.push({ tool: call.tool, input: call.input, error, ...(call.id ? { id: call.id } : {}) });
-                await this.recordEntry('error', { tool: call.tool, error, approvalRequired: false });
-                await this.emit('tool_end', { tool: call.tool, error, ...(attribution ? { attribution: attribution } : {}) });
+                results.push({
+                    tool: call.tool,
+                    input: call.input,
+                    error,
+                    ...(call.id ? { id: call.id } : {}),
+                });
+                await this.recordEntry("error", { tool: call.tool, error, approvalRequired: false });
+                await this.emit("tool_end", {
+                    tool: call.tool,
+                    error,
+                    ...(attribution ? { attribution: attribution } : {}),
+                });
                 continue;
             }
             try {
-                const input = call.tool === 'bash' ? this.clampBashToolInput(call.input, policy) : call.input;
+                const input = call.tool === "bash" ? this.clampBashToolInput(call.input, policy) : call.input;
                 const startedAt = Date.now();
-                const execute = () => Promise.resolve(tool.execute?.(input, { sandbox, ...(signal ? { signal } : {}) }));
+                const execute = () => Promise.resolve(tool.execute?.(input, {
+                    sandbox,
+                    toolCallId: call.id ?? `${this.id}:${call.tool}`,
+                    ...(signal ? { signal } : {}),
+                    ...(approvalGrant ? { approval: approvalGrant } : {}),
+                }));
                 const output = await approvedSandboxCalls.reduceRight((next, approvedCall) => () => runWithSandboxPolicyApproval(sandbox, approvedCall, next), execute)();
                 const durationMs = Date.now() - startedAt;
                 results.push({ tool: call.tool, input, output, ...(call.id ? { id: call.id } : {}) });
-                await this.recordEntry('tool_result', { tool: call.tool, output: output, durationMs, ...(call.id ? { toolCallId: call.id } : {}), ...(attribution ? { attribution: attribution } : {}) });
-                await this.emit('tool_end', { tool: call.tool, durationMs, ...(attribution ? { attribution: attribution } : {}) });
+                await this.recordEntry("tool_result", {
+                    tool: call.tool,
+                    output: output,
+                    durationMs,
+                    ...(call.id ? { toolCallId: call.id } : {}),
+                    ...(attribution ? { attribution: attribution } : {}),
+                });
+                await this.emit("tool_end", {
+                    tool: call.tool,
+                    durationMs,
+                    ...(attribution ? { attribution: attribution } : {}),
+                });
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                results.push({ tool: call.tool, input: call.input, error: message, ...(call.id ? { id: call.id } : {}) });
-                await this.recordEntry('error', { tool: call.tool, error: message });
-                await this.emit('tool_end', { tool: call.tool, error: message, ...(attribution ? { attribution: attribution } : {}) });
+                results.push({
+                    tool: call.tool,
+                    input: call.input,
+                    error: message,
+                    ...(call.id ? { id: call.id } : {}),
+                });
+                await this.recordEntry("error", { tool: call.tool, error: message });
+                await this.emit("tool_end", {
+                    tool: call.tool,
+                    error: message,
+                    ...(attribution ? { attribution: attribution } : {}),
+                });
             }
         }
         return results;
     }
     async requestCostLimitApproval(ctx, approvalTimeoutMs, approvalHandler) {
-        return this.requestApproval({
-            kind: 'cost-limit',
+        return Boolean(await this.requestApproval({
+            kind: "cost-limit",
             input: ctx,
             reason: `Cost limit (${ctx.scope}) exceeded: $${ctx.observedUsd.toFixed(6)} > $${ctx.limitUsd.toFixed(6)}`,
             subject: `cost-limit/${ctx.scope}`,
-        }, this.options.policy, approvalTimeoutMs, approvalHandler);
+        }, this.options.policy, approvalTimeoutMs, approvalHandler));
     }
     async requestApproval(input, callPolicy, approvalTimeoutMs, approvalHandler) {
-        const id = input.idempotencyKey !== undefined
-            ? `${this.id}-approval-${createHash('sha256').update(`${input.kind}\0${input.idempotencyKey}`).digest('hex').slice(0, 32)}`
+        const executingPrincipal = input.executingPrincipal ?? this.approvalPrincipal();
+        let id = input.idempotencyKey !== undefined
+            ? `${this.id}-approval-${createHash("sha256").update(`${input.kind}\0${input.idempotencyKey}`).digest("hex").slice(0, 32)}`
             : `${this.id}-approval-${Date.now()}-${Math.random().toString(16).slice(2)}`;
         if (input.idempotencyKey !== undefined && this.store.getApprovalState) {
             const existing = await this.store.getApprovalState(this.id, id);
-            if (existing?.status === 'approved')
-                return true;
-            if (existing?.status === 'denied' || existing?.status === 'expired')
-                return false;
-            if (existing?.status === 'pending' && this.store.waitForApproval) {
+            if (existing?.status === "approved") {
+                const grant = approvalGrantFromState(existing, input.input, executingPrincipal, input.toolCallId ?? id);
+                if (grant)
+                    return grant;
+                // Pre-provenance approvals cannot authorize a model-facing operation.
+                // Ask again under a new id so upgraded durable sessions recover safely.
+                id = `${id}-provenance-${Date.now()}`;
+            }
+            if (existing?.status === "denied" || existing?.status === "expired")
+                return undefined;
+            if (existing?.status === "pending" && this.store.waitForApproval) {
                 const response = await this.waitForStoredApproval(existing.request, approvalTimeoutMs ?? callPolicy?.approvals?.defaultTimeoutMs);
-                return response?.decision === 'approved';
+                if (response?.decision !== "approved")
+                    return undefined;
+                const resolved = await this.store.getApprovalState(this.id, id);
+                return resolved
+                    ? approvalGrantFromState(resolved, input.input, executingPrincipal, input.toolCallId ?? id)
+                    : undefined;
             }
         }
         const request = {
@@ -999,27 +1276,34 @@ export class StubFabricSession {
             kind: input.kind,
             createdAt: new Date().toISOString(),
             ...(input.risk ? { risk: input.risk } : {}),
-            ...(callPolicy?.approvals?.requiredApprovals ? { requiredApprovals: callPolicy.approvals.requiredApprovals } : {}),
+            ...(callPolicy?.approvals?.requiredApprovals
+                ? { requiredApprovals: callPolicy.approvals.requiredApprovals }
+                : {}),
             ...(callPolicy?.approvals?.escalation ? { escalation: callPolicy.approvals.escalation } : {}),
             ...(input.matchedPattern ? { matchedPattern: input.matchedPattern } : {}),
             ...(input.envKeys && input.envKeys.length > 0 ? { envKeys: input.envKeys } : {}),
-            ...(input.affectedPaths && input.affectedPaths.length > 0 ? { affectedPaths: input.affectedPaths } : {}),
+            ...(input.affectedPaths && input.affectedPaths.length > 0
+                ? { affectedPaths: input.affectedPaths }
+                : {}),
             ...(input.tool ? { tool: input.tool } : {}),
             ...(input.command ? { command: input.command } : {}),
             ...(isJsonValue(input.input) ? { input: input.input } : {}),
+            toolCallId: input.toolCallId ?? id,
+            inputDigest: approvalInputDigest(input.input),
+            executingPrincipal,
             ...(this.options.actor ? { actor: this.options.actor } : {}),
             ...(input.audience ? { audience: input.audience } : {}),
             ...(input.ttlSeconds !== undefined ? { ttlSeconds: input.ttlSeconds } : {}),
             ...(this.options.tenantId ? { tenantId: this.options.tenantId } : {}),
         };
-        await this.recordEntry('approval_requested', request);
-        await this.emit('approval_requested', request);
+        await this.recordEntry("approval_requested", request);
+        await this.emit("approval_requested", request);
         const handler = approvalHandler ?? this.options.onApproval;
         const autonomy = this.effectiveAutonomy();
         const waitTimeout = approvalTimeoutMs ?? callPolicy?.approvals?.defaultTimeoutMs;
         const durable = await this.getDurableRuntime();
-        const hasDurableApprovalChannel = typeof durable?.approvalRequest === 'function';
-        const hasStoredApprovalBackend = typeof this.store.waitForApproval === 'function';
+        const hasDurableApprovalChannel = typeof durable?.approvalRequest === "function";
+        const hasStoredApprovalBackend = typeof this.store.waitForApproval === "function";
         let response;
         if (handler) {
             response = normalizeApprovalResponse(await handler(request));
@@ -1042,25 +1326,66 @@ export class StubFabricSession {
                 ? `Approval unavailable in ${autonomy.mode} mode: no approval handler, durable runtime channel, or store waiter is configured (${autonomy.onApprovalUnavailable}).`
                 : waitTimeout !== undefined
                     ? `Approval timed out after ${waitTimeout}ms`
-                    : 'No approval response was received';
-            if (!handler && !hasStoredApprovalBackend && !hasDurableApprovalChannel && autonomy.onApprovalUnavailable === 'deny') {
-                await this.recordEntry('approval_denied', { approvalId: id, reason: unavailableReason });
-                await this.emit('approval_denied', { approvalId: id, reason: unavailableReason });
+                    : "No approval response was received";
+            if (!handler &&
+                !hasStoredApprovalBackend &&
+                !hasDurableApprovalChannel &&
+                autonomy.onApprovalUnavailable === "deny") {
+                await this.recordEntry("approval_denied", { approvalId: id, reason: unavailableReason });
+                await this.emit("approval_denied", { approvalId: id, reason: unavailableReason });
             }
             else {
-                await this.recordEntry('approval_expired', { approvalId: id, reason: unavailableReason });
-                await this.emit('approval_expired', { approvalId: id, reason: unavailableReason });
+                await this.recordEntry("approval_expired", { approvalId: id, reason: unavailableReason });
+                await this.emit("approval_expired", { approvalId: id, reason: unavailableReason });
             }
-            return false;
+            return undefined;
         }
-        if (response.decision === 'approved') {
-            await this.recordEntry('approval_granted', { approvalId: id, reason: response.reason ?? 'Approved by handler' });
-            await this.emit('approval_granted', { approvalId: id, reason: response.reason ?? 'Approved by handler' });
-            return true;
+        if (response.decision === "approved") {
+            if (this.store.getApprovalState) {
+                const resolved = await this.store.getApprovalState(this.id, id);
+                const persisted = resolved
+                    ? approvalGrantFromState(resolved, input.input, executingPrincipal, input.toolCallId ?? id)
+                    : undefined;
+                if (persisted)
+                    return persisted;
+            }
+            const grant = createApprovalGrant({
+                approvalId: id,
+                toolCallId: input.toolCallId ?? id,
+                toolInput: input.input,
+                principal: executingPrincipal,
+                response,
+                createdAt: request.createdAt,
+                ...(request.ttlSeconds !== undefined ? { ttlSeconds: request.ttlSeconds } : {}),
+            });
+            const grantData = grant;
+            await this.recordEntry("approval_granted", {
+                approvalId: id,
+                reason: response.reason ?? "Approved by handler",
+                grant: grantData,
+            });
+            await this.emit("approval_granted", {
+                approvalId: id,
+                reason: response.reason ?? "Approved by handler",
+                grant: grantData,
+            });
+            return grant;
         }
-        await this.recordEntry('approval_denied', { approvalId: id, reason: response.reason ?? 'Denied by handler' });
-        await this.emit('approval_denied', { approvalId: id, reason: response.reason ?? 'Denied by handler' });
-        return false;
+        await this.recordEntry("approval_denied", {
+            approvalId: id,
+            reason: response.reason ?? "Denied by handler",
+        });
+        await this.emit("approval_denied", {
+            approvalId: id,
+            reason: response.reason ?? "Denied by handler",
+        });
+        return undefined;
+    }
+    approvalPrincipal() {
+        return (this.options.actor?.principal ?? {
+            kind: "app-principal",
+            id: `fabric-session:${this.id}`,
+        });
     }
     async waitForStoredApproval(request, timeoutMs) {
         if (!this.store.waitForApproval)
@@ -1069,39 +1394,45 @@ export class StubFabricSession {
     }
     effectiveAutonomy() {
         return {
-            mode: this.options.autonomy?.mode ?? 'background',
-            onMissingInput: this.options.autonomy?.onMissingInput ?? 'assume',
-            onApprovalUnavailable: this.options.autonomy?.onApprovalUnavailable ?? 'fail',
-            onCredentialMissing: this.options.autonomy?.onCredentialMissing ?? 'fail',
+            mode: this.options.autonomy?.mode ?? "background",
+            onMissingInput: this.options.autonomy?.onMissingInput ?? "assume",
+            onApprovalUnavailable: this.options.autonomy?.onApprovalUnavailable ?? "fail",
+            onCredentialMissing: this.options.autonomy?.onCredentialMissing ?? "fail",
         };
     }
     evaluateScopedCommandToolCall(tool, input, policy) {
-        if (tool?.metadata?.kind !== 'command' || typeof tool.metadata.command !== 'string')
+        if (tool?.metadata?.kind !== "command" || typeof tool.metadata.command !== "string")
             return { allowed: true };
-        const args = typeof input === 'object' && input !== null && Array.isArray(input.args)
-            ? input.args.filter((value) => typeof value === 'string')
+        const args = typeof input === "object" &&
+            input !== null &&
+            Array.isArray(input.args)
+            ? input.args.filter((value) => typeof value === "string")
             : [];
-        const command = [tool.metadata.command, ...args.map(shellQuote)].join(' ');
+        const command = [tool.metadata.command, ...args.map(shellQuote)].join(" ");
         return evaluateCommandPolicy(command, policy);
     }
     commandTextForApproval(tool, input) {
-        if (tool?.metadata?.kind !== 'command' || typeof tool.metadata.command !== 'string')
+        if (tool?.metadata?.kind !== "command" || typeof tool.metadata.command !== "string")
             return undefined;
-        const args = typeof input === 'object' && input !== null && Array.isArray(input.args)
-            ? input.args.filter((value) => typeof value === 'string')
+        const args = typeof input === "object" &&
+            input !== null &&
+            Array.isArray(input.args)
+            ? input.args.filter((value) => typeof value === "string")
             : [];
-        return [tool.metadata.command, ...args].join(' ');
+        return [tool.metadata.command, ...args].join(" ");
     }
     clampBashToolInput(input, policy) {
-        if (!policy?.maxCommandTimeoutMs || typeof input !== 'object' || input === null)
+        if (!policy?.maxCommandTimeoutMs || typeof input !== "object" || input === null)
             return input;
         const record = input;
-        const timeout = typeof record.timeout === 'number' ? record.timeout : undefined;
+        const timeout = typeof record.timeout === "number" ? record.timeout : undefined;
         return { ...record, timeout: clampCommandTimeout(timeout, policy) };
     }
     resolveTools(sandbox, promptTools = [], promptCommands = []) {
         const tools = new Map();
-        const commandToolOptions = this.options.resolveSecret ? { resolveSecret: this.options.resolveSecret } : {};
+        const commandToolOptions = this.options.resolveSecret
+            ? { resolveSecret: this.options.resolveSecret }
+            : {};
         for (const tool of createBuiltinTools(sandbox, this.options.packagedSkills))
             tools.set(tool.name, tool);
         for (const tool of createCommandTools(this.options.commands ?? [], commandToolOptions))
@@ -1153,18 +1484,20 @@ export class StubFabricSession {
                 skill.name,
                 skill.relativePath,
                 skill.relativePath ? stripMarkdownExtension(skill.relativePath) : undefined,
-                skill.relativePath?.endsWith('/SKILL.md') ? skill.relativePath.slice(0, -'/SKILL.md'.length) : undefined,
+                skill.relativePath?.endsWith("/SKILL.md")
+                    ? skill.relativePath.slice(0, -"/SKILL.md".length)
+                    : undefined,
                 skill.path,
                 skill.path ? stripMarkdownExtension(skill.path) : undefined,
-                skill.path?.endsWith('/SKILL.md') ? skill.path.slice(0, -'/SKILL.md'.length) : undefined,
-            ].filter((value) => typeof value === 'string');
+                skill.path?.endsWith("/SKILL.md") ? skill.path.slice(0, -"/SKILL.md".length) : undefined,
+            ].filter((value) => typeof value === "string");
             return candidates.some((candidate) => normalizeSkillReference(candidate) === normalized);
         });
     }
     resolveRole(role) {
         if (!role)
             return undefined;
-        if (typeof role !== 'string')
+        if (typeof role !== "string")
             return role;
         return this.options.roles?.find((candidate) => candidate.name === role);
     }
@@ -1184,9 +1517,11 @@ export class StubFabricSession {
         if (existing) {
             // Cross-tenant access guard: a session that already belongs to a
             // different tenant should not be silently appended to.
-            if (this.options.tenantId !== undefined && existing.tenantId !== undefined && existing.tenantId !== this.options.tenantId) {
+            if (this.options.tenantId !== undefined &&
+                existing.tenantId !== undefined &&
+                existing.tenantId !== this.options.tenantId) {
                 throw new FabricError({
-                    code: 'POLICY_DENIED',
+                    code: "POLICY_DENIED",
                     message: `Session ${this.id} belongs to tenant ${existing.tenantId}; refusing to append from tenant ${this.options.tenantId}.`,
                     retryable: false,
                 });
@@ -1234,37 +1569,37 @@ export class StubFabricSession {
         if (dangling.length === 0 && unfinishedTasks.length === 0)
             return;
         for (const call of dangling) {
-            const tool = typeof call.data?.tool === 'string' ? call.data.tool : 'unknown';
-            const toolCallId = typeof call.data?.toolCallId === 'string' ? call.data.toolCallId : undefined;
-            await this.recordEntry('tool_result', {
+            const tool = typeof call.data?.tool === "string" ? call.data.tool : "unknown";
+            const toolCallId = typeof call.data?.toolCallId === "string" ? call.data.toolCallId : undefined;
+            await this.recordEntry("tool_result", {
                 tool,
                 ...(toolCallId ? { toolCallId } : {}),
                 output: {
-                    type: 'interrupted',
-                    message: 'Tool execution was interrupted before completion. The outcome is unknown.',
+                    type: "interrupted",
+                    message: "Tool execution was interrupted before completion. The outcome is unknown.",
                 },
                 isError: true,
                 interrupted: true,
                 synthetic: true,
             });
-            await this.emit('tool_end', { tool, error: 'interrupted', synthetic: true });
+            await this.emit("tool_end", { tool, error: "interrupted", synthetic: true });
         }
         for (const task of unfinishedTasks) {
-            const taskId = typeof task.data?.taskId === 'string' ? task.data.taskId : 'unknown';
-            await this.recordEntry('task_end', {
+            const taskId = typeof task.data?.taskId === "string" ? task.data.taskId : "unknown";
+            await this.recordEntry("task_end", {
                 taskId,
-                status: 'interrupted',
+                status: "interrupted",
                 synthetic: true,
                 // Keep the child transcript locatable from the settled record.
-                ...(typeof task.data?.agent === 'string' ? { agent: task.data.agent } : {}),
+                ...(typeof task.data?.agent === "string" ? { agent: task.data.agent } : {}),
             });
         }
         if (dangling.length > 0) {
             const tools = dangling
-                .map((call) => (typeof call.data?.tool === 'string' ? call.data.tool : 'unknown'))
-                .join(', ');
-            await this.recordEntry('signal', {
-                signalType: 'interrupted',
+                .map((call) => (typeof call.data?.tool === "string" ? call.data.tool : "unknown"))
+                .join(", ");
+            await this.recordEntry("signal", {
+                signalType: "interrupted",
                 content: `The previous turn was interrupted; ${dangling.length} tool call(s) did not complete and may or may not have taken effect: ${tools}. Verify their effects before repeating side-effecting operations.`,
             });
         }
@@ -1301,43 +1636,50 @@ export class StubFabricSession {
     }
 }
 function normalizeSkillReference(value) {
-    return stripMarkdownExtension(value.replace(/\\/g, '/').replace(/^\.\//, '').replace(/^skills\//, '').replace(/^\.fabricharness\/skills\//, '').replace(/^\/+/, ''));
+    return stripMarkdownExtension(value
+        .replace(/\\/g, "/")
+        .replace(/^\.\//, "")
+        .replace(/^skills\//, "")
+        .replace(/^\.fabricharness\/skills\//, "")
+        .replace(/^\/+/, ""));
 }
 function stripMarkdownExtension(value) {
-    return value.endsWith('.md') ? value.slice(0, -3) : value;
+    return value.endsWith(".md") ? value.slice(0, -3) : value;
 }
 function affectedPathsFromInput(input) {
-    if (typeof input !== 'object' || input === null)
+    if (typeof input !== "object" || input === null)
         return [];
     const record = input;
-    const paths = [record.path, record.cwd].filter((value) => typeof value === 'string');
+    const paths = [record.path, record.cwd].filter((value) => typeof value === "string");
     return [...new Set(paths)];
 }
 function commandEnvKeys(tool) {
     const value = tool?.metadata?.envKeys;
-    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
 }
 function normalizeApprovalResponse(value) {
-    if (typeof value === 'boolean')
-        return { decision: value ? 'approved' : 'denied' };
-    if (typeof value === 'string')
+    if (typeof value === "boolean")
+        return { decision: value ? "approved" : "denied" };
+    if (typeof value === "string")
         return { decision: value };
     return value;
 }
 function readStringPropertyFromInput(input, key) {
-    if (typeof input !== 'object' || input === null || !(key in input))
+    if (typeof input !== "object" || input === null || !(key in input))
         return undefined;
     const value = input[key];
-    return typeof value === 'string' ? value : undefined;
+    return typeof value === "string" ? value : undefined;
 }
 function isJsonValue(value) {
     if (value === null)
         return true;
-    if (['string', 'number', 'boolean'].includes(typeof value))
+    if (["string", "number", "boolean"].includes(typeof value))
         return true;
     if (Array.isArray(value))
         return value.every(isJsonValue);
-    if (typeof value !== 'object')
+    if (typeof value !== "object")
         return false;
     return Object.values(value).every(isJsonValue);
 }
@@ -1347,41 +1689,41 @@ function redactEnvValues(text, env) {
     let result = text;
     for (const [key, value] of Object.entries(env)) {
         if (key.length > 0) {
-            result = result.replaceAll(key, '[REDACTED]');
+            result = result.replaceAll(key, "[REDACTED]");
         }
         if (value.length > 0) {
-            result = result.replaceAll(value, '[REDACTED]');
+            result = result.replaceAll(value, "[REDACTED]");
         }
     }
     return result;
 }
 function summarizeEntries(entries) {
     if (entries.length === 0)
-        return 'No entries to compact.';
+        return "No entries to compact.";
     const counts = new Map();
     for (const entry of entries)
         counts.set(entry.type, (counts.get(entry.type) ?? 0) + 1);
-    const summary = [...counts.entries()].map(([type, count]) => `${type}: ${count}`).join(', ');
+    const summary = [...counts.entries()].map(([type, count]) => `${type}: ${count}`).join(", ");
     const first = entries[0];
     const last = entries.at(-1);
-    return `Compacted ${entries.length} entries (${summary}). Range: ${first?.timestamp ?? 'unknown'} to ${last?.timestamp ?? 'unknown'}.`;
+    return `Compacted ${entries.length} entries (${summary}). Range: ${first?.timestamp ?? "unknown"} to ${last?.timestamp ?? "unknown"}.`;
 }
 function collectFileReferences(entries) {
     const readFiles = new Set();
     const modifiedFiles = new Set();
     for (const entry of entries) {
-        if (entry.type === 'tool_call') {
-            const tool = typeof entry.data?.tool === 'string' ? entry.data.tool : undefined;
-            const effect = typeof entry.data?.effect === 'string' ? entry.data.effect : undefined;
+        if (entry.type === "tool_call") {
+            const tool = typeof entry.data?.tool === "string" ? entry.data.tool : undefined;
+            const effect = typeof entry.data?.effect === "string" ? entry.data.effect : undefined;
             const input = entry.data?.input;
             for (const path of filePathsFromToolInput(input)) {
-                if (effect === 'read' || (!effect && isReadOnlyFileTool(tool)))
+                if (effect === "read" || (!effect && isReadOnlyFileTool(tool)))
                     readFiles.add(path);
-                if (effect === 'write' || (!effect && isMutatingFileTool(tool)))
+                if (effect === "write" || (!effect && isMutatingFileTool(tool)))
                     modifiedFiles.add(path);
             }
         }
-        if (entry.type === 'shell_command' && typeof entry.data?.cwd === 'string')
+        if (entry.type === "shell_command" && typeof entry.data?.cwd === "string")
             readFiles.add(entry.data.cwd);
     }
     return { readFiles: [...readFiles].sort(), modifiedFiles: [...modifiedFiles].sort() };
@@ -1389,17 +1731,17 @@ function collectFileReferences(entries) {
 function appendFileReferenceTags(summary, refs) {
     const sections = [summary];
     if (refs.readFiles.length > 0)
-        sections.push(`<read-files>\n${refs.readFiles.join('\n')}\n</read-files>`);
+        sections.push(`<read-files>\n${refs.readFiles.join("\n")}\n</read-files>`);
     if (refs.modifiedFiles.length > 0)
-        sections.push(`<modified-files>\n${refs.modifiedFiles.join('\n')}\n</modified-files>`);
-    return sections.join('\n\n');
+        sections.push(`<modified-files>\n${refs.modifiedFiles.join("\n")}\n</modified-files>`);
+    return sections.join("\n\n");
 }
 /** Valid cut points: user prompts and assistant messages. Never cut at tool_result. */
 function findValidCutPoints(entries, start, end) {
     const cutPoints = [];
     for (let i = start; i < end; i++) {
         const type = entries[i]?.type;
-        if (type === 'user_prompt' || type === 'assistant_message') {
+        if (type === "user_prompt" || type === "assistant_message") {
             cutPoints.push(i);
         }
     }
@@ -1407,7 +1749,7 @@ function findValidCutPoints(entries, start, end) {
 }
 function findTurnStartIndex(entries, index, start) {
     for (let i = index; i >= start; i--) {
-        if (entries[i]?.type === 'user_prompt')
+        if (entries[i]?.type === "user_prompt")
             return i;
     }
     return -1;
@@ -1434,7 +1776,7 @@ function findCutPoint(entries, start, end, keepRecentTokens) {
             break;
         }
     }
-    const isUserMessage = entries[firstKeptIndex]?.type === 'user_prompt';
+    const isUserMessage = entries[firstKeptIndex]?.type === "user_prompt";
     const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, firstKeptIndex, start);
     return {
         firstKeptIndex,
@@ -1466,30 +1808,49 @@ export function prepareCompaction(entries, keepRecentTokens, previousCompaction)
     };
 }
 function isReadOnlyFileTool(tool) {
-    return tool !== undefined && ['read', 'read_buffer', 'stat', 'readdir', 'exists', 'grep', 'glob'].includes(tool);
+    return (tool !== undefined &&
+        ["read", "read_buffer", "stat", "readdir", "exists", "grep", "glob"].includes(tool));
 }
 function isMutatingFileTool(tool) {
-    return tool !== undefined && ['write', 'edit', 'mkdir', 'rm'].includes(tool);
+    return tool !== undefined && ["write", "edit", "mkdir", "rm"].includes(tool);
+}
+function toolExecutingPrincipal(tool) {
+    const value = tool?.metadata?.executingPrincipal;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const principal = value;
+    if ((principal.kind !== "user" &&
+        principal.kind !== "service-principal" &&
+        principal.kind !== "app-principal") ||
+        typeof principal.id !== "string")
+        return undefined;
+    return value;
 }
 function filePathsFromToolInput(input) {
-    if (typeof input !== 'object' || input === null)
+    if (typeof input !== "object" || input === null)
         return [];
     const record = input;
     const values = [record.path, record.cwd, record.pattern];
     if (Array.isArray(record.paths))
         values.push(...record.paths);
-    return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+    return [
+        ...new Set(values.filter((value) => typeof value === "string" && value.length > 0)),
+    ];
 }
 function isSnapshot(value) {
-    return typeof value === 'object' && value !== null && 'id' in value && typeof value.id === 'string';
+    return (typeof value === "object" &&
+        value !== null &&
+        "id" in value &&
+        typeof value.id === "string");
 }
 function abortError() {
-    const error = new Error('Task cancelled');
-    error.name = 'AbortError';
+    const error = new Error("Task cancelled");
+    error.name = "AbortError";
     return error;
 }
 function isAbortError(error) {
-    return error instanceof Error && (error.name === 'AbortError' || /aborted|cancelled|canceled/i.test(error.message));
+    return (error instanceof Error &&
+        (error.name === "AbortError" || /aborted|cancelled|canceled/i.test(error.message)));
 }
 function wrapWithPolicy(env, policy, bypass) {
     if (bypass === true)
@@ -1511,10 +1872,10 @@ function wrapWithPolicy(env, policy, bypass) {
  */
 function resolveMountPath(cwd, mountAt) {
     const normalized = path.posix.normalize(mountAt);
-    if (!normalized.startsWith('/'))
+    if (!normalized.startsWith("/"))
         return path.posix.join(cwd, normalized);
     if (normalized === cwd || normalized.startsWith(`${cwd}/`))
         return normalized;
-    return path.posix.join(cwd, normalized.replace(/^\/+/, ''));
+    return path.posix.join(cwd, normalized.replace(/^\/+/, ""));
 }
 //# sourceMappingURL=session.js.map