@sema-agent/core 7.54.1 → 7.56.0

package/dist/core/file-history-store.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { thrownText } from "./thrown-value.js";
+import { readMember, thrownText } from "./thrown-value.js";
 import { isAbsoluteForFamily, isWinFormPath, pathFamilyOf, relativeInEveryFamily } from "../tools/fs/safety.js";
 import { fileHistoryBoundariesToKeep, resolveFileHistoryRetention } from "./file-history-retention.js";
 const normSlash = (p) => p.replace(/\\/g, "/");
@@ -32,6 +32,7 @@ function parentDirOf(absPath) {
     const parent = cut.slice(0, i);
     return win ? parent.replace(/\//g, "\\") : parent;
 }
+export const FILE_HISTORY_REFUSAL_CLASSES = Object.freeze(["link_safety", "base_unavailable", "key_unresolvable"]);
 export function trackKeyFamilyOf(root) {
     return isWinFormPath(root) ? "win" : "posix";
 }
@@ -53,20 +54,40 @@ export function resolveTrackKey(root, key, minted) {
     const win = isWinFormPath(root);
     if (minted !== undefined && minted.family !== trackKeyFamilyOf(root)) {
         if (minted.kind === "absolute") {
-            return { ok: false, reason: `foreign-family absolute key cannot be restored here (recorded under a ${minted.family} root, this root is ${trackKeyFamilyOf(root)}): ${key}` };
+            return { ok: false, reason: `foreign-family absolute key cannot be restored here (recorded under a ${minted.family} root, this root is ${trackKeyFamilyOf(root)}): ${key}`, class: "key_unresolvable" };
         }
         if (isUnsafeRelPathLike(normSlash(key)) || key.includes("\\")) {
-            return { ok: false, reason: `foreign-family key is ambiguous across path families (recorded under a ${minted.family} root, this root is ${trackKeyFamilyOf(root)}): ${key}` };
+            return { ok: false, reason: `foreign-family key is ambiguous across path families (recorded under a ${minted.family} root, this root is ${trackKeyFamilyOf(root)}): ${key}`, class: "key_unresolvable" };
         }
     }
     const keyN = win ? normSlash(key) : key;
     if (isAbsoluteForFamily(pathFamilyOf({ root }), keyN) || (win && /^[A-Za-z]:/.test(keyN)))
         return { ok: true, abs: key };
     if (win ? isUnsafeRelPathLike(keyN) : keyN.split("/").includes(".."))
-        return { ok: false, reason: `unsafe recorded key escapes root: ${key}` };
+        return { ok: false, reason: `unsafe recorded key escapes root: ${key}`, class: "key_unresolvable" };
     return { ok: true, abs: joinUnder(root, keyN) };
 }
 export const FILE_HISTORY_ERROR_CODES = Object.freeze(["track_failed", "snapshot_failed", "restore_failed", "adopt_failed", "not_found", "aborted", "unsupported_format", "conflict"]);
+const CAUGHT_CODE_RETRY_CLASS = new Map([
+    ...["EACCES", "EPERM", "EROFS", "ENAMETOOLONG", "EFBIG", "ENOTDIR", "EISDIR"].map((c) => [c, "terminal"]),
+    ...["EAGAIN", "EWOULDBLOCK", "EBUSY", "EINTR", "ETIMEDOUT", "EMFILE", "ENFILE"].map((c) => [c, "transient"]),
+]);
+export function caughtFault(caught) {
+    const code = readMember(caught, "code");
+    const judged = typeof code === "string" ? CAUGHT_CODE_RETRY_CLASS.get(code) : undefined;
+    return judged === undefined ? {} : { permanence: judged };
+}
+export const DAMAGED_RECORD = Object.freeze({ permanence: "terminal" });
+export class FileHistoryStoreError extends Error {
+    code;
+    constructor(failure, message, thrown) {
+        super(message, thrown !== undefined ? { cause: thrown.value } : undefined);
+        this.name = "FileHistoryStoreError";
+        this.code = failure.code;
+        if (failure.permanence !== undefined)
+            this.permanence = failure.permanence;
+    }
+}
 export const FILE_HISTORY_DIFF_LINE_BUDGET = 2000;
 export function countRestoreLineDiff(current, target) {
     const isBinary = (b) => b !== undefined && b.includes(0);
@@ -252,18 +273,24 @@ export async function captureFileBackupViaEnv(env, absPath, root, signal) {
 }
 export async function worldStillMatchesMint(env, absPath, root, baseAvailable, mintedBlobHash, signal) {
     if (!baseAvailable) {
-        return { unchanged: false, reason: "the first touch recorded a base-UNAVAILABLE marker, whose whole purpose is to refuse a fake pristine later — an ambiguous failure may not erase it" };
+        return { verdict: "kept", reason: "the first touch recorded a base-UNAVAILABLE marker, whose whole purpose is to refuse a fake pristine later — an ambiguous failure may not erase it" };
     }
     const cap = await captureFileBackupViaEnv(env, absPath, root, signal);
     if (cap.state === "absent") {
-        return mintedBlobHash === null ? { unchanged: true } : { unchanged: false, reason: "the file recorded at the first touch is gone now" };
+        return mintedBlobHash === null ? { verdict: "unchanged" } : { verdict: "kept", reason: "the file recorded at the first touch is gone now" };
     }
     if (cap.state === "file") {
         if (mintedBlobHash === null)
-            return { unchanged: false, reason: "the path was recorded as NOT EXISTING at the first touch but holds bytes now" };
-        return cap.hash === mintedBlobHash ? { unchanged: true } : { unchanged: false, reason: "the file's bytes differ from the ones recorded at the first touch" };
+            return { verdict: "kept", reason: "the path was recorded as NOT EXISTING at the first touch but holds bytes now" };
+        return cap.hash === mintedBlobHash ? { verdict: "unchanged" } : { verdict: "kept", reason: "the file's bytes differ from the ones recorded at the first touch" };
     }
-    return { unchanged: false, reason: `the path could not be re-read to prove it is unchanged (${cap.state === "aborted" ? "aborted" : cap.cause})` };
+    return { verdict: "unjudged", reason: `the path could not be re-read to prove it is unchanged (${cap.state === "aborted" ? "aborted" : cap.cause})`, aborted: cap.state === "aborted" };
+}
+export function annulProofFailure(proof, absPath) {
+    if (proof.verdict === "kept") {
+        return { ok: false, error: { code: "conflict", message: `first-touch record for ${absPath} is NOT retractable: ${proof.reason} — the write this retraction compensates for may have changed the file, and deleting the only baseline of a modified file is worse than keeping a stale record` } };
+    }
+    return { ok: false, error: { code: proof.aborted ? "aborted" : "track_failed", message: `first-touch record for ${absPath} was left in place: ${proof.reason}, so whether the write this retraction compensates for changed the file was not judged` } };
 }
 export function modeProvenDifferent(recorded, current) {
     return recorded !== undefined && current !== undefined && recorded !== current;
@@ -297,7 +324,7 @@ export async function applyFileRestoreViaEnv(env, absPath, target, opts) {
     }
     const w = await writeRestoredBytes(env, absPath, target.bytes, signal);
     if (!w.ok)
-        return { outcome: w.refused ? "refused" : "failed", reason: `write: ${w.code}` };
+        return w.refused ? { outcome: "refused", reason: `write: ${w.code}`, class: "link_safety" } : { outcome: "failed", reason: `write: ${w.code}` };
     const modeAfter = await applyRecordedMode(env, absPath, opts, undefined);
     return { outcome: "applied", ...(modeAfter === "unpreserved" || modeAfter === "applied_unpreserved" ? { modeNotPreserved: true } : {}) };
 }
@@ -310,6 +337,7 @@ async function restorePreflight(env, absPath, opts) {
                 reason: info.value.kind === "symlink"
                     ? "restore target is a SYMLINK — the recorded bytes belong to the file that was edited, not to whatever the link now points at"
                     : `restore target is a ${info.value.kind}, not a regular file — the recorded bytes are not this object's`,
+                class: "link_safety",
             },
         };
     }
@@ -325,6 +353,7 @@ async function restorePreflight(env, absPath, opts) {
         refused: {
             outcome: "refused",
             reason: `restore target's parent chain changed identity since it was recorded (recorded ${JSON.stringify(opts.parentIdent)}, now ${JSON.stringify(now)}) — writing here could land outside the task root`,
+            class: "link_safety",
         },
     };
 }
@@ -491,7 +520,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true, minted: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${thrownText(err)}` } };
+            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${thrownText(err)}`, ...caughtFault(err) } };
         }
     }
     async annulTrack(scope, absPath, root, verify) {
@@ -522,9 +551,8 @@ export class InMemoryFileHistoryStore {
             if (before !== undefined)
                 return { ok: false, error: { code: "conflict", message: before } };
             const proof = verify === undefined ? undefined : await worldStillMatchesMint(verify.env, absPath, root, t.baseAvailable, t.versions[0]?.blobHash ?? null, verify.signal);
-            if (proof !== undefined && !proof.unchanged) {
-                return { ok: false, error: { code: "conflict", message: `first-touch record for ${absPath} is NOT retractable: ${proof.reason} — the write this retraction compensates for may have changed the file, and deleting the only baseline of a modified file is worse than keeping a stale record` } };
-            }
+            if (proof !== undefined && proof.verdict !== "unchanged")
+                return annulProofFailure(proof, absPath);
             const after = ineligible();
             if (after !== undefined)
                 return { ok: false, error: { code: "conflict", message: after } };
@@ -532,7 +560,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${thrownText(err)}` } };
+            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${thrownText(err)}`, ...caughtFault(err) } };
         }
     }
     async snapshot(scope, entryId, env, root, signal) {
@@ -601,14 +629,14 @@ export class InMemoryFileHistoryStore {
             }
             catch (err) {
                 sc.spentAttempts.add(entryId);
-                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${thrownText(err)}` } };
+                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${thrownText(err)}`, ...caughtFault(err) } };
             }
             this.applyBoundaryRetention(scope, entryId);
             return { ok: true };
         }
         catch (err) {
             sc.spentAttempts.add(entryId);
-            return { ok: false, error: { code: "snapshot_failed", message: thrownText(err) } };
+            return { ok: false, error: { code: "snapshot_failed", message: thrownText(err), ...caughtFault(err) } };
         }
         finally {
             sc.activeAttempts.delete(entryId);
@@ -635,7 +663,7 @@ export class InMemoryFileHistoryStore {
                 let targetVersion = boundary.get(key);
                 if (targetVersion === undefined) {
                     if (!t.baseAvailable) {
-                        ledger.refused.push({ path: key, reason: "base_unavailable" });
+                        ledger.refused.push({ path: key, reason: "base_unavailable", class: "base_unavailable" });
                         continue;
                     }
                     targetVersion = 1;
@@ -647,7 +675,7 @@ export class InMemoryFileHistoryStore {
                 }
                 const resolved = resolveTrackKey(root, key, t.keyDesc);
                 if (!resolved.ok) {
-                    ledger.refused.push({ path: key, reason: resolved.reason });
+                    ledger.refused.push({ path: key, reason: resolved.reason, class: resolved.class });
                     continue;
                 }
                 let target;
@@ -678,7 +706,7 @@ export class InMemoryFileHistoryStore {
                 else if (applied.outcome === "identical")
                     ledger.identicalSkipped.push(key);
                 else if (applied.outcome === "refused")
-                    ledger.refused.push({ path: key, reason: applied.reason });
+                    ledger.refused.push({ path: key, reason: applied.reason, class: applied.class });
                 else
                     ledger.failed.push({ path: key, reason: applied.reason });
                 if ((applied.outcome === "applied" || applied.outcome === "identical") && applied.modeNotPreserved === true)
@@ -688,7 +716,7 @@ export class InMemoryFileHistoryStore {
         }
         catch (err) {
             const touched = empty.filesChanged.length > 0 || empty.identicalSkipped.length > 0 || empty.refused.length > 0 || empty.failed.length > 0;
-            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: thrownText(err) } };
+            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: thrownText(err), ...caughtFault(err) } };
         }
     }
     async canRestore(scope, entryId) {
@@ -795,14 +823,12 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${thrownText(err)}` } };
+            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${thrownText(err)}`, ...caughtFault(err) } };
         }
     }
     async exportHistory(scope) {
         const sc = this.scopes.get(scope);
-        if (sc === undefined || (sc.tracked.size === 0 && sc.boundaries.size === 0))
-            return null;
-        return this.exportOf(sc);
+        return { ok: true, history: sc === undefined || (sc.tracked.size === 0 && sc.boundaries.size === 0) ? null : this.exportOf(sc) };
     }
     exportOf(sc) {
         return {
@@ -826,9 +852,9 @@ export class InMemoryFileHistoryStore {
             const shaped = validateFileHistoryExport(data);
             if (!shaped.ok)
                 return shaped;
-            const existing = await this.exportHistory(scope);
-            if (existing !== null) {
-                if (fileHistoryExportDigest(existing) === fileHistoryExportDigest(data))
+            const existing = this.scopes.get(scope);
+            if (existing !== undefined && (existing.tracked.size > 0 || existing.boundaries.size > 0)) {
+                if (fileHistoryExportDigest(this.exportOf(existing)) === fileHistoryExportDigest(data))
                     return { ok: true };
                 return { ok: false, error: { code: "conflict", message: `importHistory target "${scope}" already holds a DIFFERENT history — a first import requires an empty target and a retry is legal only for the identical envelope (atomic visibility prevents half-graphs; this law prevents publishing the wrong complete graph over locally-grown history)` } };
             }
@@ -848,7 +874,7 @@ export class InMemoryFileHistoryStore {
             }
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}`, ...caughtFault(err) } };
         }
     }
     async importStaged(scope, data, srcGetBlob, needed) {
@@ -862,10 +888,10 @@ export class InMemoryFileHistoryStore {
                     bytes = await srcGetBlob(hash);
                 }
                 catch (err) {
-                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fetch failed: ${thrownText(err)}` } };
+                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fetch failed: ${thrownText(err)}`, ...caughtFault(err) } };
                 }
                 if (bytes === undefined)
-                    return { ok: false, error: { code: "not_found", message: `source blob ${hash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
+                    return { ok: false, error: { code: "adopt_failed", message: `source blob ${hash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
                 if (createHash("sha256").update(bytes).digest("hex") !== hash) {
                     return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fails content-address integrity — refused, nothing published` } };
                 }
@@ -894,7 +920,7 @@ export class InMemoryFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}`, ...caughtFault(err) } };
         }
     }
 }

package/dist/core/gate-fold.d.ts

@@ -1,4 +1,4 @@
-import type { GatePass } from "./runner/gate-exit.js";
+import { type GatePass } from "./runner/gate-exit.js";
 import type { ToolGateResult } from "./hooks.js";
 /**
  * Run the fold over the pass: adjudicate, fold the hook-ask, tighten. Writes `req` (re-minted over the FINAL

package/dist/core/gate-fold.js

@@ -2,6 +2,8 @@ import { inlineUntrusted } from "./untrusted-text.js";
 import { markTightenMessage } from "./safety-axis-vocab.js";
 import { PROBE_REASON_MAX, normalizeProbeCause } from "./checkpoint-store.js";
 import { normalizeReadRootCandidate } from "./read-root-candidate.js";
+import { engineFailClosedExit, hookDenyExit } from "./runner/gate-exit.js";
+import { readRejudge, screenRewrite } from "./rewrite-rejudge.js";
 import { traceHookCrash } from "./gate-crash-trace.js";
 import { writeProtectionMandated, writeProtectionTightenDecision } from "./write-protect.js";
 import { createGateDeadline, awaitWriteProtectionJudgment, gateWaitFailureOf, withGateTimeout } from "./gate-bounded-await.js";
@@ -10,6 +12,7 @@ import { failedJudgmentDeny } from "./runner/policy-throw.js";
 import { thrownText } from "./thrown-value.js";
 import { argsAsTheToolReads } from "./effective-path-target.js";
 import { foldHookAsk, refuseOutOfContractDecision } from "./tool-policy.js";
+import { withProbeMandate } from "./ask-origin.js";
 import { applyUnansweredSilence, readStationAnswer, silencedBy } from "./shell-read-silence.js";
 import { asksUnstated, permissionSeatAt, unstatedAskMessage } from "./mode-policy.js";
 export async function runGateFold(pass) {
@@ -25,7 +28,7 @@ export async function runGateFold(pass) {
     catch (error) {
         unread = { error };
     }
-    pass.decision = unread !== undefined ? failedJudgmentDeny(unread.error, callSignal ?? input.abortSignal, (e) => traceHookCrash(input, e, notifier), "the call's target reading", { toolName, toolCallId }) : adjudicate ? refuseOutOfContractDecision(await (callSignal !== undefined ? adjudicate(pass.req, callSignal) : adjudicate(pass.req))) : { action: "allow" };
+    pass.decision = unread !== undefined ? failedJudgmentDeny(unread.error, callSignal ?? input.abortSignal, (e) => traceHookCrash(input, e, notifier), "the call's target reading", { toolName, toolCallId }) : adjudicate ? refuseOutOfContractDecision(await (callSignal !== undefined ? adjudicate(pass.req, callSignal) : adjudicate(pass.req)), { call: pass.req }) : { action: "allow" };
     {
         const read = ledger.fromDecision(pass.decision);
         pass.decision = read.decision;
@@ -37,6 +40,18 @@ export async function runGateFold(pass) {
         if (attributed !== undefined)
             pass.classifierRound = attributed;
     }
+    const rewritten = pass.screening !== undefined && pass.decision.action !== "deny" ? readRejudge(pass.req, pass.currentInput, pass.decision) : undefined;
+    if (pass.screening !== undefined && rewritten?.kind === "rewritten") {
+        const second = await screenRewrite(pass.screening, pass.req, rewritten.form, `the rewritten call to "${toolName}"`);
+        if (second.kind === "refused") {
+            pass.currentInput = rewritten.form;
+            return second.by === "hook" ? hookDenyExit(pass, second.reason) : await engineFailClosedExit(pass, second.reason);
+        }
+        if (second.answer?.additionalContext)
+            pass.preToolContext.push(second.answer.additionalContext);
+        pass.hookAsk = second.answer?.action === "ask" ? second.answer : undefined;
+        pass.hookAllowedBy = second.answer?.action === "allow" ? (second.answeredBy !== undefined ? [second.answeredBy] : []) : undefined;
+    }
     if ((pass.decision.action === "allow" || pass.decision.action === "ask") && pass.decision.updatedInput !== undefined) {
         pass.policyRewrite = argsAsTheToolReads(pass.req, pass.decision.updatedInput);
     }
@@ -123,7 +138,7 @@ export async function runGateFold(pass) {
         if (tighten) {
             pass.decision = {
                 action: "ask",
-                message: markTightenMessage(toolName, "irreversible"),
+                message: markTightenMessage(toolName, input.irreversibility === "always" ? "irreversible" : "unproven"),
                 decisionReason: "safety",
                 ...(probeReason !== undefined ? { probeReason } : {}),
                 ...(probeCause !== undefined ? { probeCause } : {}),
@@ -133,7 +148,7 @@ export async function runGateFold(pass) {
             pass.tightenedBy = input.shellGated === true ? "shell_gate" : "safety";
         }
         else if (alreadyAsking && probeMandated === true && pass.decision.action === "ask") {
-            pass.decision = { ...pass.decision, probeMandated: true };
+            pass.decision = withProbeMandate(pass.decision, probeReason);
         }
     }
     if (input.peerMessage === true && pass.decision.action === "allow" && input.autoMode !== undefined) {
@@ -218,19 +233,18 @@ function applyShellReadVerdict(pass, answer, toolName, shellGated) {
                 pass.shellReadDetails = verdict.details;
             if (pass.decision.action !== "allow") {
                 if (pass.decision.action === "ask")
-                    pass.decision = { ...pass.decision, probeMandated: true, ...silencedBy(verdict, pass.decision) };
+                    pass.decision = silencedBy(withProbeMandate(pass.decision, account), verdict, pass.req);
                 return;
             }
             const candidate = normalizeReadRootCandidate(verdict.readRootCandidate);
-            pass.decision = {
+            pass.decision = silencedBy({
                 action: "ask",
                 message: shellReadAskMessage(toolName, verdict),
                 decisionReason: "safety",
                 probeMandated: true,
-                ...silencedBy(verdict, {}),
                 ...(account !== undefined ? { probeReason: account } : {}),
                 ...(candidate !== undefined ? { probeReadRootCandidate: candidate } : {}),
-            };
+            }, verdict, pass.req);
             if (candidate !== undefined)
                 pass.shellReadOffer = true;
             pass.tightenedBy = shellGated ? "shell_gate" : "safety";
@@ -241,17 +255,16 @@ function applyShellReadVerdict(pass, answer, toolName, shellGated) {
             if (verdict.details !== undefined)
                 pass.shellReadDetails = verdict.details;
             if (pass.decision.action === "ask")
-                pass.decision = { ...pass.decision, ...silencedBy(verdict, pass.decision) };
+                pass.decision = silencedBy(pass.decision, verdict, pass.req);
             if (pass.decision.action === "allow") {
                 const candidate = normalizeReadRootCandidate(verdict.readRootCandidate);
-                pass.decision = {
+                pass.decision = silencedBy({
                     action: "ask",
                     message: shellReadAskMessage(toolName, verdict),
                     decisionReason: "safety",
-                    ...silencedBy(verdict, {}),
                     ...(account !== undefined ? { probeReason: account } : {}),
                     ...(candidate !== undefined ? { probeReadRootCandidate: candidate } : {}),
-                };
+                }, verdict, pass.req);
                 if (candidate !== undefined)
                     pass.shellReadOffer = true;
                 pass.tightenedBy = shellGated ? "shell_gate" : "safety";