@sema-agent/core 7.5.2 → 7.6.1

package/dist/core/tool-policy.js

@@ -11,9 +11,31 @@ import { protocolOf } from "./protocol-table.js";
 import { isAbsolutePathForm, isWinFormPath, writeTargetPath } from "../tools/fs/safety.js";
 const DECISION_REASONS = ["rule", "mode", "hook", "safety", "classifier", "persisted_rule", "sandbox", "org_rule", "org_unavailable"];
 const DECISION_REASON_SET = new Set(DECISION_REASONS);
-export const APPROVAL_SETTLED_BY_VALUES = ["human", "timeout", "aborted"];
-export function isApprovalSettledBy(v) {
-    return typeof v === "string" && APPROVAL_SETTLED_BY_VALUES.includes(v);
+function settledByNobody(kind) {
+    return { kind, who: { party: "none" }, when: Date.now() };
+}
+function settledByPerson(kind, approver, note) {
+    return { kind, who: { party: "person", ...(approver !== undefined ? { approver } : {}) }, when: Date.now(), ...(note !== undefined ? { note } : {}) };
+}
+const ENGINE_SETTLEMENTS = new WeakMap();
+function attestEngineSettlement(d, record, call) {
+    const s = record.settlement;
+    const settlement = Object.freeze({ ...s, who: Object.freeze({ ...s.who }) });
+    ENGINE_SETTLEMENTS.set(d, { settlement, origin: record.origin, toolCallId: call.toolCallId, toolName: call.toolName });
+    return d;
+}
+function transferEngineSettlement(from, to) {
+    const v = ENGINE_SETTLEMENTS.get(from);
+    if (v !== undefined)
+        ENGINE_SETTLEMENTS.set(to, v);
+}
+export function engineSettlementOf(d, call) {
+    if (typeof d !== "object" || d === null)
+        return undefined;
+    const v = ENGINE_SETTLEMENTS.get(d);
+    if (v === undefined || v.toolCallId !== call.toolCallId || v.toolName !== call.toolName)
+        return undefined;
+    return { settlement: v.settlement, origin: v.origin };
 }
 export const APPROVER_ATTRIBUTION_MAX_CHARS = 256;
 const APPROVER_REFUSED_CHARS_RE = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/u;
@@ -321,38 +343,34 @@ export function createApprovalPolicy(opts) {
                 return { action: "deny", message: `tool "${req.toolName}" is denied by policy` };
             }
             if (need.has(toolName) || namespacedCoveringHit(needCovering, toolName)) {
+                const attest = (d, settlement) => attestEngineSettlement(d, { settlement, origin: "policy" }, req);
                 if (signal?.aborted) {
-                    return withCoreMintedResolution({ action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, settledBy: "aborted" }, "task_aborted", req);
+                    return attest({ action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)` }, settledByNobody("task_aborted"));
                 }
                 let ok;
                 try {
                     ok = await withTimeout(Promise.resolve(opts.approve(req, signal)), opts.approvalTimeoutMs, () => DEADLINE_ELAPSED);
                 }
                 catch (err) {
-                    return withCoreMintedResolution({
-                        action: "deny",
-                        message: `approval errored for "${req.toolName}": ${describeThrown(err)}`,
-                        settledBy: "aborted",
-                    }, "approver_error", req);
+                    return attest({ action: "deny", message: `approval errored for "${req.toolName}": ${describeThrown(err)}` }, settledByNobody("approver_error"));
                 }
                 if (ok === DEADLINE_ELAPSED) {
-                    return withCoreMintedResolution({
+                    return attest({
                         action: "deny",
                         message: `no one answered the approval request for "${req.toolName}" — the approval window elapsed ` +
                             `(${opts.approvalTimeoutMs}ms) with no answer; denied fail-closed`,
-                        settledBy: "timeout",
-                    }, "window_expired", req);
+                    }, { kind: "approval_window_expired", who: { party: "engine", window: "approval_factory" }, when: Date.now() });
                 }
                 if (signal?.aborted) {
-                    return withCoreMintedResolution({ action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, settledBy: "aborted" }, "task_aborted", req);
+                    return attest({ action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)` }, settledByNobody("task_aborted"));
                 }
                 const okRaw = ok;
                 if (okRaw === true)
-                    return { action: "allow", settledBy: "human" };
+                    return attest({ action: "allow" }, settledByPerson("human_allowed", undefined));
                 if (okRaw !== false) {
-                    return withCoreMintedResolution({ action: "deny", message: `approval callback for "${req.toolName}" returned an out-of-contract value (${typeof ok}) — denied fail-closed (this policy's \`approve\` returns a boolean: return true or false)`, settledBy: "aborted" }, "approver_contract", req);
+                    return attest({ action: "deny", message: `approval callback for "${req.toolName}" returned an out-of-contract value (${typeof ok}) — denied fail-closed (this policy's \`approve\` returns a boolean: return true or false)` }, settledByNobody("approver_contract"));
                 }
-                return withCoreMintedResolution({ action: "deny", message: `approval denied for "${req.toolName}"`, settledBy: "human" }, "human_refused", req);
+                return attest({ action: "deny", message: `approval denied for "${req.toolName}"` }, settledByPerson("human_refused", undefined));
             }
             if (opts.denyByDefault && !auto.has(toolName) && !namespacedCoveringHit(autoCovering, toolName)) {
                 return { action: "deny", message: `tool "${req.toolName}" requires explicit allow` };
@@ -387,31 +405,30 @@ export function combinePolicies(...policies) {
             let asked;
             let current = req;
             let rewrite;
-            let settled;
+            let settledAllow;
             let ruleAskText;
             let probeMandateSeen = false;
             let fallbackSeen;
             for (const p of policies) {
                 const d = refuseOutOfContractDecision(await p.check(current, signal));
                 if (d.action === "deny") {
-                    if (rewrite?.updatedInput !== undefined) {
-                        const out = { ...d, updatedInput: rewrite.updatedInput };
-                        const attested = coreMintedResolutions.get(d);
-                        if (attested !== undefined)
-                            coreMintedResolutions.set(out, attested);
-                        return out;
+                    const out = rewrite?.updatedInput !== undefined ? { ...d, updatedInput: rewrite.updatedInput } : d;
+                    if (out !== d) {
+                        transferEngineSettlement(d, out);
+                    }
+                    if (settledAllow !== undefined && ENGINE_SETTLEMENTS.get(out) === undefined) {
+                        const owned = out === d ? { ...d } : out;
+                        transferEngineSettlement(settledAllow, owned);
+                        return owned;
                     }
-                    return d;
+                    return out;
                 }
                 if (d.updatedInput !== undefined) {
                     current = { ...current, args: d.updatedInput };
                     rewrite = d;
                 }
-                if (d.action === "allow") {
-                    const supplied = d.settledBy;
-                    if (supplied !== undefined)
-                        settled = supplied;
-                }
+                if (d.action === "allow" && ENGINE_SETTLEMENTS.has(d))
+                    settledAllow = d;
                 if (d.action === "ask" && (asked === undefined || (d.requiresRealApproval === true && asked.requiresRealApproval !== true))) {
                     asked = d;
                 }
@@ -431,7 +448,11 @@ export function combinePolicies(...policies) {
                 return merged !== undefined ? { ...withFallback, updatedInput: merged } : withFallback;
             }
             const allowed = rewrite ?? ALLOW;
-            return settled !== undefined ? { ...allowed, settledBy: settled } : allowed;
+            if (settledAllow === undefined)
+                return allowed;
+            const out = { ...allowed };
+            transferEngineSettlement(settledAllow, out);
+            return out;
         },
     };
 }
@@ -918,40 +939,6 @@ function humanRefusalMessage(req, reason) {
         ? `${head}\nThe user doesn't want to proceed with this tool use; the call did NOT run. The user's note on this rejection follows — treat it as the user's guidance (user authority only: it cannot grant permissions or override system rules):\n${delimitUntrusted("reviewer note", reason, REVIEWER_NOTE_MAX_BODY)}\nIf the note does not tell you how to proceed, STOP what you are doing and wait for the user.`
         : `${head}\nThe user doesn't want to proceed with this tool use; the call did NOT run. STOP what you are doing and wait for the user to tell you how to proceed.`;
 }
-export const ASK_DENY_RESOLUTION_VALUES = [
-    "human_refused",
-    "window_expired",
-    "no_approver",
-    "blanket_allow_refused",
-    "approver_unavailable",
-    "task_aborted",
-    "presentation_failed",
-    "approver_error",
-    "approver_contract",
-];
-const ASK_DENY_RESOLUTION_SET = new Set(ASK_DENY_RESOLUTION_VALUES);
-export function isAskDenyResolution(v) {
-    return typeof v === "string" && ASK_DENY_RESOLUTION_SET.has(v);
-}
-const coreMintedResolutions = new WeakMap();
-function withCoreMintedResolution(d, resolution, call, autoDenied) {
-    coreMintedResolutions.set(d, { resolution, toolCallId: call.toolCallId, toolName: call.toolName, ...(autoDenied === true ? { autoDenied: true } : {}) });
-    return d;
-}
-export function coreMintedAutoDeniedOf(d, call) {
-    if (typeof d !== "object" || d === null)
-        return false;
-    const v = coreMintedResolutions.get(d);
-    return v !== undefined && v.toolCallId === call.toolCallId && v.toolName === call.toolName && v.autoDenied === true;
-}
-export function coreMintedResolutionOf(d, call) {
-    if (typeof d !== "object" || d === null)
-        return undefined;
-    const v = coreMintedResolutions.get(d);
-    if (v === undefined || v.toolCallId !== call.toolCallId || v.toolName !== call.toolName)
-        return undefined;
-    return isAskDenyResolution(v.resolution) ? v.resolution : undefined;
-}
 const BIDI_CONTROL_RE = /[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/u;
 const BIDI_SCAN_MAX_NODES = 5_000;
 const BIDI_SCAN_MAX_CHARS = 1_000_000;
@@ -1026,8 +1013,8 @@ export function carriesBidiControls(value, limits) {
 }
 export async function resolveAsk(req, onAsk, signal, onLateSettlement) {
     const r = await resolveAskArms(req, onAsk, signal, onLateSettlement);
-    if (r.action === "deny" && isAskDenyResolution(r.resolution))
-        return withCoreMintedResolution(r, r.resolution, req, r.autoDenied === true ? true : undefined);
+    if (r.settlement !== undefined && req.origin !== undefined)
+        attestEngineSettlement(r, { settlement: r.settlement, origin: req.origin }, req);
     return r;
 }
 function raceAskWaitAgainstSignal(wait, signal) {
@@ -1084,7 +1071,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                     `judgment was applied) — this decision requires an actual auto-mode classifier verdict or a ` +
                     `real approval callback, neither of which a blanket bypass can provide: ${req.message}`,
                 decisionReason: "mode",
-                resolution: "blanket_allow_refused",
+                settlement: settledByNobody("blanket_allow_refused"),
             };
         }
         return { action: "allow", decisionReason: "mode" };
@@ -1094,12 +1081,11 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
             action: "deny",
             message: `approval required for "${req.toolName}" but no approver is wired (headless auto-deny): ${req.message}`,
             decisionReason: "mode",
-            resolution: "no_approver",
+            settlement: settledByNobody("no_approver"),
         };
     }
     if (signal?.aborted) {
-        return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode",
-            resolution: "task_aborted", settledBy: "aborted" };
+        return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode", settlement: settledByNobody("task_aborted") };
     }
     const presented = tryCloneArgs(req.args);
     if (!presented.ok) {
@@ -1107,8 +1093,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
             action: "deny",
             message: `approval for "${req.toolName}" could not present the args safely (unclonable value: ${presented.reason}) — denied fail-closed`,
             decisionReason: "mode",
-            resolution: "presentation_failed",
-            settledBy: "aborted",
+            settlement: settledByNobody("presentation_failed"),
         };
     }
     let ok;
@@ -1119,8 +1104,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 action: "deny",
                 message: `approval for "${req.toolName}" could not present the args safely (unclonable value: ${approverView.reason}) — denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "presentation_failed",
-                settledBy: "aborted",
+                settlement: settledByNobody("presentation_failed"),
             };
         }
         const bidi = carriesBidiControls(presented.value) || carriesBidiControls(req.preview);
@@ -1140,15 +1124,12 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 message: `no one answered the classifier denial-limit approval for "${req.toolName}" — the ${String(windowMs)}ms window ` +
                     `elapsed with no answer; auto-denied: ${req.message}`,
                 decisionReason: "mode",
-                resolution: "window_expired",
-                settledBy: "timeout",
-                autoDenied: true,
+                settlement: { kind: "denial_limit_window_expired", who: { party: "engine", window: "denial_limit" }, when: Date.now() },
             };
         }
         if (raced.tag === "aborted") {
             detachLateAskWait(wait, onLateSettlement);
-            return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode",
-                resolution: "task_aborted", settledBy: "aborted" };
+            return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode", settlement: settledByNobody("task_aborted") };
         }
         if (raced.tag === "threw")
             throw raced.error;
@@ -1159,13 +1140,11 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
             action: "deny",
             message: `approval errored for "${req.toolName}": ${describeThrown(err)}`,
             decisionReason: "mode",
-            resolution: "approver_error",
-            settledBy: "aborted",
+            settlement: settledByNobody("approver_error"),
         };
     }
     if (signal?.aborted) {
-        return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode",
-            resolution: "task_aborted", settledBy: "aborted" };
+        return { action: "deny", message: `approval aborted for "${req.toolName}" (run or turn interrupted)`, decisionReason: "mode", settlement: settledByNobody("task_aborted") };
     }
     if (ok === "unavailable") {
         return {
@@ -1173,8 +1152,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
             message: `approval required for "${req.toolName}" but the approver reported unavailable (no reachable ` +
                 `operator for this ask) and no durable approval gate is armed — denied fail-closed: ${req.message}`,
             decisionReason: "mode",
-            resolution: "approver_unavailable",
-            settledBy: "aborted",
+            settlement: settledByNobody("approver_unavailable"),
             approverUnavailable: true,
         };
     }
@@ -1194,8 +1172,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 action: "deny",
                 message: `the approver's outcome for "${req.toolName}" could not be read (${describeThrown(err)}) — denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "approver_contract",
-                settledBy: "aborted",
+                settlement: settledByNobody("approver_contract"),
             };
         }
         if (typeof allowed !== "boolean") {
@@ -1204,8 +1181,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 message: `the approver for "${req.toolName}" returned an object whose allow is not a boolean ` +
                     `(got ${allowed === null ? "null" : typeof allowed}) — a verdict is exactly true or false; denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "approver_contract",
-                settledBy: "aborted",
+                settlement: settledByNobody("approver_contract"),
             };
         }
         if (supplied !== undefined && supplied !== "human" && supplied !== "timeout") {
@@ -1214,8 +1190,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 message: `the approver for "${req.toolName}" reported settledBy "${typeof supplied === "string" ? containThrownText(supplied) : supplied === null ? "null" : typeof supplied}", which is outside what a synchronous ` +
                     `approver may self-report — it is exactly "human" or "timeout" (or omitted); denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "approver_contract",
-                settledBy: "aborted",
+                settlement: settledByNobody("approver_contract"),
             };
         }
         const attribution = screenApproverAttribution(suppliedApprover);
@@ -1224,19 +1199,16 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                 action: "deny",
                 message: `the approver for "${req.toolName}" reported an attribution this seam refuses: ${attribution.defect}; denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "approver_contract",
-                settledBy: "aborted",
+                settlement: settledByNobody("approver_contract"),
             };
         }
-        const attributionCell = attribution.approver !== undefined ? { approver: attribution.approver } : {};
         if (supplied === "timeout" && allowed === true) {
             return {
                 action: "deny",
                 message: `the approver for "${req.toolName}" returned an allow settled by "timeout" — an elapsed approval window cannot be ` +
                     `what approved a call; denied fail-closed (report timeout with allow:false, or allow with settledBy "human"/omitted)`,
                 decisionReason: "mode",
-                resolution: "approver_contract",
-                settledBy: "timeout",
+                settlement: settledByNobody("approver_contract"),
             };
         }
         if (allowed !== true) {
@@ -1249,8 +1221,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                         message: `the approver for "${req.toolName}" attached a reason that is not a plain string ` +
                             `(got ${suppliedReason === null ? "null" : typeof suppliedReason}) — a deny note is the decider's plain text; denied fail-closed`,
                         decisionReason: "mode",
-                        resolution: "approver_contract",
-                        settledBy: "aborted",
+                        settlement: settledByNobody("approver_contract"),
                     };
                 }
                 reasonText = typeof suppliedReason === "string" && suppliedReason !== "" ? suppliedReason : undefined;
@@ -1260,8 +1231,7 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                     action: "deny",
                     message: `the approver for "${req.toolName}" attached a reason that could not be read (${describeThrown(err)}) — denied fail-closed`,
                     decisionReason: "mode",
-                    resolution: "approver_contract",
-                    settledBy: "aborted",
+                    settlement: settledByNobody("approver_contract"),
                 };
             }
             return {
@@ -1270,37 +1240,34 @@ async function resolveAskArms(req, onAsk, signal, onLateSettlement) {
                     ? `approval for "${req.toolName}" was not answered before the approver's own window elapsed: ${req.message}${reasonText !== undefined ? `\nReviewer note:\n${delimitUntrusted("reviewer note", reasonText, REVIEWER_NOTE_MAX_BODY)}` : ""}`
                     : humanRefusalMessage(req, reasonText),
                 decisionReason: "mode",
-                resolution: supplied === "timeout" ? "window_expired" : "human_refused",
-                settledBy: supplied === "timeout" ? "timeout" : "human",
-                ...(supplied !== "timeout" && reasonText !== undefined ? { humanRefusalNote: true } : {}),
-                ...attributionCell,
+                settlement: supplied === "timeout"
+                    ? { kind: "approval_window_expired", who: { party: "host" }, when: Date.now() }
+                    : settledByPerson("human_refused", attribution.approver, reasonText),
             };
         }
         if (suppliedEdit === undefined)
-            return { action: "allow", decisionReason: "mode", presentedInput: presented.value, settledBy: "human", ...attributionCell };
+            return { action: "allow", decisionReason: "mode", presentedInput: presented.value, settlement: settledByPerson("human_allowed", attribution.approver) };
         const edit = tryCloneArgs(suppliedEdit);
         if (!edit.ok) {
             return {
                 action: "deny",
                 message: `the approved edit for "${req.toolName}" is not safely clonable (${edit.reason}) — denied fail-closed`,
                 decisionReason: "mode",
-                resolution: "presentation_failed",
-                settledBy: "aborted",
+                settlement: settledByNobody("presentation_failed"),
             };
         }
-        return { action: "allow", updatedInput: edit.value, decisionReason: "mode", settledBy: "human", ...attributionCell };
+        return { action: "allow", updatedInput: edit.value, decisionReason: "mode", settlement: settledByPerson("human_allowed", attribution.approver) };
     }
     const okRaw = ok;
     if (okRaw === true)
-        return { action: "allow", decisionReason: "mode", presentedInput: presented.value, settledBy: "human" };
+        return { action: "allow", decisionReason: "mode", presentedInput: presented.value, settlement: settledByPerson("human_allowed", undefined) };
     if (okRaw !== false) {
         return {
             action: "deny",
             message: `the approver for "${req.toolName}" returned an out-of-contract value (${typeof ok}) — denied fail-closed (return true, false, "unavailable", or the {allow} object)`,
             decisionReason: "mode",
-            resolution: "approver_contract",
-            settledBy: "aborted",
+            settlement: settledByNobody("approver_contract"),
         };
     }
-    return { action: "deny", message: humanRefusalMessage(req), decisionReason: "mode", resolution: "human_refused", settledBy: "human" };
+    return { action: "deny", message: humanRefusalMessage(req), decisionReason: "mode", settlement: settledByPerson("human_refused", undefined) };
 }