@decidio/sdk 0.2.2 → 0.3.0

package/dist/resume.js

@@ -78,9 +78,9 @@ export function verifyEvidence(rec, agentKey, webhookSecret) {
     }
 }
 export const EXECUTION_STATES = [
-    "parked", "claimed_preinvoke", "invoking", "executed_unreported", "indeterminate", "reported",
+    "parked", "claimed_preinvoke", "discarded", "invoking", "executed_unreported", "indeterminate", "reported",
 ];
-export const NON_REPLAYABLE = ["invoking", "executed_unreported", "indeterminate", "reported"];
+export const NON_REPLAYABLE = ["discarded", "invoking", "executed_unreported", "indeterminate", "reported"];
 export class DecidioStaleAttemptError extends Error {
     decisionId;
     owner;
@@ -101,16 +101,47 @@ export class DecidioAlreadySettledError extends Error {
         this.name = "DecidioAlreadySettledError";
     }
 }
+export class DecidioRecoveryUnavailableError extends Error {
+    cause;
+    constructor(cause) {
+        super(`[decidio] recover(): the execution ledger could not be read (${cause?.message ?? cause}). Refusing to return an empty recovery list, which would read as "nothing is outstanding" — inspect the store; some actions may be awaiting a report.`);
+        this.cause = cause;
+        this.name = "DecidioRecoveryUnavailableError";
+    }
+}
+export class DecidioDeniedError extends Error {
+    decisionId;
+    verdict;
+    constructor(decisionId, verdict) {
+        super(`[decidio] ${decisionId}: this decision was DENIED (${verdict}) and a denial is terminal — refusing a state write that would move it back toward execution. Nothing may advance out of a denial; if this action should now proceed it needs a NEW request and a new approval.`);
+        this.decisionId = decisionId;
+        this.verdict = verdict;
+        this.name = "DecidioDeniedError";
+    }
+}
+function assertNotDenied(id, cur, next) {
+    if (cur.state === "discarded" && next !== "discarded")
+        throw new DecidioDeniedError(id, cur.verdict ?? "rejected");
+}
+function assertClaimedBy(id, cur, attemptId) {
+    if (cur.state !== "claimed_preinvoke" || cur.attemptId !== attemptId) {
+        throw new Error(`[decidio] ${id}: refusing to cross the invocation boundary — attempt ${attemptId} does not hold a claim on this decision (state ${cur.state}, held by ${cur.attemptId || "nobody"}). A claim is the only way to acquire ownership; call claim() and act on its result.`);
+    }
+}
 function assertNotSettled(id, cur, next) {
     if (cur.reconciled?.outcome === "committed" && (next === "executed_unreported" || next === "indeterminate")) {
         throw new DecidioAlreadySettledError(id);
     }
 }
 export const SETTLE_OUTCOMES = ["committed", "not_committed"];
-export function assertSettlable(id, state, outcome, hasObservedEvidence = true) {
+export function assertSettlable(id, state, outcome, opts = {}) {
+    const hasObservedEvidence = opts.hasObservedEvidence ?? true;
     if (!SETTLE_OUTCOMES.includes(outcome)) {
         throw new Error(`[decidio] ${id}: outcome must be "committed" or "not_committed", not ${JSON.stringify(outcome)}.`);
     }
+    if (state === "discarded") {
+        throw new Error(`[decidio] ${id}: this decision was DENIED by a human or a policy, and a denial is final — it cannot be reconciled, released or retried. Nothing ran, so there is no outcome to record. If this action should now proceed it needs a NEW request and a new approval.`);
+    }
     if (outcome === "committed") {
         if (state === "reported")
             throw new Error(`[decidio] ${id}: already reported — there is nothing left to reconcile.`);
@@ -126,6 +157,9 @@ export function assertSettlable(id, state, outcome, hasObservedEvidence = true)
             throw new Error(`[decidio] ${id}: this decision holds CAPTURED EVIDENCE of an execution — releasing it would re-run a proven write. Re-send the evidence with reconfirm("${id}") instead.`);
         if (state === "parked")
             throw new Error(`[decidio] ${id}: already parked — nothing to release.`);
+        if (state === "invoking" && opts.workerStopped !== true) {
+            throw new Error(`[decidio] ${id}: this decision is still INVOKING — the worker that claimed it may be running the action right now, and releasing it would let a second worker run the same approved action. Stop or confirm the death of that worker first, then say so explicitly: reconcile("${id}", { outcome: "not_committed", reason: …, workerStopped: true }). If you cannot confirm it stopped, treat the decision as possibly executed and reconcile it as "committed" once you have checked the downstream system.`);
+        }
     }
 }
 const rank = (s) => EXECUTION_STATES.indexOf(s);
@@ -135,11 +169,12 @@ export class MemoryPendingStore {
     rec(id) {
         return this.x.get(id) ?? { decisionId: id, state: "parked", attemptId: null, at: new Date().toISOString() };
     }
-    advance(id, attemptId, state, patch = {}) {
+    advance(id, attemptId, state, patch = {}, takeover = false) {
         const cur = this.rec(id);
-        if (cur.attemptId && cur.attemptId !== attemptId && rank(cur.state) >= rank("invoking")) {
+        if (!takeover && cur.attemptId && cur.attemptId !== attemptId) {
             throw new DecidioStaleAttemptError(id, cur.attemptId, cur.state);
         }
+        assertNotDenied(id, cur, state);
         assertNotSettled(id, cur, state);
         if (rank(state) < rank(cur.state)) {
             throw new Error(`[decidio] ${id}: refusing to move ${cur.state} → ${state}; execution state only ever advances.`);
@@ -152,7 +187,15 @@ export class MemoryPendingStore {
             this.x.set(p.decisionId, { decisionId: p.decisionId, state: "parked", attemptId: null, action: p.action, at: new Date().toISOString() });
     }
     async get(id) { return this.m.get(id) ?? null; }
-    async delete(id) { this.m.delete(id); }
+    async delete(id, attemptId) {
+        if (attemptId && !this.ownsPayload(id, attemptId))
+            return;
+        this.m.delete(id);
+    }
+    ownsPayload(id, attemptId) {
+        const owner = this.x.get(id)?.attemptId;
+        return !owner || owner === attemptId;
+    }
     async list() { return [...this.m.values()].filter((p) => this.rec(p.decisionId).state === "parked"); }
     async claim(id, attemptId) {
         if (!this.m.has(id))
@@ -162,59 +205,87 @@ export class MemoryPendingStore {
             return { ok: false, state: cur.state, reason: `already ${cur.state}` };
         if (cur.state === "claimed_preinvoke")
             return { ok: false, state: cur.state, reason: "claimed by another attempt" };
-        this.advance(id, attemptId, "claimed_preinvoke", { action: this.m.get(id)?.action });
+        this.advance(id, attemptId, "claimed_preinvoke", { action: this.m.get(id)?.action }, true);
         return { ok: true };
     }
-    async markInvoking(id, attemptId) { this.advance(id, attemptId, "invoking"); }
+    async markInvoking(id, attemptId) {
+        const cur = this.rec(id);
+        assertNotDenied(id, cur, "invoking");
+        assertClaimedBy(id, cur, attemptId);
+        this.advance(id, attemptId, "invoking");
+    }
     async recordExecuted(id, attemptId, evidence, evidenceSig, evidenceError) { this.advance(id, attemptId, "executed_unreported", { evidence, hasEvidence: true, evidenceSig, evidenceError }); }
     async markIndeterminate(id, attemptId, error) { this.advance(id, attemptId, "indeterminate", { error }); }
     async markReported(id, attemptId, confirmation) { this.advance(id, attemptId, "reported", { confirmation }); }
+    async markDiscarded(id, verdict, reason) { this.advance(id, this.x.get(id)?.attemptId ?? "", "discarded", { verdict, ...(reason ? { discardReason: reason } : {}) }); }
     async getExecution(id) { return this.x.get(id) ?? null; }
     async listExecutions() { return [...this.x.values()]; }
     async settle(id, outcome, opts = {}) {
         const cur = this.rec(id);
-        assertSettlable(id, cur.state, outcome, !cur.evidenceError);
+        assertSettlable(id, cur.state, outcome, { hasObservedEvidence: !cur.evidenceError, workerStopped: opts.workerStopped });
         const at = new Date().toISOString();
-        const reconciled = { outcome, reason: opts.reason, at };
+        const reconciled = { outcome, reason: opts.reason, at, ...(opts.workerStopped ? { workerStopped: true } : {}) };
         this.x.set(id, outcome === "committed"
             ? { ...cur, state: "executed_unreported", evidence: opts.evidence ?? null, hasEvidence: true, evidenceSig: opts.evidenceSig, evidenceError: undefined, reconciled, at }
             : { ...cur, state: "parked", attemptId: null, error: undefined, reconciled, at });
     }
     async releasePreinvoke(id, attemptId) {
         const cur = this.rec(id);
-        if (rank(cur.state) >= rank("invoking"))
-            throw new Error(`[decidio] ${id}: refusing to release a claim after invocation began (state ${cur.state}).`);
+        if (NON_REPLAYABLE.includes(cur.state))
+            throw new Error(`[decidio] ${id}: refusing to release this decision — its durable state is ${cur.state}, which is terminal or past the invocation boundary. releasePreinvoke only ever releases a claim nothing has acted on.`);
         if (cur.attemptId && cur.attemptId !== attemptId)
             return;
         this.x.set(id, { ...cur, state: "parked", attemptId: null, at: new Date().toISOString() });
     }
 }
+export function windowsPrincipal() {
+    const sysRoot = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+    for (const exe of [join(sysRoot, "System32", "whoami.exe"), "whoami"]) {
+        try {
+            const out = execFileSync(exe, ["/user", "/fo", "csv", "/nh"], { encoding: "utf8" });
+            const m = out.match(/S-1-[0-9-]+/);
+            if (m)
+                return `*${m[0]}`;
+        }
+        catch { }
+    }
+    try {
+        return userInfo().username;
+    }
+    catch {
+        return process.env.USERNAME ?? process.env.USER ?? "";
+    }
+}
+export function hardenFile(file) {
+    if (process.platform !== "win32")
+        return null;
+    try {
+        const principal = windowsPrincipal();
+        if (!principal)
+            return "could not determine the current user";
+        execFileSync("icacls", [file, "/inheritance:r", "/grant:r", `${principal}:F`, "/grant:r", "*S-1-5-18:F"], { stdio: "ignore" });
+        try {
+            readFileSync(file, "utf8");
+        }
+        catch (verifyError) {
+            try {
+                execFileSync("icacls", [file, "/inheritance:e"], { stdio: "ignore" });
+            }
+            catch { }
+            return `the restriction applied but this process could no longer read the file (${verifyError?.message ?? verifyError}), so it was rolled back`;
+        }
+        return null;
+    }
+    catch (e) {
+        return String(e?.message ?? e);
+    }
+}
 export function hardenDir(dir) {
     if (process.platform !== "win32")
         return;
     const warn = (why) => console.warn(`[decidio] WARNING: could not restrict ${dir} to owner-only (${why}). It keeps the directory's inherited permissions, so other accounts on this machine may be able to read parked action arguments. Move the pending store to a protected location, or set DECIDIO_PENDING_DIR to one.`);
     try {
-        const sid = (() => {
-            const sysRoot = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
-            for (const exe of [join(sysRoot, "System32", "whoami.exe"), "whoami"]) {
-                try {
-                    const out = execFileSync(exe, ["/user", "/fo", "csv", "/nh"], { encoding: "utf8" });
-                    const m = out.match(/S-1-[0-9-]+/);
-                    if (m)
-                        return m[0];
-                }
-                catch { }
-            }
-            return null;
-        })();
-        const principal = sid ? `*${sid}` : (() => {
-            try {
-                return userInfo().username;
-            }
-            catch {
-                return process.env.USERNAME ?? process.env.USER ?? "";
-            }
-        })();
+        const principal = windowsPrincipal();
         if (!principal)
             throw new Error("could not determine the current user");
         execFileSync("icacls", [dir, "/inheritance:r", "/grant:r", `${principal}:(OI)(CI)F`, "/grant:r", "*S-1-5-18:(OI)(CI)F"], { stdio: "ignore" });
@@ -271,6 +342,7 @@ export class FilePendingStore {
     resolve(id) {
         const corrupt = [];
         let best = null;
+        let denial = null;
         for (const s of EXECUTION_STATES) {
             const f = this.statePath(id, s);
             if (!existsSync(f))
@@ -279,21 +351,27 @@ export class FilePendingStore {
                 const r = JSON.parse(readFileSync(f, "utf8"));
                 if (!best || rank(s) >= rank(best.state))
                     best = { ...r, state: s };
+                if (s === "discarded")
+                    denial = { ...r, state: "discarded" };
             }
             catch (e) {
                 corrupt.push(`${f}: ${e.message}`);
             }
         }
-        return { rec: best, corrupt };
+        if (!denial)
+            return { rec: best, corrupt };
+        const ran = best && rank(best.state) >= rank("invoking") ? best : null;
+        return { rec: ran ? { ...denial, executionDespiteDenial: { state: ran.state, at: ran.at, hasEvidence: !!ran.hasEvidence } } : denial, corrupt };
     }
     setState(id, attemptId, state, patch = {}) {
         const { rec, corrupt } = this.resolve(id);
         if (corrupt.length)
             throw new DecidioStateCorruptError(id, corrupt);
         const cur = rec ?? { decisionId: id, state: "parked", attemptId: null, at: new Date().toISOString() };
-        if (cur.attemptId && cur.attemptId !== attemptId && rank(cur.state) >= rank("invoking")) {
+        if (cur.attemptId && cur.attemptId !== attemptId) {
             throw new DecidioStaleAttemptError(id, cur.attemptId, cur.state);
         }
+        assertNotDenied(id, cur, state);
         assertNotSettled(id, cur, state);
         if (rank(state) < rank(cur.state)) {
             throw new Error(`[decidio] ${id}: refusing to move ${cur.state} → ${state}; execution state only ever advances.`);
@@ -323,11 +401,18 @@ export class FilePendingStore {
         const f = this.path(id);
         return existsSync(f) ? JSON.parse(readFileSync(f, "utf8")) : null;
     }
-    async delete(id) { try {
-        if (existsSync(this.path(id)))
-            rmSync(this.path(id));
+    async delete(id, attemptId) {
+        if (attemptId) {
+            const owner = this.resolve(id).rec?.attemptId;
+            if (owner && owner !== attemptId)
+                return;
+        }
+        try {
+            if (existsSync(this.path(id)))
+                rmSync(this.path(id));
+        }
+        catch { }
     }
-    catch { } }
     async list() {
         if (!existsSync(this.dir))
             return [];
@@ -360,7 +445,7 @@ export class FilePendingStore {
             return { ok: false, state, reason: "claimed by another attempt" };
         const target = this.statePath(id, "claimed_preinvoke");
         const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
-        const payload = JSON.stringify({ decisionId: id, state: "claimed_preinvoke", attemptId, action: rec?.action, at: new Date().toISOString() }, null, 2);
+        const payload = JSON.stringify({ ...(rec ?? {}), decisionId: id, state: "claimed_preinvoke", attemptId, action: rec?.action, at: new Date().toISOString() }, null, 2);
         const fd = openSync(tmp, "w", 0o600);
         try {
             writeFileSync(fd, payload);
@@ -391,10 +476,19 @@ export class FilePendingStore {
         catch { }
         return { ok: true };
     }
-    async markInvoking(id, attemptId) { this.setState(id, attemptId, "invoking"); }
+    async markInvoking(id, attemptId) {
+        const { rec, corrupt } = this.resolve(id);
+        if (corrupt.length)
+            throw new DecidioStateCorruptError(id, corrupt);
+        const cur = rec ?? { decisionId: id, state: "parked", attemptId: null, at: new Date().toISOString() };
+        assertNotDenied(id, cur, "invoking");
+        assertClaimedBy(id, cur, attemptId);
+        this.setState(id, attemptId, "invoking");
+    }
     async recordExecuted(id, attemptId, evidence, evidenceSig, evidenceError) { this.setState(id, attemptId, "executed_unreported", { evidence, hasEvidence: true, evidenceSig, evidenceError }); }
     async markIndeterminate(id, attemptId, error) { this.setState(id, attemptId, "indeterminate", { error }); }
     async markReported(id, attemptId, confirmation) { this.setState(id, attemptId, "reported", { confirmation }); }
+    async markDiscarded(id, verdict, reason) { this.setState(id, this.resolve(id).rec?.attemptId ?? "", "discarded", { verdict, ...(reason ? { discardReason: reason } : {}) }); }
     async getExecution(id) {
         const { rec, corrupt } = this.resolve(id);
         if (corrupt.length)
@@ -431,11 +525,12 @@ export class FilePendingStore {
         if (corrupt.length)
             throw new DecidioStateCorruptError(id, corrupt);
         const cur = rec ?? { decisionId: id, state: "parked", attemptId: null, at: new Date().toISOString() };
-        assertSettlable(id, cur.state, outcome, !cur.evidenceError);
+        assertSettlable(id, cur.state, outcome, { hasObservedEvidence: !cur.evidenceError, workerStopped: opts.workerStopped });
         const at = new Date().toISOString();
+        const reconciled = { outcome, reason: opts.reason, at, ...(opts.workerStopped ? { workerStopped: true } : {}) };
         const next = outcome === "committed"
-            ? { ...cur, state: "executed_unreported", evidence: opts.evidence ?? null, hasEvidence: true, evidenceSig: opts.evidenceSig, evidenceError: undefined, reconciled: { outcome, reason: opts.reason, at }, at }
-            : { ...cur, state: "parked", attemptId: null, error: undefined, reconciled: { outcome, reason: opts.reason, at }, at };
+            ? { ...cur, state: "executed_unreported", evidence: opts.evidence ?? null, hasEvidence: true, evidenceSig: opts.evidenceSig, evidenceError: undefined, reconciled, at }
+            : { ...cur, state: "parked", attemptId: null, error: undefined, reconciled, at };
         this.writeAtomic(this.statePath(id, next.state), JSON.stringify(next, null, 2));
         for (const st of EXECUTION_STATES) {
             if (st === next.state)
@@ -451,11 +546,11 @@ export class FilePendingStore {
     async releasePreinvoke(id, attemptId) {
         const { rec } = this.resolve(id);
         const state = rec?.state ?? "parked";
-        if (rank(state) >= rank("invoking"))
-            throw new Error(`[decidio] ${id}: refusing to release a claim after invocation began (state ${state}).`);
+        if (NON_REPLAYABLE.includes(state))
+            throw new Error(`[decidio] ${id}: refusing to release this decision — its durable state is ${state}, which is terminal or past the invocation boundary. releasePreinvoke only ever releases a claim nothing has acted on.`);
         if (rec?.attemptId && rec.attemptId !== attemptId)
             return;
-        this.writeAtomic(this.statePath(id, "parked"), JSON.stringify({ decisionId: id, state: "parked", attemptId: null, action: rec?.action, at: new Date().toISOString() }, null, 2));
+        this.writeAtomic(this.statePath(id, "parked"), JSON.stringify({ ...(rec ?? {}), decisionId: id, state: "parked", attemptId: null, action: rec?.action, at: new Date().toISOString() }, null, 2));
         try {
             const c = this.statePath(id, "claimed_preinvoke");
             if (existsSync(c))
@@ -472,6 +567,11 @@ export class FilePendingStore {
                 const key = name.slice(0, -".claimed".length);
                 try {
                     const p = JSON.parse(readFileSync(join(this.dir, name), "utf8"));
+                    const existing = this.resolve(p.decisionId).rec;
+                    if (existing && NON_REPLAYABLE.includes(existing.state)) {
+                        renameSync(join(this.dir, name), join(this.dir, `${name}.migrated`));
+                        continue;
+                    }
                     this.writeAtomic(this.statePath(p.decisionId, "indeterminate"), JSON.stringify({ decisionId: p.decisionId, state: "indeterminate", attemptId: null, action: p.action, error: "upgraded from 0.1.x while claimed — whether it ran is not knowable; reconcile it", at: new Date().toISOString() }, null, 2));
                     this.writeAtomic(this.path(p.decisionId), JSON.stringify(p, null, 2));
                     rmSync(join(this.dir, name));
@@ -518,6 +618,11 @@ export class FilePendingStore {
                     renameSync(file, `${file}.migrated`);
                     continue;
                 }
+                if (existing?.state === "discarded") {
+                    renameSync(file, `${file}.migrated`);
+                    console.error(`[decidio] ${e.decisionId}: a 0.1.x execution report was found for a decision that was DENIED (${existing.verdict ?? "rejected"}). It has NOT been added to the ledger — a denial is terminal and this report will not be sent. The file is kept as ${file}.migrated: if that action really ran, check the downstream system and correct it there.`);
+                    continue;
+                }
                 this.writeAtomic(this.statePath(e.decisionId, "executed_unreported"), JSON.stringify({
                     decisionId: e.decisionId, state: "executed_unreported", attemptId: null, action: e.action,
                     evidence: e.reported, hasEvidence: true, migratedFrom: "0.1.x report journal",
@@ -615,6 +720,7 @@ async function statusOf(cfg, decisionId) {
 const V2_STORE_METHODS = [
     "put", "get", "delete", "list",
     "claim", "markInvoking", "recordExecuted", "markIndeterminate", "markReported",
+    "markDiscarded",
     "getExecution", "listExecutions", "releasePreinvoke", "settle",
 ];
 function assertStoreV2(store) {
@@ -622,7 +728,7 @@ function assertStoreV2(store) {
     if (!missing.length)
         return;
     throw new Error(`[decidio] this PendingStore is missing ${missing.length} required method${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}.\n` +
-        `  0.2.0 makes the durable execution state machine MANDATORY (parked → claimed_preinvoke → invoking → executed_unreported | indeterminate → reported).\n` +
+        `  The durable execution state machine is MANDATORY (parked → claimed_preinvoke → invoking → executed_unreported | indeterminate → reported, plus the terminal "discarded" that a denial writes).\n` +
         `  The 0.1.x contract left claim() optional and fell back to a process-local guard, which cannot survive a restart — so it never carried the single-execution guarantee it appeared to. A store that cannot record that invocation BEGAN cannot prevent a committed action from running twice.\n` +
         `  Fix: implement the missing methods (see the PendingStore docs), or use the shipped FilePendingStore / MemoryPendingStore. Nothing was started.`);
 }
@@ -679,7 +785,7 @@ export function createDecidioResume(opts) {
                 if (e instanceof DecidioStaleAttemptError) {
                     console.warn(`[decidio] ${decisionId}: this action finished, but the decision is now owned by a newer attempt — it was released for retry while this one was still running. This attempt's report is NOT being sent; the owning attempt reports. Your action DID run: if that means it ran twice, the release was premature.`);
                     try {
-                        await ctrl.store.delete(decisionId);
+                        await ctrl.store.delete(decisionId, attemptId);
                     }
                     catch { }
                     return { ...base, reportRecorded: false, executionConfirmed: false, confirmationRetryable: false, reportJournalled: false, diagnostic: `${decisionId} was released to a newer attempt while this one was running; this attempt's report was not sent. If your action is not idempotent, note that it has now run more than once.` };
@@ -687,11 +793,15 @@ export function createDecidioResume(opts) {
                 if (e instanceof DecidioAlreadySettledError) {
                     console.warn(`[decidio] ${decisionId}: this action finished, but an operator had already reconciled the decision as committed and Decidio has that report. This attempt's own report is NOT being sent — one decision, one report. If your result differs from what was reconciled, correct it in Decidio; do NOT re-run the action.`);
                     try {
-                        await ctrl.store.delete(decisionId);
+                        await ctrl.store.delete(decisionId, attemptId);
                     }
                     catch { }
                     return { ...base, reportRecorded: true, executionConfirmed: false, reportJournalled: true, diagnostic: `an operator settled ${decisionId} as committed while this attempt was running; their report stands and this one was not sent.` };
                 }
+                if (e instanceof DecidioDeniedError) {
+                    console.error(`[decidio] ${decisionId}: this decision is DENIED, so no execution report will be sent. If your action nevertheless ran, your store let a refused decision reach the handler — treat that as a defect in the store, and correct the downstream effect by hand.`);
+                    return { ...base, reportRecorded: false, executionConfirmed: false, confirmationRetryable: false, reportJournalled: false, diagnostic: `${decisionId} is denied; no report was sent.` };
+                }
                 console.error(`[decidio] ${decisionId}: the action RAN but its execution report could NOT be recorded (${e?.message ?? e}). If the report also fails to send, this execution is NOT locally recoverable — record the outcome from your own system.`);
             }
         }
@@ -704,7 +814,7 @@ export function createDecidioResume(opts) {
         }
         const deletePending = async () => {
             try {
-                await ctrl.store.delete(decisionId);
+                await ctrl.store.delete(decisionId, attemptId);
             }
             catch (e) {
                 console.warn(`[decidio] ${decisionId}: the parked payload could not be removed (${e?.message ?? e}). This is cleanup only — the execution ledger already records this decision as executed, so no process can run it again; remove the row at your convenience.`);
@@ -743,11 +853,11 @@ export function createDecidioResume(opts) {
         return { ...base, reportRecorded: ev.reportRecorded, executionConfirmed: ev.executionConfirmed, ...(ev.evidenceTier ? { evidenceTier: ev.evidenceTier } : {}), ...(ev.executionReportVerified !== undefined ? { executionReportVerified: ev.executionReportVerified } : {}), ...(ev.executionReportReason ? { executionReportReason: ev.executionReportReason } : {}), ...(ev.confirmationRetryable !== undefined ? { confirmationRetryable: ev.confirmationRetryable } : {}), reportJournalled: journalled, ...(buildProblem ? { evidenceError: buildProblem } : {}), ...(diagnostic ? { diagnostic } : {}) };
     }
     const refusalWarned = new Set();
-    const refuseOnce = (decisionId, msg) => {
+    const refuseOnce = (decisionId, msg, tail) => {
         if (refusalWarned.has(decisionId))
             return;
         refusalWarned.add(decisionId);
-        console.error(msg + " (This prints once — the entry stays parked until you act.)");
+        console.error(msg + (tail ?? " (This prints once — the entry stays parked until you act.)"));
     };
     const ctrl = {
         ...opts,
@@ -783,13 +893,10 @@ export function createDecidioResume(opts) {
             const pending = await ctrl.store.get(decisionId);
             if (!pending)
                 return { status: "unknown", decisionId };
-            if (verdict === "rejected") {
+            if (verdict === "rejected" || verdict === "blocked") {
+                await ctrl.store.markDiscarded(decisionId, verdict, reason);
                 await ctrl.store.delete(decisionId);
-                return finish({ status: "rejected", decisionId, action: pending.action, reason });
-            }
-            if (verdict === "blocked") {
-                await ctrl.store.delete(decisionId);
-                return finish({ status: "blocked", decisionId, action: pending.action, reason });
+                return finish({ status: verdict, decisionId, action: pending.action, reason });
             }
             if (verdict !== "approved" && verdict !== "auto_approved")
                 return { status: "unknown", decisionId };
@@ -827,7 +934,9 @@ export function createDecidioResume(opts) {
             const claim = await ctrl.store.claim(decisionId, attemptId);
             if (!claim.ok) {
                 if (claim.state && NON_REPLAYABLE.includes(claim.state)) {
-                    refuseOnce(decisionId, `[decidio] REFUSING to execute ${decisionId}: its durable state is ${claim.state} — invocation already began, so re-running it could duplicate a committed effect. Inspect it with guard.resume.recover(); settle it with guard.resume.reconcile("${decisionId}", …).`);
+                    refuseOnce(decisionId, claim.state === "discarded"
+                        ? `[decidio] REFUSING to execute ${decisionId}: it was DENIED (${(await ctrl.store.getExecution(decisionId))?.verdict ?? "rejected"}) and that answer is final. Nothing ran. A denial cannot be reconciled or retried — if this action should now proceed, it needs a NEW request and a new approval.`
+                        : `[decidio] REFUSING to execute ${decisionId}: its durable state is ${claim.state} — invocation already began, so re-running it could duplicate a committed effect. Inspect it with guard.resume.recover(); settle it with guard.resume.reconcile("${decisionId}", …).`, claim.state === "discarded" ? " (This prints once. The decision is closed — no action is needed.)" : undefined);
                     return finish({ status: claim.state === "indeterminate" ? "indeterminate" : "unknown", decisionId, action: pending.action, reason: claim.reason });
                 }
                 return { status: "unknown", decisionId };
@@ -933,7 +1042,7 @@ export function createDecidioResume(opts) {
                 ? signEvidence(decisionId, entry.attemptId ?? null, settleEvidence, ctrl.agentKey, ctrl.webhookSecret)
                 : undefined;
             try {
-                await ctrl.store.settle(decisionId, opts.outcome, { evidence: settleEvidence, reason: opts.reason, evidenceSig: settleSig });
+                await ctrl.store.settle(decisionId, opts.outcome, { evidence: settleEvidence, reason: opts.reason, evidenceSig: settleSig, workerStopped: opts.workerStopped });
             }
             catch (e) {
                 return { reportRecorded: false, executionConfirmed: false, diagnostic: `${e?.message ?? e}` };
@@ -977,6 +1086,14 @@ export function createDecidioResume(opts) {
             if (entry?.state === "indeterminate") {
                 return { reportRecorded: false, executionConfirmed: false, diagnostic: `${decisionId} is INDETERMINATE: it was invoked and its outcome is unknown, so there is no captured result to re-send. Settle it with reconcile("${decisionId}", …) once you have checked the downstream system.` };
             }
+            if (entry?.state === "discarded") {
+                return {
+                    reportRecorded: false, executionConfirmed: false,
+                    diagnostic: entry.executionDespiteDenial
+                        ? `${decisionId} was DENIED (${entry.verdict ?? "rejected"}), and this store ALSO holds an execution marker for it (${entry.executionDespiteDenial.state} at ${entry.executionDespiteDenial.at}). A denial is terminal, so no report will be sent for it — but something may have run. Check the downstream system and correct it there; do NOT re-run the action.`
+                        : `${decisionId} was DENIED (${entry.verdict ?? "rejected"}) and nothing ran, so there is no execution report to send. A denial cannot be reconciled or retried.`,
+                };
+            }
             if (!entry || !entry.hasEvidence) {
                 return {
                     reportRecorded: false, executionConfirmed: false,
@@ -1018,12 +1135,13 @@ export function createDecidioResume(opts) {
         },
         async recover() {
             const items = [];
-            const execs = await ctrl.store.listExecutions().catch((e) => {
-                console.error(`[decidio] recover(): the execution ledger could not be read (${e?.message ?? e}). Nothing is reported rather than reporting a falsely empty recovery list.`);
-                return null;
-            });
-            if (execs === null)
-                return items;
+            let execs;
+            try {
+                execs = await ctrl.store.listExecutions();
+            }
+            catch (e) {
+                throw new DecidioRecoveryUnavailableError(e);
+            }
             for (const r of execs) {
                 const a = r.action ?? "(unknown action)";
                 switch (r.state) {
@@ -1037,7 +1155,7 @@ export function createDecidioResume(opts) {
                         break;
                     case "invoking":
                         items.push({ decisionId: r.decisionId, action: r.action, state: "indeterminate",
-                            guidance: `"${a}" was invoked at ${r.at} and this process died before recording the outcome, so whether it ran is unknown locally. It will NOT be retried automatically — reconcile it as above.` });
+                            guidance: `"${a}" was invoked at ${r.at} by attempt ${r.attemptId ?? "(unknown)"} and no outcome has been recorded since. That does NOT mean the worker died — it may still be running this action. It will not be retried automatically. Check that worker first: if it is gone, settle it with { outcome: "committed", evidence: … } once you have checked the downstream system, or release it with { outcome: "not_committed", reason: …, workerStopped: true }.` });
                         break;
                     case "claimed_preinvoke":
                         items.push({ decisionId: r.decisionId, action: r.action, state: "claimed_stalled",
@@ -1046,6 +1164,12 @@ export function createDecidioResume(opts) {
                     case "parked":
                         items.push({ decisionId: r.decisionId, action: r.action, state: "parked", guidance: `"${a}" is parked awaiting a human decision. Nothing has executed.` });
                         break;
+                    case "discarded":
+                        if (r.executionDespiteDenial) {
+                            items.push({ decisionId: r.decisionId, action: r.action, state: "denied_with_evidence",
+                                guidance: `"${a}" was DENIED (${r.verdict ?? "rejected"})${r.discardReason ? ` — ${r.discardReason}` : ""}, but this store also holds an execution marker for it (${r.executionDespiteDenial.state} at ${r.executionDespiteDenial.at}${r.executionDespiteDenial.hasEvidence ? ", with a captured result" : ""}). Nothing will run it and nothing will report it — a denial is terminal and cannot be reconciled. CHECK THE DOWNSTREAM SYSTEM: if the action really ran, correct it there.` });
+                        }
+                        break;
                     case "reported":
                         break;
                 }

package/dist/signing.d.ts

@@ -1,4 +1,11 @@
-/** Sorted-key JCS — must match apps/api/src/canonical.ts byte-for-byte. */
+/** Sorted-key JCS — must match apps/api/src/canonical.ts byte-for-byte.
+ *
+ *  ONE IMPLEMENTATION (F-006). This was a module-local copy that reached `JSON.stringify` for every
+ *  primitive, so it applied NONE of the strict rules the exported canonicalizer enforces — most
+ *  sharply, it emitted an escaped lone surrogate instead of refusing it. The bytes a bound proof
+ *  SIGNS and the bytes the digest BINDS are the two places that must never disagree with the value
+ *  model, and they were the two places that did. Python already delegated (`signing.canonicalize` →
+ *  `canonical_json`); this is the twin-parity repair on the TypeScript side. */
 export declare function canonicalize(v: unknown): string;
 /** Generate a fresh Ed25519 keypair LOCALLY. Returns the public `did:key` (register this)
  *  and the PKCS8 private key base64 (keep this in the agent host's env as DECIDIO_AGENT_KEY —

package/dist/signing.js

@@ -1,4 +1,5 @@
 import { generateKeyPairSync, createPrivateKey, createPublicKey, sign as edSign, verify as edVerify, createHash, randomUUID } from "node:crypto";
+import { canonicalJson } from "./canonical.js";
 const B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 function b58encode(buf) {
     const digits = [0];
@@ -26,12 +27,7 @@ function b58encode(buf) {
     return str;
 }
 export function canonicalize(v) {
-    if (v === null || typeof v !== "object")
-        return JSON.stringify(v);
-    if (Array.isArray(v))
-        return `[${v.map(canonicalize).join(",")}]`;
-    const o = v;
-    return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${canonicalize(o[k])}`).join(",")}}`;
+    return canonicalJson(v, "canonicalize(...)");
 }
 export function didFromPrivateKey(privateKeyBase64) {
     const priv = createPrivateKey({ key: Buffer.from(privateKeyBase64, "base64"), format: "der", type: "pkcs8" });
@@ -111,20 +107,6 @@ export function assertJsonSafe(value, path = "args") {
     walk(value, path);
 }
 export function assertSafeTransport(url, hasCredential) {
-    if (!hasCredential) {
-        let probe = null;
-        try {
-            probe = new URL(url);
-        }
-        catch {
-            probe = null;
-        }
-        if (probe && (probe.username || probe.password)) {
-            throw new Error(`[decidio] the gate URL carries credentials in the URL itself (${probe.protocol}//user:***@${probe.host}). Decidio authenticates with a bearer token, so this is either a mistake or a secret you did not mean to put on the wire — and it is sent on every request regardless of whether an api token is configured. Remove the user:password from the URL. Nothing was sent.`);
-        }
-    }
-    if (!hasCredential)
-        return;
     let u;
     try {
         u = new URL(url);
@@ -132,9 +114,9 @@ export function assertSafeTransport(url, hasCredential) {
     catch {
         const spelled = url.replace(/[\t\r\n]/g, "").replace(/^[\s\u0000-\u001f\u0085\ufeff]+/, "");
         if (/^http:/i.test(spelled)) {
-            throw new Error(`[decidio] refusing to send credentials over plaintext http to ${JSON.stringify(url)} — that is not a complete absolute URL, so where the request would actually connect is undefined (the path is appended to it, which can turn it into a remote host). Set a full https URL, or http://localhost for local dev. Nothing was sent.`);
+            throw new Error(`[decidio] refusing to ${hasCredential ? "send credentials" : "send a request"} over plaintext http to ${JSON.stringify(url)} — that is not a complete absolute URL, so where the request would actually connect is undefined (the path is appended to it, which can turn it into a remote host). Set a full https URL, or http://localhost for local dev. Nothing was sent.`);
         }
-        return;
+        throw new Error(`[decidio] the gate URL ${JSON.stringify(url)} is not an absolute URL, so there is no host to send to — where a request would actually connect depends entirely on whichever transport resolves it. Decidio needs a full https URL (or http://localhost for local dev). Nothing was sent.`);
     }
     if (u.protocol !== "http:" && u.protocol !== "https:") {
         throw new Error(`[decidio] the gate URL uses the ${u.protocol.replace(":", "")} scheme, which is not a Decidio endpoint — use https (or http://localhost for local dev). Nothing was sent.`);
@@ -148,7 +130,9 @@ export function assertSafeTransport(url, hasCredential) {
     const local = host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1";
     if (local)
         return;
-    throw new Error(`[decidio] refusing to send credentials over plaintext http to ${u.origin} — use https, or localhost for local dev. Nothing was sent.`);
+    throw new Error(hasCredential
+        ? `[decidio] refusing to send credentials over plaintext http to ${u.origin} — use https, or localhost for local dev. Nothing was sent.`
+        : `[decidio] refusing to talk to ${u.origin} over plaintext http — Decidio is https, and an unauthenticated plaintext reply cannot be trusted to carry an authority decision. Use https, or localhost for local dev. Nothing was sent.`);
 }
 export const carriesCredential = (c) => !!c.apiToken || !!(c.agentKey && c.agentDid);
 export function signExecutionReport(privateKeyBase64, fields) {