@sema-agent/core 7.48.0 → 7.49.1

package/dist/core/tool-policy.js

@@ -16,104 +16,93 @@ import { boundInputHashOf } from "./canonical-json.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY } from "./untrusted-text.js";
 import { describeRejectedValue } from "./tool-search-setting.js";
 import { thrownText } from "./thrown-value.js";
+import { assertNoRetiredToolPolicyKeys } from "./retired-keys.js";
 import { isEngineRefusal, nestedRecordsOf, receiveContract, receiveNestedRecords, refusedOutOfContract, screenContractValues } from "./decision-receipt.js";
 export { isEngineRefusal } from "./decision-receipt.js";
 import { isNamespacedCoveringRuleName, namespacedRuleNameCovers, parsePermissionRule } from "./permission-rules.js";
 import { protocolOf } from "./protocol-table.js";
-import { isAbsoluteForFamily, isAbsolutePathForm, joinForFamily, normalizeAbsPathLexically, pathFamilyOf, writeTargetPath } from "../tools/fs/safety.js";
-import { ASSIGNMENT_PREFIX, writtenAssignmentPrefix } from "../tools/fs/bash-program-position.js";
-import { removalReadingOf } from "../tools/fs/removal-targets.js";
+import { anchorSpelling, isAbsoluteForFamily, normalizeAbsPathLexically, pathFamilyOf, writeTargetPath } from "../tools/fs/safety.js";
+import { KNOWN_SAFE_ROOTS, removalReadingOf } from "../tools/fs/removal-targets.js";
 const nameListHolds = (set, req) => heldBy("policy.nameLists", set, req);
 const shellToolsListHolds = (set, req) => heldBy("policy.shellToolsList", set, req);
 export function advertisedWritableRootsSeat(seat) {
     return seat === undefined ? {} : { advertisedWritableRoots: Object.freeze([...seat.roots]) };
 }
+export function exemptRootsSeat(exemptRoots) {
+    return { exemptRoots };
+}
 function settledByNobody(kind) {
     return { kind, who: { party: "none" }, when: Date.now() };
 }
-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;
-}
-export function abortedSeatDeny(req, message, origin) {
-    return attestEngineSettlement({ action: "deny", message }, { settlement: settledByNobody("task_aborted"), origin }, req);
-}
-function transferEngineAttestations(from, to) {
-    for (const seat of ENGINE_ATTESTATION_SEATS) {
-        const v = seat.get(from);
-        if (v !== undefined)
-            seat.set(to, v);
-    }
-}
-function hasEngineAttestation(o) {
-    return ENGINE_ATTESTATION_SEATS.some((seat) => seat.has(o));
-}
-export function carryEngineAttestations(from, to) {
-    transferEngineAttestations(from, to);
-    return to;
-}
-export function carryPrecedingSettlement(preceding, to) {
-    if (ENGINE_SETTLEMENTS.get(to) !== undefined)
-        return;
-    const v = ENGINE_SETTLEMENTS.get(preceding);
-    if (v !== undefined)
-        ENGINE_SETTLEMENTS.set(to, v);
-}
-const CLASSIFIER_DENY_CAUSES_SEAT = new WeakMap();
-export function attestClassifierDenyCause(d, cause, call) {
-    CLASSIFIER_DENY_CAUSES_SEAT.set(d, { cause, toolCallId: call.toolCallId, toolName: call.toolName });
-    return d;
-}
-export function classifierDenyCauseOf(d, call) {
-    if (typeof d !== "object" || d === null)
-        return undefined;
-    const v = CLASSIFIER_DENY_CAUSES_SEAT.get(d);
-    if (v === undefined || v.toolCallId !== call.toolCallId || v.toolName !== call.toolName)
-        return undefined;
-    return v.cause;
-}
-const CLASSIFIER_ROUNDS_SEAT = new WeakMap();
-export function attestClassifierRound(d, round, call) {
-    CLASSIFIER_ROUNDS_SEAT.set(d, { round, toolCallId: call.toolCallId, toolName: call.toolName });
-    return d;
-}
-export function classifierRoundOf(d, call) {
+const ATTESTATION_GROUP_OF = {
+    settlement: "answer",
+    origin: "answer",
+    classes: "answer",
+    inputDigest: "answer",
+    classifierCause: "classifierCause",
+    classifierRound: "classifierRound",
+    unresolvableCause: "unresolvableCause",
+    foldedClasses: "foldedClasses",
+};
+const ATTESTATION_MEMBERS = Object.keys(ATTESTATION_GROUP_OF);
+const groupLead = (g) => ATTESTATION_MEMBERS.find((k) => ATTESTATION_GROUP_OF[k] === g);
+const ENGINE_ATTESTATIONS = new WeakSet();
+function detachedMember(v) {
+    if (Array.isArray(v))
+        return Object.freeze([...v]);
+    if (typeof v !== "object" || v === null)
+        return v;
+    return Object.freeze(Object.fromEntries(Object.entries(v).map(([k, x]) => [k, typeof x === "object" && x !== null ? Object.freeze(Array.isArray(x) ? [...x] : { ...x }) : x])));
+}
+export function mintAttestation(call, members) {
+    const record = { toolCallId: call.toolCallId, toolName: call.toolName };
+    for (const k of ATTESTATION_MEMBERS)
+        if (members[k] !== undefined)
+            record[k] = detachedMember(members[k]);
+    const minted = Object.freeze(record);
+    ENGINE_ATTESTATIONS.add(minted);
+    return minted;
+}
+export function isEngineAttestation(v) {
+    return typeof v === "object" && v !== null && ENGINE_ATTESTATIONS.has(v);
+}
+const boundTo = (r, call) => isEngineAttestation(r) && r.toolCallId === call.toolCallId && r.toolName === call.toolName ? r : undefined;
+export function attestationOf(d, call) {
     if (typeof d !== "object" || d === null)
         return undefined;
-    const v = CLASSIFIER_ROUNDS_SEAT.get(d);
-    if (v === undefined || v.toolCallId !== call.toolCallId || v.toolName !== call.toolName)
-        return undefined;
-    return v.round;
+    return boundTo(Object.getOwnPropertyDescriptor(d, "attestation")?.value, call);
+}
+export function mergeAttestation(call, earlier, later, scope = "all") {
+    const a = boundTo(earlier, call);
+    const b = boundTo(later, call);
+    if (a === undefined)
+        return b;
+    const members = {};
+    if (b !== undefined)
+        for (const k of ATTESTATION_MEMBERS)
+            if (b[k] !== undefined)
+                members[k] = b[k];
+    let filled = false;
+    for (const g of new Set(Object.values(ATTESTATION_GROUP_OF))) {
+        if ((scope === "answer" && g !== "answer") || members[groupLead(g)] !== undefined || a[groupLead(g)] === undefined)
+            continue;
+        for (const k of ATTESTATION_MEMBERS)
+            if (ATTESTATION_GROUP_OF[k] === g && a[k] !== undefined)
+                members[k] = a[k];
+        filled = true;
+    }
+    if (!filled)
+        return b;
+    return mintAttestation(call, members);
 }
-const ASK_UNRESOLVABLE_CAUSES_SEAT = new WeakMap();
-export function attestAskUnresolvableCause(d, cause, call) {
-    ASK_UNRESOLVABLE_CAUSES_SEAT.set(d, { cause, toolCallId: call.toolCallId, toolName: call.toolName });
-    return d;
+export function attest(d, call, members) {
+    return withAttestation(d, mergeAttestation(call, attestationOf(d, call), mintAttestation(call, members)));
 }
-export function askUnresolvableCauseOf(d, call) {
-    if (typeof d !== "object" || d === null)
-        return undefined;
-    const v = ASK_UNRESOLVABLE_CAUSES_SEAT.get(d);
-    if (v === undefined || v.toolCallId !== call.toolCallId || v.toolName !== call.toolName)
-        return undefined;
-    return v.cause;
-}
-const FOLDED_CLASSES_SEAT = new WeakMap();
-function foldedAskClassesAttested(d, held) {
-    const signed = FOLDED_CLASSES_SEAT.get(d);
-    return signed !== undefined && Array.isArray(held) && signed.length === held.length && signed.every((c, i) => c === held[i]);
+export function withAttestation(d, record) {
+    return record === undefined ? d : { ...d, attestation: record };
 }
-const ENGINE_ATTESTATION_SEATS = [ENGINE_SETTLEMENTS, CLASSIFIER_DENY_CAUSES_SEAT, ASK_UNRESOLVABLE_CAUSES_SEAT, CLASSIFIER_ROUNDS_SEAT, FOLDED_CLASSES_SEAT];
-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 function abortedSeatDeny(req, message, origin) {
+    return attest({ action: "deny", message }, req, { settlement: settledByNobody("task_aborted"), 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;
@@ -138,8 +127,9 @@ export const ASK_EVIDENCE_ABSENCE_VALUES = ["not_wired", "not_adjudicated", "una
 export function decisionText(d) {
     return d.message;
 }
-const TOOL_POLICY_CARRIED_MEMBERS = ["projection", "pathRules", "writeTargetGuard", "nameSets"];
+const TOOL_POLICY_CARRIED_MEMBERS = ["projection", "pathRules", "writeGuardRows", "nameSets"];
 export function carriedMembersOf(p) {
+    assertNoRetiredToolPolicyKeys(p);
     const out = {};
     const carry = (k) => {
         const v = p[k];
@@ -156,22 +146,11 @@ export function wrapToolPolicy(inner, check) {
 export function toolPolicyPathRules(policies, anchors) {
     return policies.flatMap((p) => (typeof p?.pathRules === "function" ? p.pathRules(anchors) : []));
 }
-export function toolPolicyWriteTargetGuard(policies) {
-    const guards = policies.flatMap((p) => (typeof p?.writeTargetGuard === "function" ? [p.writeTargetGuard] : []));
-    if (guards.length === 0)
+export function toolPolicyWriteGuardRows(policies) {
+    const sources = policies.flatMap((p) => (typeof p?.writeGuardRows === "function" ? [p.writeGuardRows] : []));
+    if (sources.length === 0)
         return undefined;
-    return async (target, signal) => {
-        for (const guard of guards) {
-            try {
-                if ((await guard(target, signal)) !== false)
-                    return true;
-            }
-            catch {
-                return true;
-            }
-        }
-        return false;
-    };
+    return async (at) => (await Promise.all(sources.map((rowsOf) => rowsOf(at)))).flat();
 }
 export function namespacedCoveringEntries(entries) {
     return (entries ?? []).filter(isNamespacedCoveringRuleName);
@@ -263,7 +242,7 @@ const RETIRED_TEXT_FIELD = "reason";
 export const DECISION_MEMBERS = Object.keys({
     action: 0, updatedInput: 0, message: 0, decisionReason: 0, requiresRealApproval: 0, denialLimitFallback: 0, classifierNoRuling: 0, allowRuleShadowed: 0, probeReason: 0,
     probeCause: 0, probeMandated: 0, mandated: 0, mandate: 0, probeReadRootCandidate: 0, matchedAskRule: 0, ruleEvidence: 0, segmentCoverage: 0,
-    origin: 0, askClass: 0, classes: 0, guard: 0, ruleUnreadable: 0, authoredBy: 0, foldedAskClasses: 0,
+    origin: 0, askClass: 0, classes: 0, guard: 0, ruleUnreadable: 0, authoredBy: 0, foldedAskClasses: 0, attestation: 0,
 });
 const HOOK_RESULT_MEMBERS = [...DECISION_MEMBERS, "additionalContext"];
 const HOOK_SEAM_UNREAD = new Set(["decisionReason"]);
@@ -290,20 +269,30 @@ export function refuseOutOfContractDecision(d, opts) {
     const refused = receiveNestedRecords(contract) ?? screenContractValues(contract, hookSeam ? { skip: HOOK_SEAM_UNREAD, optional: HOOK_SEAM_OPTIONAL } : undefined);
     if (refused !== undefined)
         return refused;
-    if (contract.foldedAskClasses !== undefined && !foldedAskClassesAttested(d, contract.foldedAskClasses)) {
-        return refusedOutOfContract(`a permission decision carries "foldedAskClasses" that no policy fold of the engine wrote on this object — the member is ` +
+    const attestation = contract.attestation;
+    if (attestation !== undefined && (hookSeam || !isEngineAttestation(attestation))) {
+        return refusedOutOfContract(hookSeam
+            ? `a PreToolUse hook result carries an "attestation" — the member is an engine-minted record and a hook result carries none; denied fail-closed`
+            : `a permission decision carries an "attestation" the engine did not mint — the member is an engine record (who settled the call, ` +
+                `which question it answered); denied fail-closed rather than reading a caller's value as a settlement`);
+    }
+    const folded = contract.foldedAskClasses;
+    const signed = attestation?.foldedClasses;
+    if (folded !== undefined && !(signed !== undefined && Array.isArray(folded) && signed.length === folded.length && signed.every((c, i) => c === folded[i]))) {
+        return refusedOutOfContract(`a permission decision carries "foldedAskClasses" that no policy fold of the engine attested on it — the member is ` +
             `engine-written (combinePolicies records the classes of the asks it collapsed); denied fail-closed rather than letting a ` +
             `class no station judged reach the class derivation`);
     }
     if (hookSeam && contract.additionalContext !== undefined && typeof contract.additionalContext !== "string") {
         return refusedOutOfContract(`a PreToolUse hook result's "additionalContext" is not a string — the member is the text appended for the model; denied fail-closed rather than rendering a value this layer cannot classify`);
     }
-    const detached = tryCloneArgs(contract);
+    const { attestation: _record, ...members } = contract;
+    const detached = tryCloneArgs(members);
     if (!detached.ok) {
         return refusedOutOfContract(`a permission decision's members could not be detached from the layer that returned them (${detached.reason}) — ` +
             `the engine keeps its own copy of what it read; denied fail-closed`);
     }
-    const receipt = Object.freeze(detached.value);
+    const receipt = Object.freeze(attestation !== undefined ? { ...detached.value, attestation } : detached.value);
     for (const k of ["classes", "foldedAskClasses"])
         if (Object.hasOwn(receipt, k) && Array.isArray(receipt[k]))
             Object.freeze(receipt[k]);
@@ -313,7 +302,6 @@ export function refuseOutOfContractDecision(d, opts) {
                 Object.freeze(v);
         Object.freeze(record);
     }
-    carryEngineAttestations(d, receipt);
     (hookSeam ? HOOK_RECEIPTS : ENGINE_RECEIPTS).add(receipt);
     return receipt;
 }
@@ -457,12 +445,24 @@ export function createApprovalPolicy(opts) {
                 return { action: "deny", message: `tool "${req.toolName}" is denied by policy` };
             }
             if (nameListHolds(need, req) || namespacedCoveringHit(needCovering, req)) {
-                const attest = (d, settlement) => attestEngineSettlement(d, { settlement, origin: "policy" }, req);
+                const attestOver = (inputDigest) => (d, settlement) => ({ ...d, attestation: mintAttestation(req, { settlement, origin: "policy", inputDigest }) });
                 if (signal?.aborted)
                     return abortedSeatDeny(req, `approval aborted for "${req.toolName}" (run or turn interrupted)`, "policy");
+                const shown = tryCloneArgs(req.args);
+                if (!shown.ok) {
+                    return attestOver(boundInputHashOf(req.args))({ action: "deny", message: `approval for "${req.toolName}" could not present the args safely (unclonable value: ${shown.reason}) — denied fail-closed` }, settledByNobody("presentation_failed"));
+                }
+                const askedDigest = boundInputHashOf(shown.value);
+                const attest = attestOver(askedDigest);
+                const heldWhileWaiting = () => boundInputHashOf(req.args) === askedDigest;
+                const changedWhilePending = () => attest({
+                    action: "deny",
+                    message: `the arguments of "${req.toolName}" changed while its approval was pending — denied fail-closed ` +
+                        `(an approval answers the arguments it was shown; ask again over the arguments that will run)`,
+                }, settledByNobody("approver_contract"));
                 let ok;
                 try {
-                    ok = await withTimeout(Promise.resolve(opts.approve(req, signal)), opts.approvalTimeoutMs, () => DEADLINE_ELAPSED);
+                    ok = await withTimeout(Promise.resolve(opts.approve({ ...req, args: shown.value }, signal)), opts.approvalTimeoutMs, () => DEADLINE_ELAPSED);
                 }
                 catch (err) {
                     return attest({ action: "deny", message: `approval errored for "${req.toolName}": ${describeThrown(err)}` }, settledByNobody("approver_error"));
@@ -490,11 +490,13 @@ export function createApprovalPolicy(opts) {
                                     : `approval denied for "${req.toolName}"${reading.note !== undefined ? `\nReviewer note:\n${delimitUntrusted("reviewer note", reading.note, REVIEWER_NOTE_MAX_BODY)}` : ""}`,
                         }, reading.settlement);
                     }
+                    if (!heldWhileWaiting())
+                        return changedWhilePending();
                     return attest({ action: "allow", decisionReason: "mode" }, reading.settlement);
                 }
                 const okRaw = ok;
                 if (okRaw === true)
-                    return attest({ action: "allow", decisionReason: "mode" }, settledByDecider("person", "allowed", undefined));
+                    return heldWhileWaiting() ? attest({ action: "allow", decisionReason: "mode" }, settledByDecider("person", "allowed", undefined)) : changedWhilePending();
                 if (okRaw !== false) {
                     return attest({
                         action: "deny",
@@ -514,9 +516,11 @@ export function createApprovalPolicy(opts) {
     };
 }
 export function combinePolicies(...policies) {
+    for (const member of policies)
+        assertNoRetiredToolPolicyKeys(member);
     const nameSets = policies.flatMap(toolPolicyNameSets);
     const pathRuled = policies.filter((p) => typeof p?.pathRules === "function");
-    const writeTargetGuard = toolPolicyWriteTargetGuard(policies);
+    const writeGuardRows = toolPolicyWriteGuardRows(policies);
     const childProjections = policies.map((p) => p.projection);
     const projectedComponents = [];
     let combinedRemainder = false;
@@ -538,7 +542,7 @@ export function combinePolicies(...policies) {
         projection: combinedProjection,
         nameSets: nameSets.length > 0 ? nameSets : undefined,
         pathRules: pathRuled.length > 0 ? (anchors) => toolPolicyPathRules(pathRuled, anchors) : undefined,
-        writeTargetGuard,
+        writeGuardRows,
     };
     return {
         ...carriedMembersOf(folded),
@@ -547,8 +551,7 @@ export function combinePolicies(...policies) {
             let current = req;
             let rewrite;
             let stated;
-            const records = {};
-            let anyRecord = false;
+            let records;
             let ruleAskText;
             let probeMandateSeen = false;
             let mandateSeen = false;
@@ -558,20 +561,15 @@ export function combinePolicies(...policies) {
             const contributors = [];
             const settleDeny = (d) => {
                 const out = rewrite?.updatedInput !== undefined ? { ...d, updatedInput: rewrite.updatedInput } : d;
-                if (out !== d)
-                    transferEngineAttestations(d, out);
-                if (!anyRecord)
+                if (records === undefined)
                     return out;
-                const owned = out === d ? { ...d } : out;
-                transferEngineAttestations(records, owned);
-                transferEngineAttestations(d, owned);
-                return owned;
+                return { ...out, attestation: mergeAttestation(req, records, d.attestation) };
             };
             let seatDeny;
             for (const p of policies) {
                 const d = refuseOutOfContractDecision(await p.check(current, signal));
                 if (d.action === "deny") {
-                    if (engineSettlementOf(d, current)?.settlement.kind !== "task_aborted")
+                    if (attestationOf(d, current)?.settlement?.kind !== "task_aborted")
                         return settleDeny(d);
                     seatDeny ??= settleDeny(d);
                     continue;
@@ -585,10 +583,8 @@ export function combinePolicies(...policies) {
                 else if (d.action === "allow" && stated === undefined && d.decisionReason !== undefined) {
                     stated = d.decisionReason;
                 }
-                if (d.action === "allow" && hasEngineAttestation(d)) {
-                    transferEngineAttestations(d, records);
-                    anyRecord = true;
-                }
+                if (d.action === "allow" && d.attestation !== undefined)
+                    records = mergeAttestation(req, records, d.attestation);
                 if (d.action === "ask" && (asked === undefined || (d.requiresRealApproval === true && asked.requiresRealApproval !== true))) {
                     asked = d;
                 }
@@ -628,17 +624,11 @@ export function combinePolicies(...policies) {
                         folded.add(k);
                 const withClasses = folded.size > 0 ? { ...withAuthor, foldedAskClasses: [...folded] } : withAuthor;
                 const out = merged !== undefined ? { ...withClasses, updatedInput: merged } : withClasses;
-                if (folded.size > 0)
-                    FOLDED_CLASSES_SEAT.set(out, Object.freeze([...folded]));
-                return out;
+                return folded.size > 0 ? attest(out, req, { foldedClasses: [...folded] }) : out;
             }
             const base = rewrite ?? ALLOW;
             const allowed = stated !== undefined && base.decisionReason !== stated ? { ...base, decisionReason: stated } : base;
-            if (!anyRecord)
-                return allowed;
-            const out = { ...allowed };
-            transferEngineAttestations(records, out);
-            return out;
+            return records === undefined ? allowed : { ...allowed, attestation: records };
         },
     };
 }
@@ -691,238 +681,18 @@ export function createCoarseCommandNamePolicy(opts) {
         },
     }, "sandbox_local");
 }
-const UNVERIFIABLE_DELETE_SAFE_VARS = ["TMPDIR", "HOME", "PWD"];
-const DELETE_HEADS = new Set(["rm", "xargs", "Remove-Item"]);
-const DELETE_WRAPPERS = new Set([
-    "sudo", "command", "nohup", "time", "do", "then", "else",
-    "env", "nice", "ionice", "exec", "doas", "setsid", "stdbuf", "chroot", "eval",
-    "sh", "bash", "zsh", "dash", "ksh", "ash", "timeout", "case",
-]);
-const STATEMENT_SPLIT = /[;&|\n]+/;
-const stripTokenEdges = (t) => t.replace(/^[("'{]+|[)"'}]+$/g, "");
-function restOfAssignment(tokens, i, eq) {
-    const first = tokens[i].slice(eq + 1);
-    const q = first.startsWith('"') ? '"' : first.startsWith("'") ? "'" : undefined;
-    if (q === undefined || (first.length > 1 && first.endsWith(q)))
-        return first;
-    const parts = [first];
-    for (let k = i + 1; k < tokens.length; k++) {
-        parts.push(tokens[k]);
-        if (tokens[k].endsWith(q))
-            break;
-    }
-    return parts.join(" ");
-}
-function assignmentTokenSpan(tokens, i) {
-    const eq = tokens[i].indexOf("=");
-    const first = tokens[i].slice(eq + 1);
-    const q = first.startsWith('"') ? '"' : first.startsWith("'") ? "'" : undefined;
-    if (q === undefined || (first.length > 1 && first.endsWith(q)))
-        return 1;
-    for (let k = i + 1; k < tokens.length; k++)
-        if (tokens[k].endsWith(q))
-            return k - i + 1;
-    return 1;
-}
-function valueIsOpaque(value, assigned, safeVars) {
-    const v = value.replace(/["']/g, "").replace(/\\(.)/g, "$1");
-    if (v.includes("$(") || v.includes("`"))
-        return true;
-    if (/\$[@*#!?0-9-]/.test(v))
-        return true;
-    if (/\$\{[!#]/.test(v))
-        return true;
-    for (const vm of v.matchAll(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g)) {
-        const ref = vm[1];
-        if (!assigned.has(ref) && !(safeVars.has(ref) && safeRootBelow(v.slice((vm.index ?? 0) + vm[0].length))))
-            return true;
-    }
-    return false;
-}
-const safeRootBelow = (after) => /^\/[^*?[\]]+$/.test(after) && !after.split("/").includes("..");
-export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVERIFIABLE_DELETE_SAFE_VARS)) {
-    const assigned = new Set();
-    const assignedEscapesRoot = new Set();
-    const valueEscapesRoot = (value, safe) => {
-        const v = value.replace(/\\(.)/g, "$1").replace(/["']/g, "");
-        for (const vm of v.matchAll(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g)) {
-            if (!safe.has(vm[1]))
-                continue;
-            if (v.slice((vm.index ?? 0) + vm[0].length).split("/").includes(".."))
-                return true;
-        }
-        return false;
-    };
-    const applyAssignmentWord = (words, at) => {
-        const written = writtenAssignmentPrefix(words[at]);
-        if (written === undefined) {
-            assigned.delete(words[at].replace(/\[.*$/, ""));
-            return;
-        }
-        const value = restOfAssignment(words, at, written.prefix.length - 1);
-        if ((!written.settlesWholeName && !assigned.has(written.name)) || valueIsOpaque(value, assigned, safeVars))
-            assigned.delete(written.name);
-        else
-            assigned.add(written.name);
-        if (valueEscapesRoot(value, safeVars))
-            assignedEscapesRoot.add(written.name);
-        else if (written.settlesWholeName)
-            assignedEscapesRoot.delete(written.name);
-    };
-    const statements = command.replace(/\\\r?\n/g, " ").split(STATEMENT_SPLIT);
-    for (const stmt of statements) {
-        const tokens = stmt.trim().split(/\s+/).filter(Boolean);
-        let i = 0;
-        while (i < tokens.length && ASSIGNMENT_PREFIX.test(tokens[i])) {
-            applyAssignmentWord(tokens, i);
-            i += assignmentTokenSpan(tokens, i);
-        }
-        let sawWrapper = false;
-        while (i < tokens.length) {
-            const t = stripTokenEdges(tokens[i]).replace(/^\\/, "");
-            if (t === "") {
-                i++;
-                continue;
-            }
-            if (DELETE_WRAPPERS.has(t)) {
-                sawWrapper = true;
-                i++;
-                while (i < tokens.length && (/^-/.test(tokens[i]) || ASSIGNMENT_PREFIX.test(tokens[i])))
-                    i++;
-                continue;
-            }
-            if (/\)$/.test(tokens[i]) && !DELETE_HEADS.has(t)) {
-                sawWrapper = true;
-                i++;
-                continue;
-            }
-            break;
-        }
-        if (i >= tokens.length)
-            continue;
-        const norm = (tok) => {
-            const t = stripTokenEdges(tok).replace(/^\\/, "");
-            return t.split("/").pop() ?? t;
-        };
-        let headIdx = i;
-        if (sawWrapper && !DELETE_HEADS.has(norm(tokens[headIdx]))) {
-            const found = tokens.findIndex((t, k) => k > headIdx && DELETE_HEADS.has(norm(t)));
-            if (found !== -1)
-                headIdx = found;
-        }
-        i = headIdx;
-        const head = stripTokenEdges(tokens[i]).replace(/^\\/, "");
-        const headName = head.split("/").pop() ?? head;
-        const declStmt = stmt.trim();
-        const declaredWords = /^(?:export|declare|typeset|local|readonly)\b/.test(declStmt) ? declStmt.split(/\s+/).filter(Boolean).slice(1) : ASSIGNMENT_PREFIX.test(declStmt) ? [declStmt] : [];
-        for (let d = 0; d < declaredWords.length;) {
-            if (/^[-+]/.test(declaredWords[d])) {
-                d += 1;
-                continue;
-            }
-            declaredWords[d] = stripTokenEdges(declaredWords[d]);
-            applyAssignmentWord(declaredWords, d);
-            d += assignmentTokenSpan(declaredWords, d);
-        }
-        if (headName === "read") {
-            void 0;
-        }
-        if (headName === "for" && tokens[i + 1] && tokens[i + 2] === "in") {
-            const list = tokens.slice(i + 3).join(" ");
-            if (!valueIsOpaque(list, assigned, safeVars))
-                assigned.add(tokens[i + 1]);
-            if (valueEscapesRoot(list, safeVars))
-                assignedEscapesRoot.add(tokens[i + 1]);
-        }
-        if (headName === "xargs") {
-            const rest = tokens.slice(i + 1).map(stripTokenEdges);
-            const rmAt = rest.findIndex((t) => (t.split("/").pop() ?? t) === "rm");
-            if (rmAt >= 0 && hasRecursiveForce(rest.slice(rmAt + 1))) {
-                return "`xargs rm` with recursive+force flags — the delete targets come from pipe output that cannot be verified";
-            }
-            continue;
-        }
-        if (/^remove-item$/i.test(headName) || /^ri$/i.test(headName)) {
-            const rest = tokens.slice(i + 1);
-            const recurse = rest.some((t) => /^-recurse$/i.test(t));
-            const force = rest.some((t) => /^-force$/i.test(t));
-            const varTarget = rest.find((t) => !t.startsWith("-") && t.includes("$"));
-            if (recurse && force && varTarget !== undefined) {
-                return `\`Remove-Item -Recurse -Force\` target ${varTarget} is a variable that cannot be verified from this command`;
-            }
-            continue;
-        }
-        if (headName !== "rm")
-            continue;
-        const rest = tokens.slice(i + 1);
-        if (!hasRecursiveForce(rest))
-            continue;
-        let optionsEnded = false;
-        for (const raw of rest) {
-            if (!optionsEnded && raw === "--") {
-                optionsEnded = true;
-                continue;
-            }
-            if (!optionsEnded && raw.startsWith("-"))
-                continue;
-            const target = raw.replace(/["']/g, "");
-            if (target.includes("$(") || target.includes("`")) {
-                return `\`rm\` recursive+force target ${raw} uses command substitution — the deleted path cannot be verified from this command`;
-            }
-            if (/\$[@*#!?0-9-]/.test(target)) {
-                return `\`rm\` recursive+force target ${raw} uses a positional/special shell parameter that cannot be verified from this command`;
-            }
-            if (/\$\{[!#]/.test(target)) {
-                return `\`rm\` recursive+force target ${raw} uses indirect/length expansion (\`\${!…}\`/\`\${#…}\`) — the deleted path cannot be verified from this command`;
-            }
-            const targetNorm = target.replace(/\\(.)/g, "$1");
-            for (const vm of targetNorm.matchAll(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g)) {
-                const name = vm[1];
-                if (assigned.has(name)) {
-                    const afterName = targetNorm.slice((vm.index ?? 0) + vm[0].length);
-                    if (afterName.split("/").includes("..")) {
-                        return `\`rm\` recursive+force target ${raw} climbs above its in-window root via \`..\` — the deleted path cannot be verified from this command`;
-                    }
-                    if (!assignedEscapesRoot.has(name))
-                        continue;
-                    return `\`rm\` recursive+force target ${raw} resolves through ${name}, whose in-window value climbs above a known-safe root (\`..\`) — the deleted path cannot be verified from this command`;
-                }
-                if (safeVars.has(name)) {
-                    if (safeRootBelow(targetNorm.slice((vm.index ?? 0) + vm[0].length)))
-                        continue;
-                }
-                return `\`rm\` recursive+force target ${raw} references $${name}, which has no assignment in this command — an empty or unexpected value could make this a home-directory or filesystem-root wipe`;
-            }
-        }
-    }
-    return undefined;
-}
-function hasRecursiveForce(argvTail) {
-    let recursive = false;
-    let force = false;
-    for (const raw of argvTail) {
-        const t = raw.replace(/^["']|["']$/g, "");
-        if (t === "--")
-            break;
-        if (!t.startsWith("-"))
-            continue;
-        if (t === "--recursive")
-            recursive = true;
-        else if (t === "--force")
-            force = true;
-        else if (/^-[A-Za-z]+$/.test(t)) {
-            if (/[rR]/.test(t))
-                recursive = true;
-            if (t.includes("f"))
-                force = true;
+export function createUnverifiableDeletePolicy(opts) {
+    for (const name of opts?.safeVars ?? []) {
+        if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+            throw new TypeError(`createUnverifiableDeletePolicy: safeVars entry ${JSON.stringify(name)} is not a shell variable name`);
+        if (name === "PWD" || name === "OLDPWD") {
+            const e = new Error(`createUnverifiableDeletePolicy: safeVars entry "${name}" is a reserved name — it is where the command stands, which the removal guard reads off the working-directory thread, not a root the shell provides. Drop the entry; to treat a fixed directory as a safe root, export it under a name of your own and list that name.`);
+            e.code = "config.safe_vars_reserved_name";
+            throw e;
         }
     }
-    return recursive && force;
-}
-export function createUnverifiableDeletePolicy(opts) {
-    const safeVars = new Set([...UNVERIFIABLE_DELETE_SAFE_VARS, ...(opts?.safeVars ?? [])]);
+    const safeRoots = [...new Set([...KNOWN_SAFE_ROOTS, ...(opts?.safeVars ?? [])])];
     const shellTools = canonicalToolNameSet(opts?.tools);
-    const unverifiable = (command, finding = findUnverifiableRecursiveDelete(command, safeVars)) => (finding === undefined ? ALLOW : removalAsk("unverifiable_delete", finding));
     return brandPolicyAskClass({
         check(req, signal) {
             if (!shellToolsListHolds(shellTools, req))
@@ -930,14 +700,18 @@ export function createUnverifiableDeletePolicy(opts) {
             const command = req.args?.command;
             if (typeof command !== "string")
                 return ALLOW;
-            const removal = removalReadingOf(command, req, opts?.removalSeat);
-            return removal === undefined ? unverifiable(command) : removal.judge(signal).then((found) => (found === undefined ? unverifiable(command) : removalAsk(found.guard, found.text)));
+            const removal = removalReadingOf(command, req, opts?.removalSeat, safeRoots);
+            return removal === undefined ? ALLOW : removal.judge(signal).then((found) => (found === undefined ? ALLOW : removalAsk(found.guard, found.text)));
         },
     }, "external_authority");
 }
 function removalAsk(guard, text) {
-    const message = guard === "dangerous_delete" ? `Dangerous removal: ${text}. No permission mode, allow rule or classifier clears this — only a person confirming this call does.` : `Unverifiable recursive delete (fail-closed unless cleared): ${text}. Re-run the delete with the resolved literal path written into the command itself (or assign the variable a literal path in the same command, e.g. \`DIR=/exact/path; rm -rf "$DIR"\`) so the target can be verified.`;
-    return { action: "ask", decisionReason: "safety", requiresRealApproval: true, guard, message };
+    const messages = {
+        dangerous_delete: `Dangerous removal: ${text}. No permission mode, allow rule or classifier clears this — only a person confirming this call does.`,
+        unverifiable_delete: `Unverifiable recursive delete (fail-closed unless cleared): ${text}. Re-run the delete with the resolved literal path written into the command itself (or assign the variable a literal path in the same command, e.g. \`DIR=/exact/path; rm -rf "$DIR"\`) so the target can be verified.`,
+        unverifiable_shell_text: `Unverifiable shell text (fail-closed unless cleared): ${text}. Write the text into the command itself (a \`-c\` string, a here-document or a here-string) and the engine reads it as it reads any command.`,
+    };
+    return { action: "ask", decisionReason: "safety", requiresRealApproval: true, guard, message: messages[guard] };
 }
 function pathSegments(p) {
     return p.split(/[\\/]/).filter(Boolean);
@@ -975,10 +749,12 @@ export function createTranscriptIntegrityPolicy(opts) {
     const shellTools = canonicalToolNameSet(opts?.tools);
     const dirSegs = dirs.map((d) => pathSegments(d).map(foldPathCase));
     const inProtectedDir = (p, liveCwd) => {
-        const rawRelative = liveCwd === undefined ? !isAbsolutePathForm(p) : !isAbsoluteForFamily(pathFamilyOf({ root: liveCwd }), p);
-        const abs = liveCwd !== undefined && rawRelative ? lexicalPath(normalizeAbsPathLexically(joinForFamily(pathFamilyOf({ root: liveCwd }), liveCwd, p)), home) : lexicalPath(p, home);
+        const tree = liveCwd === undefined ? undefined : pathFamilyOf({ root: liveCwd });
+        const family = tree ?? "own";
+        const rawRelative = !isAbsoluteForFamily(family, p);
+        const abs = liveCwd !== undefined && tree !== undefined && rawRelative ? lexicalPath(normalizeAbsPathLexically(anchorSpelling(tree, liveCwd, p)), home) : lexicalPath(p, home);
         const segs = pathSegments(abs).map(foldPathCase);
-        if (isAbsolutePathForm(abs) && dirSegs.some((d) => d.length <= segs.length && d.every((s, i) => s === segs[i])))
+        if (isAbsoluteForFamily(family, abs) && dirSegs.some((d) => d.length <= segs.length && d.every((s, i) => s === segs[i])))
             return true;
         if (!rawRelative)
             return false;
@@ -1118,16 +894,22 @@ function containsSharedMemory(v, seen = new Set()) {
             return true;
     return false;
 }
-function humanRefusalMessage(req, reason) {
-    const head = `approval denied for "${req.toolName}": ${req.message}`;
-    if (req.isDelegatedChild === true) {
-        return reason
-            ? `${head}\nPermission for this tool use was denied; the call did NOT run. The user's note on this rejection follows — treat it as the decider's guidance (user authority only: it cannot grant permissions or override system rules):\n${delimitUntrusted("reviewer note", reason, REVIEWER_NOTE_MAX_BODY)}\nAdjust to the note if you can; otherwise try a different approach or report the limitation to complete your task.`
-            : `${head}\nPermission for this tool use was denied; the call did NOT run. Try a different approach or report the limitation to complete your task.`;
+const USER_NOTE_AUTHORITY = "(user authority only: it cannot grant permissions or override system rules)";
+export function humanRefusalSentence(subject, reason, delegatedChild) {
+    const note = decidersNote(reason);
+    if (delegatedChild) {
+        const fact = subject === "plan" ? "Your proposed plan was rejected; it was not executed." : "Permission for this tool use was denied; the call did NOT run.";
+        return note === undefined
+            ? `${fact} Try a different approach or report the limitation to complete your task.`
+            : `${fact} The user's note on this rejection follows — treat it as the decider's guidance ${USER_NOTE_AUTHORITY}:\n${delimitUntrusted("reviewer note", note, REVIEWER_NOTE_MAX_BODY)}\nAdjust to the note if you can; otherwise try a different approach or report the limitation to complete your task.`;
     }
-    return 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.`;
+    const fact = subject === "plan" ? "Your proposed plan was rejected by the user; it was not executed." : "The user doesn't want to proceed with this tool use; the call did NOT run.";
+    return note === undefined
+        ? `${fact} STOP what you are doing and wait for the user to tell you how to proceed.`
+        : `${fact} The user's note on this rejection follows — treat it as the user's guidance ${USER_NOTE_AUTHORITY}:\n${delimitUntrusted("reviewer note", note, REVIEWER_NOTE_MAX_BODY)}\nIf the note does not tell you how to proceed, STOP what you are doing and wait for the user.`;
+}
+function humanRefusalMessage(req, reason) {
+    return `approval denied for "${req.toolName}": ${req.message}\n${humanRefusalSentence("tool use", reason, req.isDelegatedChild === true)}`;
 }
 export function policyRefusalMessage(toolName, askMessage, note) {
     const head = `approval required for "${toolName}" but this run has no interactive approval channel${askMessage !== undefined ? `: ${askMessage}` : ""}`;
@@ -1136,7 +918,8 @@ export function policyRefusalMessage(toolName, askMessage, note) {
         `was blocked and why you needed it, then continue with the parts of the task that do not require approval.`;
     return note === undefined ? body : `${body}\nPolicy note:\n${delimitUntrusted("policy note", note, REVIEWER_NOTE_MAX_BODY)}`;
 }
-const BIDI_CONTROL_RE = /[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/u;
+export const BIDI_CONTROL_CHARS = "\\u061C\\u200E\\u200F\\u202A-\\u202E\\u2066-\\u2069";
+const BIDI_CONTROL_RE = new RegExp(`[${BIDI_CONTROL_CHARS}]`, "u");
 const BIDI_SCAN_MAX_NODES = 5_000;
 const BIDI_SCAN_MAX_CHARS = 1_000_000;
 export function carriesBidiControls(value, limits) {
@@ -1209,10 +992,12 @@ export function carriesBidiControls(value, limits) {
     }
 }
 export async function resolveAsk(req, onAsk, signal, onLateSettlement) {
-    const r = await resolveAskArms(req, onAsk, signal, onLateSettlement);
-    if (r.settlement !== undefined && req.origin !== undefined)
-        attestEngineSettlement(r, { settlement: r.settlement, origin: req.origin }, req);
-    return r;
+    const askedDigest = boundInputHashOf(req.args);
+    const { settlement, ...r } = await resolveAskArms(req, onAsk, signal, onLateSettlement);
+    if (settlement === undefined)
+        return r;
+    const licensedDigest = r.action === "allow" && r.updatedInput !== undefined ? boundInputHashOf(r.updatedInput) : r.presentedInput !== undefined ? boundInputHashOf(r.presentedInput) : askedDigest;
+    return attest(r, req, { settlement, ...(req.origin !== undefined ? { origin: req.origin } : {}), ...(req.classes !== undefined ? { classes: req.classes } : {}), inputDigest: licensedDigest });
 }
 function raceAskWaitAgainstSignal(wait, signal) {
     const settledWait = wait.then((value) => ({ tag: "value", value }), (error) => ({ tag: "threw", error }));