omk-adaptorch-wpl 0.91.0

package/dist/regenerate-packet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regenerate-packet.d.ts","sourceRoot":"","sources":["../src/regenerate-packet.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA2B,SAAQ,eAAe;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,GAAG,gBAAgB,CAmBzF","sourcesContent":["/**\n * Structured capped-regenerate packet (hints only — no LLM runner in Wave 3).\n */\n\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\nimport { capRepairHints, parseRepairBudget, shouldOfferRepair } from \"./repair-budget.ts\";\nimport type { RepairHintInput } from \"./repair-loop.ts\";\nimport { deriveRepairHints } from \"./repair-loop.ts\";\n\nexport interface RegeneratePacket {\n\tenabled: boolean;\n\tverdict: UserVerdict;\n\tattemptCount: number;\n\tbudget: number;\n\tbudgetRemaining: number;\n\thints: string[];\n\tmessage: string;\n}\n\nexport interface BuildRegeneratePacketInput extends RepairHintInput {\n\tattemptCount: number;\n\tbudgetOverride?: number;\n\tautoRegenerateEnabled: boolean;\n}\n\n/**\n * When auto-regenerate is enabled and verdict is BLOCKED with budget headroom,\n * returns capped hints for operator or downstream agent — does not apply patches.\n */\nexport function buildRegeneratePacket(input: BuildRegeneratePacketInput): RegeneratePacket {\n\tconst budget = parseRepairBudget(input.budgetOverride);\n\tconst rawHints = deriveRepairHints(input);\n\tconst hints = capRepairHints(rawHints, budget);\n\tconst offer = shouldOfferRepair(input.userVerdict, input.attemptCount, budget);\n\tconst enabled = input.autoRegenerateEnabled && offer && hints.length > 0;\n\tconst budgetRemaining = Math.max(0, budget - input.attemptCount);\n\n\treturn {\n\t\tenabled,\n\t\tverdict: input.userVerdict,\n\t\tattemptCount: input.attemptCount,\n\t\tbudget,\n\t\tbudgetRemaining,\n\t\thints: enabled ? hints : [],\n\t\tmessage: enabled\n\t\t\t? \"Capped regenerate packet ready (hints only; re-run wall after editing).\"\n\t\t\t: \"Auto-regenerate not offered (disabled, non-BLOCKED verdict, or repair budget exhausted).\",\n\t};\n}\n"]}

package/dist/regenerate-packet.js

@@ -0,0 +1,29 @@
+/**
+ * Structured capped-regenerate packet (hints only — no LLM runner in Wave 3).
+ */
+import { capRepairHints, parseRepairBudget, shouldOfferRepair } from "./repair-budget.js";
+import { deriveRepairHints } from "./repair-loop.js";
+/**
+ * When auto-regenerate is enabled and verdict is BLOCKED with budget headroom,
+ * returns capped hints for operator or downstream agent — does not apply patches.
+ */
+export function buildRegeneratePacket(input) {
+    const budget = parseRepairBudget(input.budgetOverride);
+    const rawHints = deriveRepairHints(input);
+    const hints = capRepairHints(rawHints, budget);
+    const offer = shouldOfferRepair(input.userVerdict, input.attemptCount, budget);
+    const enabled = input.autoRegenerateEnabled && offer && hints.length > 0;
+    const budgetRemaining = Math.max(0, budget - input.attemptCount);
+    return {
+        enabled,
+        verdict: input.userVerdict,
+        attemptCount: input.attemptCount,
+        budget,
+        budgetRemaining,
+        hints: enabled ? hints : [],
+        message: enabled
+            ? "Capped regenerate packet ready (hints only; re-run wall after editing)."
+            : "Auto-regenerate not offered (disabled, non-BLOCKED verdict, or repair budget exhausted).",
+    };
+}
+//# sourceMappingURL=regenerate-packet.js.map

package/dist/regenerate-packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regenerate-packet.js","sourceRoot":"","sources":["../src/regenerate-packet.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAkBrD;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAiC,EAAoB;IAC1F,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/E,MAAM,OAAO,GAAG,KAAK,CAAC,qBAAqB,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACzE,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;IAEjE,OAAO;QACN,OAAO;QACP,OAAO,EAAE,KAAK,CAAC,WAAW;QAC1B,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,MAAM;QACN,eAAe;QACf,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QAC3B,OAAO,EAAE,OAAO;YACf,CAAC,CAAC,yEAAyE;YAC3E,CAAC,CAAC,0FAA0F;KAC7F,CAAC;AAAA,CACF","sourcesContent":["/**\n * Structured capped-regenerate packet (hints only — no LLM runner in Wave 3).\n */\n\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\nimport { capRepairHints, parseRepairBudget, shouldOfferRepair } from \"./repair-budget.ts\";\nimport type { RepairHintInput } from \"./repair-loop.ts\";\nimport { deriveRepairHints } from \"./repair-loop.ts\";\n\nexport interface RegeneratePacket {\n\tenabled: boolean;\n\tverdict: UserVerdict;\n\tattemptCount: number;\n\tbudget: number;\n\tbudgetRemaining: number;\n\thints: string[];\n\tmessage: string;\n}\n\nexport interface BuildRegeneratePacketInput extends RepairHintInput {\n\tattemptCount: number;\n\tbudgetOverride?: number;\n\tautoRegenerateEnabled: boolean;\n}\n\n/**\n * When auto-regenerate is enabled and verdict is BLOCKED with budget headroom,\n * returns capped hints for operator or downstream agent — does not apply patches.\n */\nexport function buildRegeneratePacket(input: BuildRegeneratePacketInput): RegeneratePacket {\n\tconst budget = parseRepairBudget(input.budgetOverride);\n\tconst rawHints = deriveRepairHints(input);\n\tconst hints = capRepairHints(rawHints, budget);\n\tconst offer = shouldOfferRepair(input.userVerdict, input.attemptCount, budget);\n\tconst enabled = input.autoRegenerateEnabled && offer && hints.length > 0;\n\tconst budgetRemaining = Math.max(0, budget - input.attemptCount);\n\n\treturn {\n\t\tenabled,\n\t\tverdict: input.userVerdict,\n\t\tattemptCount: input.attemptCount,\n\t\tbudget,\n\t\tbudgetRemaining,\n\t\thints: enabled ? hints : [],\n\t\tmessage: enabled\n\t\t\t? \"Capped regenerate packet ready (hints only; re-run wall after editing).\"\n\t\t\t: \"Auto-regenerate not offered (disabled, non-BLOCKED verdict, or repair budget exhausted).\",\n\t};\n}\n"]}

package/dist/repair-budget.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Capped regenerate repair budget (attempt counting vs env/config budget).
+ */
+import type { UserVerdict } from "./b2c-verdict.ts";
+export interface RepairBudgetState {
+    packetKey: string;
+    attempts: number;
+    lastVerdict: UserVerdict;
+}
+/**
+ * Parse a non-negative repair budget cap. Uses `override` when provided; otherwise reads
+ * `OMK_WALL_REPAIR_BUDGET` from the environment (invalid/missing → default 1).
+ */
+export declare function parseRepairBudget(override?: number): number;
+/**
+ * Whether another capped regenerate/repair offer is allowed for this packet.
+ * Offers while `attemptCount` is strictly below `budget` (0-based attempts consumed).
+ */
+export declare function shouldOfferRepair(verdict: UserVerdict, attemptCount: number, budget: number): boolean;
+/**
+ * Cap a list of repair hint strings for display (capped regenerate algorithm).
+ */
+export declare function capRepairHints(hints: string[], budget: number): string[];
+//# sourceMappingURL=repair-budget.d.ts.map

package/dist/repair-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-budget.d.ts","sourceRoot":"","sources":["../src/repair-budget.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;CACzB;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKrG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAIxE","sourcesContent":["/**\n * Capped regenerate repair budget (attempt counting vs env/config budget).\n */\n\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\n\nexport interface RepairBudgetState {\n\tpacketKey: string;\n\tattempts: number;\n\tlastVerdict: UserVerdict;\n}\n\nconst DEFAULT_REPAIR_BUDGET = 1;\n\n/**\n * Parse a non-negative repair budget cap. Uses `override` when provided; otherwise reads\n * `OMK_WALL_REPAIR_BUDGET` from the environment (invalid/missing → default 1).\n */\nexport function parseRepairBudget(override?: number): number {\n\tif (override !== undefined) {\n\t\tif (!Number.isFinite(override) || override < 0) return DEFAULT_REPAIR_BUDGET;\n\t\treturn Math.floor(override);\n\t}\n\tconst raw = process.env.OMK_WALL_REPAIR_BUDGET?.trim();\n\tif (!raw) return DEFAULT_REPAIR_BUDGET;\n\tconst n = Number.parseInt(raw, 10);\n\tif (!Number.isFinite(n) || n < 0) return DEFAULT_REPAIR_BUDGET;\n\treturn n;\n}\n\n/**\n * Whether another capped regenerate/repair offer is allowed for this packet.\n * Offers while `attemptCount` is strictly below `budget` (0-based attempts consumed).\n */\nexport function shouldOfferRepair(verdict: UserVerdict, attemptCount: number, budget: number): boolean {\n\tif (verdict !== \"BLOCKED\") return false;\n\tconst cap = parseRepairBudget(budget);\n\tif (cap === 0) return false;\n\treturn attemptCount < cap;\n}\n\n/**\n * Cap a list of repair hint strings for display (capped regenerate algorithm).\n */\nexport function capRepairHints(hints: string[], budget: number): string[] {\n\tconst cap = parseRepairBudget(budget);\n\tif (cap === 0 || hints.length === 0) return [];\n\treturn hints.slice(0, cap);\n}\n"]}

package/dist/repair-budget.js

@@ -0,0 +1,44 @@
+/**
+ * Capped regenerate repair budget (attempt counting vs env/config budget).
+ */
+const DEFAULT_REPAIR_BUDGET = 1;
+/**
+ * Parse a non-negative repair budget cap. Uses `override` when provided; otherwise reads
+ * `OMK_WALL_REPAIR_BUDGET` from the environment (invalid/missing → default 1).
+ */
+export function parseRepairBudget(override) {
+    if (override !== undefined) {
+        if (!Number.isFinite(override) || override < 0)
+            return DEFAULT_REPAIR_BUDGET;
+        return Math.floor(override);
+    }
+    const raw = process.env.OMK_WALL_REPAIR_BUDGET?.trim();
+    if (!raw)
+        return DEFAULT_REPAIR_BUDGET;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0)
+        return DEFAULT_REPAIR_BUDGET;
+    return n;
+}
+/**
+ * Whether another capped regenerate/repair offer is allowed for this packet.
+ * Offers while `attemptCount` is strictly below `budget` (0-based attempts consumed).
+ */
+export function shouldOfferRepair(verdict, attemptCount, budget) {
+    if (verdict !== "BLOCKED")
+        return false;
+    const cap = parseRepairBudget(budget);
+    if (cap === 0)
+        return false;
+    return attemptCount < cap;
+}
+/**
+ * Cap a list of repair hint strings for display (capped regenerate algorithm).
+ */
+export function capRepairHints(hints, budget) {
+    const cap = parseRepairBudget(budget);
+    if (cap === 0 || hints.length === 0)
+        return [];
+    return hints.slice(0, cap);
+}
+//# sourceMappingURL=repair-budget.js.map

package/dist/repair-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-budget.js","sourceRoot":"","sources":["../src/repair-budget.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEhC;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAiB,EAAU;IAC5D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC;YAAE,OAAO,qBAAqB,CAAC;QAC7E,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,IAAI,EAAE,CAAC;IACvD,IAAI,CAAC,GAAG;QAAE,OAAO,qBAAqB,CAAC;IACvC,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IACnC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,qBAAqB,CAAC;IAC/D,OAAO,CAAC,CAAC;AAAA,CACT;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAoB,EAAE,YAAoB,EAAE,MAAc,EAAW;IACtG,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACxC,MAAM,GAAG,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,GAAG,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5B,OAAO,YAAY,GAAG,GAAG,CAAC;AAAA,CAC1B;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,KAAe,EAAE,MAAc,EAAY;IACzE,MAAM,GAAG,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC/C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAAA,CAC3B","sourcesContent":["/**\n * Capped regenerate repair budget (attempt counting vs env/config budget).\n */\n\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\n\nexport interface RepairBudgetState {\n\tpacketKey: string;\n\tattempts: number;\n\tlastVerdict: UserVerdict;\n}\n\nconst DEFAULT_REPAIR_BUDGET = 1;\n\n/**\n * Parse a non-negative repair budget cap. Uses `override` when provided; otherwise reads\n * `OMK_WALL_REPAIR_BUDGET` from the environment (invalid/missing → default 1).\n */\nexport function parseRepairBudget(override?: number): number {\n\tif (override !== undefined) {\n\t\tif (!Number.isFinite(override) || override < 0) return DEFAULT_REPAIR_BUDGET;\n\t\treturn Math.floor(override);\n\t}\n\tconst raw = process.env.OMK_WALL_REPAIR_BUDGET?.trim();\n\tif (!raw) return DEFAULT_REPAIR_BUDGET;\n\tconst n = Number.parseInt(raw, 10);\n\tif (!Number.isFinite(n) || n < 0) return DEFAULT_REPAIR_BUDGET;\n\treturn n;\n}\n\n/**\n * Whether another capped regenerate/repair offer is allowed for this packet.\n * Offers while `attemptCount` is strictly below `budget` (0-based attempts consumed).\n */\nexport function shouldOfferRepair(verdict: UserVerdict, attemptCount: number, budget: number): boolean {\n\tif (verdict !== \"BLOCKED\") return false;\n\tconst cap = parseRepairBudget(budget);\n\tif (cap === 0) return false;\n\treturn attemptCount < cap;\n}\n\n/**\n * Cap a list of repair hint strings for display (capped regenerate algorithm).\n */\nexport function capRepairHints(hints: string[], budget: number): string[] {\n\tconst cap = parseRepairBudget(budget);\n\tif (cap === 0 || hints.length === 0) return [];\n\treturn hints.slice(0, cap);\n}\n"]}

package/dist/repair-loop.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derive user-facing repair hints from wall verdict inputs (batch-1, no runner execution).
+ */
+import type { AdjudicationReasonCode } from "./adjudicator-registry.ts";
+import type { UserVerdict } from "./b2c-verdict.ts";
+import type { PolicyFlag } from "./policy-wall.ts";
+export interface RepairHintInput {
+    userVerdict: UserVerdict;
+    policyFlags: PolicyFlag[];
+    adjudicationReasonCode?: AdjudicationReasonCode;
+    previewOnly: boolean;
+    diffPaths: string[];
+}
+/**
+ * Produce ordered, de-duplicated repair hints for the verdict card.
+ */
+export declare function deriveRepairHints(input: RepairHintInput): string[];
+//# sourceMappingURL=repair-loop.d.ts.map

package/dist/repair-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-loop.d.ts","sourceRoot":"","sources":["../src/repair-loop.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;CACpB;AAeD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,EAAE,CAqClE","sourcesContent":["/**\n * Derive user-facing repair hints from wall verdict inputs (batch-1, no runner execution).\n */\n\nimport type { AdjudicationReasonCode } from \"./adjudicator-registry.ts\";\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\nimport type { PolicyFlag } from \"./policy-wall.ts\";\nimport { POLICY_FLAG } from \"./policy-wall.ts\";\n\nexport interface RepairHintInput {\n\tuserVerdict: UserVerdict;\n\tpolicyFlags: PolicyFlag[];\n\tadjudicationReasonCode?: AdjudicationReasonCode;\n\tpreviewOnly: boolean;\n\tdiffPaths: string[];\n}\n\nconst REASON_REPAIR: Partial<Record<AdjudicationReasonCode, string>> = {\n\tSCOPE_VIOLATION: \"Narrow the change to approved write paths only, then re-run the wall.\",\n\tSCHEMA_DRIFT: \"Align outputs with the expected schema contract before resubmitting.\",\n\tCONTENT_CHECK_FAILED: \"Fix failing content checks on artifacts, then re-adjudicate.\",\n\tNO_EVIDENCE_ON_SUCCESS: \"Attach terminal run evidence before claiming success.\",\n\tEMPTY_ARTIFACT_CONTENT: \"Ensure artifacts contain substantive content, not placeholders.\",\n\tTRACE_CHECK_FAILED: \"Resolve trace verification failures on the reported run.\",\n\tTRACE_ERROR_SPAN: \"Clear error spans under a success status or mark the run failed.\",\n\tMIN_ACTIONS_UNMET: \"Record the minimum required actions for this kind.\",\n\tRUN_FETCH_FAILED: \"Retry fetching run evidence when the runner is available.\",\n\tEVIDENCE_EMPTY: \"Widen verification scope or wait for terminal run artifacts.\",\n};\n\n/**\n * Produce ordered, de-duplicated repair hints for the verdict card.\n */\nexport function deriveRepairHints(input: RepairHintInput): string[] {\n\tconst hints: string[] = [];\n\n\tif (input.policyFlags.includes(POLICY_FLAG.CANDIDATE_LEAK_SUSPECT)) {\n\t\thints.push(\"Remove or relocate paths outside the approved write scope.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.SECRET_SUSPECT)) {\n\t\thints.push(\"Remove secret-like material from the diff; never commit credentials or private keys.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.NON_NEGOTIABLE_BLOCKING)) {\n\t\thints.push(\"Resolve non-negotiable policy blocks before apply or submit.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.EVIDENCE_DAG_INCOMPLETE)) {\n\t\thints.push(\"Complete the evidence DAG with terminal run ids (non-preview evaluation).\");\n\t}\n\tif (input.previewOnly && input.policyFlags.includes(POLICY_FLAG.LOW_DISCRIMINATION)) {\n\t\thints.push(\"Run a non-preview Deep Check with runner evidence for higher discrimination.\");\n\t}\n\n\tif (input.adjudicationReasonCode !== undefined) {\n\t\tconst fromReason = REASON_REPAIR[input.adjudicationReasonCode];\n\t\tif (fromReason !== undefined) {\n\t\t\thints.push(fromReason);\n\t\t}\n\t}\n\n\tif (input.userVerdict === \"INCONCLUSIVE\" && input.diffPaths.length === 0) {\n\t\thints.push(\"Provide a non-empty diff or explicit changed paths.\");\n\t}\n\tif (input.userVerdict === \"BLOCKED\" && hints.length === 0) {\n\t\thints.push(\"Regenerate the change set after addressing blocked reasons.\");\n\t}\n\tif (input.userVerdict === \"ADVISORY\") {\n\t\thints.push(\"Review advisory signals before applying in production.\");\n\t}\n\n\treturn [...new Set(hints)];\n}\n"]}

package/dist/repair-loop.js

@@ -0,0 +1,54 @@
+/**
+ * Derive user-facing repair hints from wall verdict inputs (batch-1, no runner execution).
+ */
+import { POLICY_FLAG } from "./policy-wall.js";
+const REASON_REPAIR = {
+    SCOPE_VIOLATION: "Narrow the change to approved write paths only, then re-run the wall.",
+    SCHEMA_DRIFT: "Align outputs with the expected schema contract before resubmitting.",
+    CONTENT_CHECK_FAILED: "Fix failing content checks on artifacts, then re-adjudicate.",
+    NO_EVIDENCE_ON_SUCCESS: "Attach terminal run evidence before claiming success.",
+    EMPTY_ARTIFACT_CONTENT: "Ensure artifacts contain substantive content, not placeholders.",
+    TRACE_CHECK_FAILED: "Resolve trace verification failures on the reported run.",
+    TRACE_ERROR_SPAN: "Clear error spans under a success status or mark the run failed.",
+    MIN_ACTIONS_UNMET: "Record the minimum required actions for this kind.",
+    RUN_FETCH_FAILED: "Retry fetching run evidence when the runner is available.",
+    EVIDENCE_EMPTY: "Widen verification scope or wait for terminal run artifacts.",
+};
+/**
+ * Produce ordered, de-duplicated repair hints for the verdict card.
+ */
+export function deriveRepairHints(input) {
+    const hints = [];
+    if (input.policyFlags.includes(POLICY_FLAG.CANDIDATE_LEAK_SUSPECT)) {
+        hints.push("Remove or relocate paths outside the approved write scope.");
+    }
+    if (input.policyFlags.includes(POLICY_FLAG.SECRET_SUSPECT)) {
+        hints.push("Remove secret-like material from the diff; never commit credentials or private keys.");
+    }
+    if (input.policyFlags.includes(POLICY_FLAG.NON_NEGOTIABLE_BLOCKING)) {
+        hints.push("Resolve non-negotiable policy blocks before apply or submit.");
+    }
+    if (input.policyFlags.includes(POLICY_FLAG.EVIDENCE_DAG_INCOMPLETE)) {
+        hints.push("Complete the evidence DAG with terminal run ids (non-preview evaluation).");
+    }
+    if (input.previewOnly && input.policyFlags.includes(POLICY_FLAG.LOW_DISCRIMINATION)) {
+        hints.push("Run a non-preview Deep Check with runner evidence for higher discrimination.");
+    }
+    if (input.adjudicationReasonCode !== undefined) {
+        const fromReason = REASON_REPAIR[input.adjudicationReasonCode];
+        if (fromReason !== undefined) {
+            hints.push(fromReason);
+        }
+    }
+    if (input.userVerdict === "INCONCLUSIVE" && input.diffPaths.length === 0) {
+        hints.push("Provide a non-empty diff or explicit changed paths.");
+    }
+    if (input.userVerdict === "BLOCKED" && hints.length === 0) {
+        hints.push("Regenerate the change set after addressing blocked reasons.");
+    }
+    if (input.userVerdict === "ADVISORY") {
+        hints.push("Review advisory signals before applying in production.");
+    }
+    return [...new Set(hints)];
+}
+//# sourceMappingURL=repair-loop.js.map

package/dist/repair-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-loop.js","sourceRoot":"","sources":["../src/repair-loop.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAU/C,MAAM,aAAa,GAAoD;IACtE,eAAe,EAAE,uEAAuE;IACxF,YAAY,EAAE,sEAAsE;IACpF,oBAAoB,EAAE,8DAA8D;IACpF,sBAAsB,EAAE,uDAAuD;IAC/E,sBAAsB,EAAE,iEAAiE;IACzF,kBAAkB,EAAE,0DAA0D;IAC9E,gBAAgB,EAAE,kEAAkE;IACpF,iBAAiB,EAAE,oDAAoD;IACvE,gBAAgB,EAAE,2DAA2D;IAC7E,cAAc,EAAE,8DAA8D;CAC9E,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAsB,EAAY;IACnE,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,IAAI,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,sBAAsB,CAAC,EAAE,CAAC;QACpE,KAAK,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;QAC5D,KAAK,CAAC,IAAI,CAAC,sFAAsF,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAAE,CAAC;QACrE,KAAK,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAAE,CAAC;QACrE,KAAK,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;IACzF,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACrF,KAAK,CAAC,IAAI,CAAC,8EAA8E,CAAC,CAAC;IAC5F,CAAC;IAED,IAAI,KAAK,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;QAChD,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC/D,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC9B,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACxB,CAAC;IACF,CAAC;IAED,IAAI,KAAK,CAAC,WAAW,KAAK,cAAc,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1E,KAAK,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;IACnE,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3D,KAAK,CAAC,IAAI,CAAC,6DAA6D,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,KAAK,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QACtC,KAAK,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AAAA,CAC3B","sourcesContent":["/**\n * Derive user-facing repair hints from wall verdict inputs (batch-1, no runner execution).\n */\n\nimport type { AdjudicationReasonCode } from \"./adjudicator-registry.ts\";\nimport type { UserVerdict } from \"./b2c-verdict.ts\";\nimport type { PolicyFlag } from \"./policy-wall.ts\";\nimport { POLICY_FLAG } from \"./policy-wall.ts\";\n\nexport interface RepairHintInput {\n\tuserVerdict: UserVerdict;\n\tpolicyFlags: PolicyFlag[];\n\tadjudicationReasonCode?: AdjudicationReasonCode;\n\tpreviewOnly: boolean;\n\tdiffPaths: string[];\n}\n\nconst REASON_REPAIR: Partial<Record<AdjudicationReasonCode, string>> = {\n\tSCOPE_VIOLATION: \"Narrow the change to approved write paths only, then re-run the wall.\",\n\tSCHEMA_DRIFT: \"Align outputs with the expected schema contract before resubmitting.\",\n\tCONTENT_CHECK_FAILED: \"Fix failing content checks on artifacts, then re-adjudicate.\",\n\tNO_EVIDENCE_ON_SUCCESS: \"Attach terminal run evidence before claiming success.\",\n\tEMPTY_ARTIFACT_CONTENT: \"Ensure artifacts contain substantive content, not placeholders.\",\n\tTRACE_CHECK_FAILED: \"Resolve trace verification failures on the reported run.\",\n\tTRACE_ERROR_SPAN: \"Clear error spans under a success status or mark the run failed.\",\n\tMIN_ACTIONS_UNMET: \"Record the minimum required actions for this kind.\",\n\tRUN_FETCH_FAILED: \"Retry fetching run evidence when the runner is available.\",\n\tEVIDENCE_EMPTY: \"Widen verification scope or wait for terminal run artifacts.\",\n};\n\n/**\n * Produce ordered, de-duplicated repair hints for the verdict card.\n */\nexport function deriveRepairHints(input: RepairHintInput): string[] {\n\tconst hints: string[] = [];\n\n\tif (input.policyFlags.includes(POLICY_FLAG.CANDIDATE_LEAK_SUSPECT)) {\n\t\thints.push(\"Remove or relocate paths outside the approved write scope.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.SECRET_SUSPECT)) {\n\t\thints.push(\"Remove secret-like material from the diff; never commit credentials or private keys.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.NON_NEGOTIABLE_BLOCKING)) {\n\t\thints.push(\"Resolve non-negotiable policy blocks before apply or submit.\");\n\t}\n\tif (input.policyFlags.includes(POLICY_FLAG.EVIDENCE_DAG_INCOMPLETE)) {\n\t\thints.push(\"Complete the evidence DAG with terminal run ids (non-preview evaluation).\");\n\t}\n\tif (input.previewOnly && input.policyFlags.includes(POLICY_FLAG.LOW_DISCRIMINATION)) {\n\t\thints.push(\"Run a non-preview Deep Check with runner evidence for higher discrimination.\");\n\t}\n\n\tif (input.adjudicationReasonCode !== undefined) {\n\t\tconst fromReason = REASON_REPAIR[input.adjudicationReasonCode];\n\t\tif (fromReason !== undefined) {\n\t\t\thints.push(fromReason);\n\t\t}\n\t}\n\n\tif (input.userVerdict === \"INCONCLUSIVE\" && input.diffPaths.length === 0) {\n\t\thints.push(\"Provide a non-empty diff or explicit changed paths.\");\n\t}\n\tif (input.userVerdict === \"BLOCKED\" && hints.length === 0) {\n\t\thints.push(\"Regenerate the change set after addressing blocked reasons.\");\n\t}\n\tif (input.userVerdict === \"ADVISORY\") {\n\t\thints.push(\"Review advisory signals before applying in production.\");\n\t}\n\n\treturn [...new Set(hints)];\n}\n"]}

package/dist/retry-backoff.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Deterministic jitter retry backoff (W1).
+ *
+ * Produces a per-packet, per-attempt delay that is:
+ *   - deterministic given (packet_id, retry_count): same inputs ⇒ same ms across
+ *     processes and machines (no Math.random, no wall-clock dependence),
+ *   - exponentially growing with retry_count, with the exponential BASE capped at `max`,
+ *   - spread by a per-packet jitter factor derived from an FNV-1a hash of the packet id,
+ *     so two packets retrying on the same schedule don't thunder-herd.
+ *
+ * FNV-1a 32-bit is implemented in-file (not imported across packages) so this module
+ * stays zero-dependency and the determinism contract is fully localized here.
+ */
+/** Configuration for {@link backoffDelayMs}. All fields optional; see field defaults. */
+export interface BackoffConfig {
+    /**
+     * Base delay in ms for retry_count 0 (the seed of the exponential). Default 2000.
+     * If greater than {@link BackoffConfig.max}, it is clamped down to `max`.
+     */
+    initial?: number;
+    /** Upper bound in ms applied to the exponential base. Default 120000. */
+    max?: number;
+}
+/**
+ * FNV-1a 32-bit hash over the UTF-16 code units of `s`. Returns an unsigned 32-bit integer
+ * in [0, 2^32). Iterates per UTF-16 code unit (String.prototype.charCodeAt), matching the
+ * spec contract exactly.
+ */
+export declare function fnv1a32(s: string): number;
+/**
+ * Deterministic exponential backoff with per-packet jitter.
+ *
+ * Formula (authoritative — the test's hard-coded vectors are generated from this exact
+ * expression by an independent reference script):
+ *   n       = retryCount clamped to >= 0 (negative / NaN treated as 0)
+ *   initial = cfg.initial ?? 2000;  if initial > max → initial = max
+ *   max     = cfg.max ?? 120000
+ *   base    = min(max, initial * 2**n)        // CAP APPLIES TO BASE, not to the result
+ *   h       = fnv1a32(packetId)               // unsigned 32-bit
+ *   jitter  = 0.5 + h / 2**32                 // ∈ [0.5, 1.5)
+ *   return  = round(base * jitter)
+ *
+ * Range note: the literal expression `0.5 + h / 2**32` yields a jitter factor in [0.5, 1.5)
+ * because h ∈ [0, 2**32). This is implemented exactly as specified; the returned delay may
+ * therefore exceed `max` by up to ~50%. The spec comment "// range [0.5, 1.0)" is
+ * inconsistent with the literal formula; the formula and its externally-generated vectors
+ * are authoritative per the W1 task. See the W1 evidence note for details.
+ */
+export declare function backoffDelayMs(packetId: string, retryCount: number, cfg?: BackoffConfig): number;
+/**
+ * Computes the ISO-8601 "not-before" timestamp by adding `delayMs` milliseconds to `nowIso`.
+ * If `nowIso` is not a parseable date, falls back to `Date.now()` so a corrupt stored
+ * timestamp can never freeze a packet permanently.
+ */
+export declare function retryNotBefore(nowIso: string, delayMs: number): string;
+//# sourceMappingURL=retry-backoff.d.ts.map

package/dist/retry-backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-backoff.d.ts","sourceRoot":"","sources":["../src/retry-backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAMD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzC;AAKD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,MAAM,CAchG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAItE","sourcesContent":["/**\n * Deterministic jitter retry backoff (W1).\n *\n * Produces a per-packet, per-attempt delay that is:\n *   - deterministic given (packet_id, retry_count): same inputs ⇒ same ms across\n *     processes and machines (no Math.random, no wall-clock dependence),\n *   - exponentially growing with retry_count, with the exponential BASE capped at `max`,\n *   - spread by a per-packet jitter factor derived from an FNV-1a hash of the packet id,\n *     so two packets retrying on the same schedule don't thunder-herd.\n *\n * FNV-1a 32-bit is implemented in-file (not imported across packages) so this module\n * stays zero-dependency and the determinism contract is fully localized here.\n */\n\n/** Configuration for {@link backoffDelayMs}. All fields optional; see field defaults. */\nexport interface BackoffConfig {\n\t/**\n\t * Base delay in ms for retry_count 0 (the seed of the exponential). Default 2000.\n\t * If greater than {@link BackoffConfig.max}, it is clamped down to `max`.\n\t */\n\tinitial?: number;\n\t/** Upper bound in ms applied to the exponential base. Default 120000. */\n\tmax?: number;\n}\n\nconst FNV1A_OFFSET_BASIS = 0x811c9dc5;\nconst FNV1A_PRIME = 0x01000193;\nconst UINT32_MOD = 4294967296; // 2^32\n\n/**\n * FNV-1a 32-bit hash over the UTF-16 code units of `s`. Returns an unsigned 32-bit integer\n * in [0, 2^32). Iterates per UTF-16 code unit (String.prototype.charCodeAt), matching the\n * spec contract exactly.\n */\nexport function fnv1a32(s: string): number {\n\tlet hash = FNV1A_OFFSET_BASIS >>> 0;\n\tfor (let i = 0; i < s.length; i++) {\n\t\thash = Math.imul((hash ^ s.charCodeAt(i)) >>> 0, FNV1A_PRIME) >>> 0;\n\t}\n\treturn hash >>> 0;\n}\n\nconst DEFAULT_INITIAL_MS = 2000;\nconst DEFAULT_MAX_MS = 120000;\n\n/**\n * Deterministic exponential backoff with per-packet jitter.\n *\n * Formula (authoritative — the test's hard-coded vectors are generated from this exact\n * expression by an independent reference script):\n *   n       = retryCount clamped to >= 0 (negative / NaN treated as 0)\n *   initial = cfg.initial ?? 2000;  if initial > max → initial = max\n *   max     = cfg.max ?? 120000\n *   base    = min(max, initial * 2**n)        // CAP APPLIES TO BASE, not to the result\n *   h       = fnv1a32(packetId)               // unsigned 32-bit\n *   jitter  = 0.5 + h / 2**32                 // ∈ [0.5, 1.5)\n *   return  = round(base * jitter)\n *\n * Range note: the literal expression `0.5 + h / 2**32` yields a jitter factor in [0.5, 1.5)\n * because h ∈ [0, 2**32). This is implemented exactly as specified; the returned delay may\n * therefore exceed `max` by up to ~50%. The spec comment \"// range [0.5, 1.0)\" is\n * inconsistent with the literal formula; the formula and its externally-generated vectors\n * are authoritative per the W1 task. See the W1 evidence note for details.\n */\nexport function backoffDelayMs(packetId: string, retryCount: number, cfg?: BackoffConfig): number {\n\tlet n = retryCount;\n\tif (n < 0 || Number.isNaN(n)) {\n\t\tn = 0;\n\t}\n\tlet initial = cfg?.initial ?? DEFAULT_INITIAL_MS;\n\tconst max = cfg?.max ?? DEFAULT_MAX_MS;\n\tif (initial > max) {\n\t\tinitial = max;\n\t}\n\tconst base = Math.min(max, initial * 2 ** n);\n\tconst h = fnv1a32(packetId);\n\tconst jitter = 0.5 + h / UINT32_MOD;\n\treturn Math.round(base * jitter);\n}\n\n/**\n * Computes the ISO-8601 \"not-before\" timestamp by adding `delayMs` milliseconds to `nowIso`.\n * If `nowIso` is not a parseable date, falls back to `Date.now()` so a corrupt stored\n * timestamp can never freeze a packet permanently.\n */\nexport function retryNotBefore(nowIso: string, delayMs: number): string {\n\tconst parsed = Date.parse(nowIso);\n\tconst t = Number.isNaN(parsed) ? Date.now() : parsed;\n\treturn new Date(t + delayMs).toISOString();\n}\n"]}

package/dist/retry-backoff.js

@@ -0,0 +1,75 @@
+/**
+ * Deterministic jitter retry backoff (W1).
+ *
+ * Produces a per-packet, per-attempt delay that is:
+ *   - deterministic given (packet_id, retry_count): same inputs ⇒ same ms across
+ *     processes and machines (no Math.random, no wall-clock dependence),
+ *   - exponentially growing with retry_count, with the exponential BASE capped at `max`,
+ *   - spread by a per-packet jitter factor derived from an FNV-1a hash of the packet id,
+ *     so two packets retrying on the same schedule don't thunder-herd.
+ *
+ * FNV-1a 32-bit is implemented in-file (not imported across packages) so this module
+ * stays zero-dependency and the determinism contract is fully localized here.
+ */
+const FNV1A_OFFSET_BASIS = 0x811c9dc5;
+const FNV1A_PRIME = 0x01000193;
+const UINT32_MOD = 4294967296; // 2^32
+/**
+ * FNV-1a 32-bit hash over the UTF-16 code units of `s`. Returns an unsigned 32-bit integer
+ * in [0, 2^32). Iterates per UTF-16 code unit (String.prototype.charCodeAt), matching the
+ * spec contract exactly.
+ */
+export function fnv1a32(s) {
+    let hash = FNV1A_OFFSET_BASIS >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        hash = Math.imul((hash ^ s.charCodeAt(i)) >>> 0, FNV1A_PRIME) >>> 0;
+    }
+    return hash >>> 0;
+}
+const DEFAULT_INITIAL_MS = 2000;
+const DEFAULT_MAX_MS = 120000;
+/**
+ * Deterministic exponential backoff with per-packet jitter.
+ *
+ * Formula (authoritative — the test's hard-coded vectors are generated from this exact
+ * expression by an independent reference script):
+ *   n       = retryCount clamped to >= 0 (negative / NaN treated as 0)
+ *   initial = cfg.initial ?? 2000;  if initial > max → initial = max
+ *   max     = cfg.max ?? 120000
+ *   base    = min(max, initial * 2**n)        // CAP APPLIES TO BASE, not to the result
+ *   h       = fnv1a32(packetId)               // unsigned 32-bit
+ *   jitter  = 0.5 + h / 2**32                 // ∈ [0.5, 1.5)
+ *   return  = round(base * jitter)
+ *
+ * Range note: the literal expression `0.5 + h / 2**32` yields a jitter factor in [0.5, 1.5)
+ * because h ∈ [0, 2**32). This is implemented exactly as specified; the returned delay may
+ * therefore exceed `max` by up to ~50%. The spec comment "// range [0.5, 1.0)" is
+ * inconsistent with the literal formula; the formula and its externally-generated vectors
+ * are authoritative per the W1 task. See the W1 evidence note for details.
+ */
+export function backoffDelayMs(packetId, retryCount, cfg) {
+    let n = retryCount;
+    if (n < 0 || Number.isNaN(n)) {
+        n = 0;
+    }
+    let initial = cfg?.initial ?? DEFAULT_INITIAL_MS;
+    const max = cfg?.max ?? DEFAULT_MAX_MS;
+    if (initial > max) {
+        initial = max;
+    }
+    const base = Math.min(max, initial * 2 ** n);
+    const h = fnv1a32(packetId);
+    const jitter = 0.5 + h / UINT32_MOD;
+    return Math.round(base * jitter);
+}
+/**
+ * Computes the ISO-8601 "not-before" timestamp by adding `delayMs` milliseconds to `nowIso`.
+ * If `nowIso` is not a parseable date, falls back to `Date.now()` so a corrupt stored
+ * timestamp can never freeze a packet permanently.
+ */
+export function retryNotBefore(nowIso, delayMs) {
+    const parsed = Date.parse(nowIso);
+    const t = Number.isNaN(parsed) ? Date.now() : parsed;
+    return new Date(t + delayMs).toISOString();
+}
+//# sourceMappingURL=retry-backoff.js.map

package/dist/retry-backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-backoff.js","sourceRoot":"","sources":["../src/retry-backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,MAAM,kBAAkB,GAAG,UAAU,CAAC;AACtC,MAAM,WAAW,GAAG,UAAU,CAAC;AAC/B,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,OAAO;AAEtC;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,CAAS,EAAU;IAC1C,IAAI,IAAI,GAAG,kBAAkB,KAAK,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,CAAC;AAAA,CAClB;AAED,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAChC,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,UAAkB,EAAE,GAAmB,EAAU;IACjG,IAAI,CAAC,GAAG,UAAU,CAAC;IACnB,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9B,CAAC,GAAG,CAAC,CAAC;IACP,CAAC;IACD,IAAI,OAAO,GAAG,GAAG,EAAE,OAAO,IAAI,kBAAkB,CAAC;IACjD,MAAM,GAAG,GAAG,GAAG,EAAE,GAAG,IAAI,cAAc,CAAC;IACvC,IAAI,OAAO,GAAG,GAAG,EAAE,CAAC;QACnB,OAAO,GAAG,GAAG,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5B,MAAM,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,UAAU,CAAC;IACpC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;AAAA,CACjC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,OAAe,EAAU;IACvE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IACrD,OAAO,IAAI,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;AAAA,CAC3C","sourcesContent":["/**\n * Deterministic jitter retry backoff (W1).\n *\n * Produces a per-packet, per-attempt delay that is:\n *   - deterministic given (packet_id, retry_count): same inputs ⇒ same ms across\n *     processes and machines (no Math.random, no wall-clock dependence),\n *   - exponentially growing with retry_count, with the exponential BASE capped at `max`,\n *   - spread by a per-packet jitter factor derived from an FNV-1a hash of the packet id,\n *     so two packets retrying on the same schedule don't thunder-herd.\n *\n * FNV-1a 32-bit is implemented in-file (not imported across packages) so this module\n * stays zero-dependency and the determinism contract is fully localized here.\n */\n\n/** Configuration for {@link backoffDelayMs}. All fields optional; see field defaults. */\nexport interface BackoffConfig {\n\t/**\n\t * Base delay in ms for retry_count 0 (the seed of the exponential). Default 2000.\n\t * If greater than {@link BackoffConfig.max}, it is clamped down to `max`.\n\t */\n\tinitial?: number;\n\t/** Upper bound in ms applied to the exponential base. Default 120000. */\n\tmax?: number;\n}\n\nconst FNV1A_OFFSET_BASIS = 0x811c9dc5;\nconst FNV1A_PRIME = 0x01000193;\nconst UINT32_MOD = 4294967296; // 2^32\n\n/**\n * FNV-1a 32-bit hash over the UTF-16 code units of `s`. Returns an unsigned 32-bit integer\n * in [0, 2^32). Iterates per UTF-16 code unit (String.prototype.charCodeAt), matching the\n * spec contract exactly.\n */\nexport function fnv1a32(s: string): number {\n\tlet hash = FNV1A_OFFSET_BASIS >>> 0;\n\tfor (let i = 0; i < s.length; i++) {\n\t\thash = Math.imul((hash ^ s.charCodeAt(i)) >>> 0, FNV1A_PRIME) >>> 0;\n\t}\n\treturn hash >>> 0;\n}\n\nconst DEFAULT_INITIAL_MS = 2000;\nconst DEFAULT_MAX_MS = 120000;\n\n/**\n * Deterministic exponential backoff with per-packet jitter.\n *\n * Formula (authoritative — the test's hard-coded vectors are generated from this exact\n * expression by an independent reference script):\n *   n       = retryCount clamped to >= 0 (negative / NaN treated as 0)\n *   initial = cfg.initial ?? 2000;  if initial > max → initial = max\n *   max     = cfg.max ?? 120000\n *   base    = min(max, initial * 2**n)        // CAP APPLIES TO BASE, not to the result\n *   h       = fnv1a32(packetId)               // unsigned 32-bit\n *   jitter  = 0.5 + h / 2**32                 // ∈ [0.5, 1.5)\n *   return  = round(base * jitter)\n *\n * Range note: the literal expression `0.5 + h / 2**32` yields a jitter factor in [0.5, 1.5)\n * because h ∈ [0, 2**32). This is implemented exactly as specified; the returned delay may\n * therefore exceed `max` by up to ~50%. The spec comment \"// range [0.5, 1.0)\" is\n * inconsistent with the literal formula; the formula and its externally-generated vectors\n * are authoritative per the W1 task. See the W1 evidence note for details.\n */\nexport function backoffDelayMs(packetId: string, retryCount: number, cfg?: BackoffConfig): number {\n\tlet n = retryCount;\n\tif (n < 0 || Number.isNaN(n)) {\n\t\tn = 0;\n\t}\n\tlet initial = cfg?.initial ?? DEFAULT_INITIAL_MS;\n\tconst max = cfg?.max ?? DEFAULT_MAX_MS;\n\tif (initial > max) {\n\t\tinitial = max;\n\t}\n\tconst base = Math.min(max, initial * 2 ** n);\n\tconst h = fnv1a32(packetId);\n\tconst jitter = 0.5 + h / UINT32_MOD;\n\treturn Math.round(base * jitter);\n}\n\n/**\n * Computes the ISO-8601 \"not-before\" timestamp by adding `delayMs` milliseconds to `nowIso`.\n * If `nowIso` is not a parseable date, falls back to `Date.now()` so a corrupt stored\n * timestamp can never freeze a packet permanently.\n */\nexport function retryNotBefore(nowIso: string, delayMs: number): string {\n\tconst parsed = Date.parse(nowIso);\n\tconst t = Number.isNaN(parsed) ? Date.now() : parsed;\n\treturn new Date(t + delayMs).toISOString();\n}\n"]}

package/dist/signed-receipt.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Verification digest for receipts — patch + evidence fingerprints without secret material.
+ */
+export interface VerificationDigestInput {
+    /** Unified diff or patch text (hashed, not echoed). */
+    patchText?: string;
+    /** Opaque evidence blobs (e.g. run artifact excerpts); only digests are retained. */
+    evidenceChunks?: string[];
+    /** Correctness wall policy batch id (included in composite hash when set). */
+    wallVersion?: string;
+}
+export interface VerificationDigest {
+    algorithm: "sha256-hex";
+    patchHash: string | null;
+    evidenceHashes: string[];
+    compositeHash: string;
+    /** Wall receipt batch id when supplied at digest build time. */
+    wallVersion?: string;
+}
+/** Wall-scoped receipt metadata paired with digest fingerprints. */
+export interface WallReceiptMeta {
+    wallVersion: string;
+    compositeHash: string;
+}
+/**
+ * Build a stable verification digest from patch and evidence. No secrets or raw payloads in output.
+ */
+export declare function buildVerificationDigest(input: VerificationDigestInput): VerificationDigest;
+//# sourceMappingURL=signed-receipt.d.ts.map

package/dist/signed-receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-receipt.d.ts","sourceRoot":"","sources":["../src/signed-receipt.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,uBAAuB;IACvC,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,YAAY,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACtB;AAMD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,uBAAuB,GAAG,kBAAkB,CAc1F","sourcesContent":["/**\n * Verification digest for receipts — patch + evidence fingerprints without secret material.\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport interface VerificationDigestInput {\n\t/** Unified diff or patch text (hashed, not echoed). */\n\tpatchText?: string;\n\t/** Opaque evidence blobs (e.g. run artifact excerpts); only digests are retained. */\n\tevidenceChunks?: string[];\n\t/** Correctness wall policy batch id (included in composite hash when set). */\n\twallVersion?: string;\n}\n\nexport interface VerificationDigest {\n\talgorithm: \"sha256-hex\";\n\tpatchHash: string | null;\n\tevidenceHashes: string[];\n\tcompositeHash: string;\n\t/** Wall receipt batch id when supplied at digest build time. */\n\twallVersion?: string;\n}\n\n/** Wall-scoped receipt metadata paired with digest fingerprints. */\nexport interface WallReceiptMeta {\n\twallVersion: string;\n\tcompositeHash: string;\n}\n\nfunction sha256Hex(text: string): string {\n\treturn createHash(\"sha256\").update(text, \"utf8\").digest(\"hex\");\n}\n\n/**\n * Build a stable verification digest from patch and evidence. No secrets or raw payloads in output.\n */\nexport function buildVerificationDigest(input: VerificationDigestInput): VerificationDigest {\n\tconst patchHash = input.patchText !== undefined && input.patchText.length > 0 ? sha256Hex(input.patchText) : null;\n\tconst evidenceHashes = (input.evidenceChunks ?? []).filter((c) => c.length > 0).map((c) => sha256Hex(c));\n\tconst wallVersion = input.wallVersion !== undefined && input.wallVersion.length > 0 ? input.wallVersion : undefined;\n\tconst compositeMaterial = [wallVersion ?? \"\", patchHash ?? \"\", ...evidenceHashes].join(\"|\");\n\tconst compositeHash = sha256Hex(compositeMaterial || \"empty\");\n\n\treturn {\n\t\talgorithm: \"sha256-hex\",\n\t\tpatchHash,\n\t\tevidenceHashes,\n\t\tcompositeHash,\n\t\t...(wallVersion !== undefined ? { wallVersion } : {}),\n\t};\n}\n"]}

package/dist/signed-receipt.js

@@ -0,0 +1,25 @@
+/**
+ * Verification digest for receipts — patch + evidence fingerprints without secret material.
+ */
+import { createHash } from "node:crypto";
+function sha256Hex(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+/**
+ * Build a stable verification digest from patch and evidence. No secrets or raw payloads in output.
+ */
+export function buildVerificationDigest(input) {
+    const patchHash = input.patchText !== undefined && input.patchText.length > 0 ? sha256Hex(input.patchText) : null;
+    const evidenceHashes = (input.evidenceChunks ?? []).filter((c) => c.length > 0).map((c) => sha256Hex(c));
+    const wallVersion = input.wallVersion !== undefined && input.wallVersion.length > 0 ? input.wallVersion : undefined;
+    const compositeMaterial = [wallVersion ?? "", patchHash ?? "", ...evidenceHashes].join("|");
+    const compositeHash = sha256Hex(compositeMaterial || "empty");
+    return {
+        algorithm: "sha256-hex",
+        patchHash,
+        evidenceHashes,
+        compositeHash,
+        ...(wallVersion !== undefined ? { wallVersion } : {}),
+    };
+}
+//# sourceMappingURL=signed-receipt.js.map

package/dist/signed-receipt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-receipt.js","sourceRoot":"","sources":["../src/signed-receipt.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0BzC,SAAS,SAAS,CAAC,IAAY,EAAU;IACxC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAAA,CAC/D;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAA8B,EAAsB;IAC3F,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAClH,MAAM,cAAc,GAAG,CAAC,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IACzG,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACpH,MAAM,iBAAiB,GAAG,CAAC,WAAW,IAAI,EAAE,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5F,MAAM,aAAa,GAAG,SAAS,CAAC,iBAAiB,IAAI,OAAO,CAAC,CAAC;IAE9D,OAAO;QACN,SAAS,EAAE,YAAY;QACvB,SAAS;QACT,cAAc;QACd,aAAa;QACb,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACrD,CAAC;AAAA,CACF","sourcesContent":["/**\n * Verification digest for receipts — patch + evidence fingerprints without secret material.\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport interface VerificationDigestInput {\n\t/** Unified diff or patch text (hashed, not echoed). */\n\tpatchText?: string;\n\t/** Opaque evidence blobs (e.g. run artifact excerpts); only digests are retained. */\n\tevidenceChunks?: string[];\n\t/** Correctness wall policy batch id (included in composite hash when set). */\n\twallVersion?: string;\n}\n\nexport interface VerificationDigest {\n\talgorithm: \"sha256-hex\";\n\tpatchHash: string | null;\n\tevidenceHashes: string[];\n\tcompositeHash: string;\n\t/** Wall receipt batch id when supplied at digest build time. */\n\twallVersion?: string;\n}\n\n/** Wall-scoped receipt metadata paired with digest fingerprints. */\nexport interface WallReceiptMeta {\n\twallVersion: string;\n\tcompositeHash: string;\n}\n\nfunction sha256Hex(text: string): string {\n\treturn createHash(\"sha256\").update(text, \"utf8\").digest(\"hex\");\n}\n\n/**\n * Build a stable verification digest from patch and evidence. No secrets or raw payloads in output.\n */\nexport function buildVerificationDigest(input: VerificationDigestInput): VerificationDigest {\n\tconst patchHash = input.patchText !== undefined && input.patchText.length > 0 ? sha256Hex(input.patchText) : null;\n\tconst evidenceHashes = (input.evidenceChunks ?? []).filter((c) => c.length > 0).map((c) => sha256Hex(c));\n\tconst wallVersion = input.wallVersion !== undefined && input.wallVersion.length > 0 ? input.wallVersion : undefined;\n\tconst compositeMaterial = [wallVersion ?? \"\", patchHash ?? \"\", ...evidenceHashes].join(\"|\");\n\tconst compositeHash = sha256Hex(compositeMaterial || \"empty\");\n\n\treturn {\n\t\talgorithm: \"sha256-hex\",\n\t\tpatchHash,\n\t\tevidenceHashes,\n\t\tcompositeHash,\n\t\t...(wallVersion !== undefined ? { wallVersion } : {}),\n\t};\n}\n"]}

package/dist/state-machine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Design-fidelity note: this file implements the packet-level state machine defined in
+ * Part 1 (`final-part1-core-algorithm.md`), Section 2 (transition table), Section 4 (terminal
+ * state, since only CLOSED is terminal per §2's own text), and Section 2 state 3
+ * (AWAITING_APPROVAL's trigger condition). It is an implementation of that document, not a
+ * restatement of it.
+ */
+import type { LoopConfig, TopologyClassification, WorkPacket, WorkPacketState } from "./types.ts";
+/**
+ * Part 1 §2 — returns whether `from -> to` is a legal Work Packet state transition, per the
+ * transition table. Pure and side-effect free.
+ */
+export declare function canTransition(from: WorkPacketState, to: WorkPacketState): boolean;
+/**
+ * Part 1 §2 / §7 — applies a state transition to a Work Packet, returning a new packet object
+ * with `state` updated and a new `TransitionLogEntry` appended to `transition_log`. Throws if
+ * the transition is not legal per `canTransition`. Does not mutate `packet`.
+ *
+ * `now` defaults to the wall-clock ISO timestamp but is accepted as a parameter so callers
+ * (and tests) can supply a deterministic clock.
+ */
+export declare function applyTransition(packet: WorkPacket, to: WorkPacketState, cause: string, now?: () => string): WorkPacket;
+/**
+ * Part 1 §2 state 14 / §4 "Completion exhaustion" — CLOSED is the only terminal state.
+ * ESCALATED and RETRY_QUEUED are explicitly not terminal: both can still transition further
+ * (ESCALATED via an explicit external unblock signal; RETRY_QUEUED back into ROUTED).
+ */
+export declare function isTerminalState(state: WorkPacketState): boolean;
+/**
+ * Part 1 §2 state 3 — whether the next attempt for `packet` must be held in
+ * AWAITING_APPROVAL before its first `adaptorch_run` call, rather than going straight from
+ * ROUTED to DISPATCHED.
+ *
+ * True only if the proposed payload differs from the packet's last-human-approved baseline,
+ * or the proposed topology classification differs from the packet's currently stored topology
+ * decision — unless the loop instance is running in pre-approved-batch mode (§2 state 3's
+ * documented opt-in escape hatch), in which case this always returns false.
+ */
+export declare function requiresHumanApproval(packet: WorkPacket, newPayload: unknown, newTopology: TopologyClassification | null, loopConfig: LoopConfig): boolean;
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../src/state-machine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAwBlG;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,GAAG,OAAO,CAEjF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,MAAM,MAAuC,GAChD,UAAU,CAYZ;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,OAAO,EACnB,WAAW,EAAE,sBAAsB,GAAG,IAAI,EAC1C,UAAU,EAAE,UAAU,GACpB,OAAO,CAkBT","sourcesContent":["/**\n * Design-fidelity note: this file implements the packet-level state machine defined in\n * Part 1 (`final-part1-core-algorithm.md`), Section 2 (transition table), Section 4 (terminal\n * state, since only CLOSED is terminal per §2's own text), and Section 2 state 3\n * (AWAITING_APPROVAL's trigger condition). It is an implementation of that document, not a\n * restatement of it.\n */\n\nimport type { LoopConfig, TopologyClassification, WorkPacket, WorkPacketState } from \"./types.ts\";\n\n/**\n * Part 1 §2 — the full transition table, as an adjacency map keyed by source state. This is\n * the single source of truth for which transitions are legal; every other state-machine\n * function in this file is built on top of `canTransition`.\n */\nconst TRANSITIONS: Record<WorkPacketState, WorkPacketState[]> = {\n\tDRAFTED: [\"ROUTED\"],\n\tROUTED: [\"AWAITING_APPROVAL\", \"DISPATCHED\"],\n\tAWAITING_APPROVAL: [\"DISPATCHED\", \"CLOSED\"],\n\tDISPATCHED: [\"ACTIVE\", \"RAW_TERMINAL\", \"CLOSED\"],\n\tACTIVE: [\"RAW_TERMINAL\", \"HALTING\", \"CLOSED\"],\n\tHALTING: [\"RAW_TERMINAL\", \"CLOSED\"],\n\tRAW_TERMINAL: [\"UNDER_REVIEW\", \"ADJUDICATION_FAILED\"],\n\tUNDER_REVIEW: [\"ADJUDICATION_FAILED\", \"CONFIRMED\", \"DECLINED\"],\n\tADJUDICATION_FAILED: [\"UNDER_REVIEW\", \"ESCALATED\"],\n\tCONFIRMED: [\"CLOSED\"],\n\tDECLINED: [\"ESCALATED\", \"RETRY_QUEUED\", \"CLOSED\"],\n\tRETRY_QUEUED: [\"ROUTED\"],\n\tESCALATED: [\"RETRY_QUEUED\", \"CLOSED\"],\n\tCLOSED: [],\n};\n\n/**\n * Part 1 §2 — returns whether `from -> to` is a legal Work Packet state transition, per the\n * transition table. Pure and side-effect free.\n */\nexport function canTransition(from: WorkPacketState, to: WorkPacketState): boolean {\n\treturn TRANSITIONS[from].includes(to);\n}\n\n/**\n * Part 1 §2 / §7 — applies a state transition to a Work Packet, returning a new packet object\n * with `state` updated and a new `TransitionLogEntry` appended to `transition_log`. Throws if\n * the transition is not legal per `canTransition`. Does not mutate `packet`.\n *\n * `now` defaults to the wall-clock ISO timestamp but is accepted as a parameter so callers\n * (and tests) can supply a deterministic clock.\n */\nexport function applyTransition(\n\tpacket: WorkPacket,\n\tto: WorkPacketState,\n\tcause: string,\n\tnow: () => string = () => new Date().toISOString(),\n): WorkPacket {\n\tif (!canTransition(packet.state, to)) {\n\t\tthrow new Error(\n\t\t\t`Illegal work packet transition: ${packet.state} -> ${to} for packet ${packet.packet_id} (cause: ${cause})`,\n\t\t);\n\t}\n\tconst at = now();\n\treturn {\n\t\t...packet,\n\t\tstate: to,\n\t\ttransition_log: [...packet.transition_log, { from: packet.state, to, at, cause }],\n\t};\n}\n\n/**\n * Part 1 §2 state 14 / §4 \"Completion exhaustion\" — CLOSED is the only terminal state.\n * ESCALATED and RETRY_QUEUED are explicitly not terminal: both can still transition further\n * (ESCALATED via an explicit external unblock signal; RETRY_QUEUED back into ROUTED).\n */\nexport function isTerminalState(state: WorkPacketState): boolean {\n\treturn state === \"CLOSED\";\n}\n\n/**\n * Part 1 §2 state 3 — whether the next attempt for `packet` must be held in\n * AWAITING_APPROVAL before its first `adaptorch_run` call, rather than going straight from\n * ROUTED to DISPATCHED.\n *\n * True only if the proposed payload differs from the packet's last-human-approved baseline,\n * or the proposed topology classification differs from the packet's currently stored topology\n * decision — unless the loop instance is running in pre-approved-batch mode (§2 state 3's\n * documented opt-in escape hatch), in which case this always returns false.\n */\nexport function requiresHumanApproval(\n\tpacket: WorkPacket,\n\tnewPayload: unknown,\n\tnewTopology: TopologyClassification | null,\n\tloopConfig: LoopConfig,\n): boolean {\n\tif (loopConfig.pre_approved_batch) {\n\t\treturn false;\n\t}\n\n\t// Pragmatic choice, not a claim of full structural equality semantics: JSON.stringify\n\t// comparison is order-sensitive for object keys and does not handle non-JSON-serializable\n\t// values (e.g. undefined, functions, symbols) specially. Adequate for the plain task\n\t// payloads this design assumes; a caller with payloads that need true structural equality\n\t// should compare upstream and pass an already-decided `newPayload` reference instead.\n\tconst payloadChanged = JSON.stringify(newPayload) !== JSON.stringify(packet.last_human_approved_payload);\n\n\tconst topologyChanged =\n\t\tnewTopology !== null &&\n\t\tpacket.topology_decision !== null &&\n\t\tnewTopology !== packet.topology_decision.classification;\n\n\treturn payloadChanged || topologyChanged;\n}\n"]}

package/dist/state-machine.js

@@ -0,0 +1,88 @@
+/**
+ * Design-fidelity note: this file implements the packet-level state machine defined in
+ * Part 1 (`final-part1-core-algorithm.md`), Section 2 (transition table), Section 4 (terminal
+ * state, since only CLOSED is terminal per §2's own text), and Section 2 state 3
+ * (AWAITING_APPROVAL's trigger condition). It is an implementation of that document, not a
+ * restatement of it.
+ */
+/**
+ * Part 1 §2 — the full transition table, as an adjacency map keyed by source state. This is
+ * the single source of truth for which transitions are legal; every other state-machine
+ * function in this file is built on top of `canTransition`.
+ */
+const TRANSITIONS = {
+    DRAFTED: ["ROUTED"],
+    ROUTED: ["AWAITING_APPROVAL", "DISPATCHED"],
+    AWAITING_APPROVAL: ["DISPATCHED", "CLOSED"],
+    DISPATCHED: ["ACTIVE", "RAW_TERMINAL", "CLOSED"],
+    ACTIVE: ["RAW_TERMINAL", "HALTING", "CLOSED"],
+    HALTING: ["RAW_TERMINAL", "CLOSED"],
+    RAW_TERMINAL: ["UNDER_REVIEW", "ADJUDICATION_FAILED"],
+    UNDER_REVIEW: ["ADJUDICATION_FAILED", "CONFIRMED", "DECLINED"],
+    ADJUDICATION_FAILED: ["UNDER_REVIEW", "ESCALATED"],
+    CONFIRMED: ["CLOSED"],
+    DECLINED: ["ESCALATED", "RETRY_QUEUED", "CLOSED"],
+    RETRY_QUEUED: ["ROUTED"],
+    ESCALATED: ["RETRY_QUEUED", "CLOSED"],
+    CLOSED: [],
+};
+/**
+ * Part 1 §2 — returns whether `from -> to` is a legal Work Packet state transition, per the
+ * transition table. Pure and side-effect free.
+ */
+export function canTransition(from, to) {
+    return TRANSITIONS[from].includes(to);
+}
+/**
+ * Part 1 §2 / §7 — applies a state transition to a Work Packet, returning a new packet object
+ * with `state` updated and a new `TransitionLogEntry` appended to `transition_log`. Throws if
+ * the transition is not legal per `canTransition`. Does not mutate `packet`.
+ *
+ * `now` defaults to the wall-clock ISO timestamp but is accepted as a parameter so callers
+ * (and tests) can supply a deterministic clock.
+ */
+export function applyTransition(packet, to, cause, now = () => new Date().toISOString()) {
+    if (!canTransition(packet.state, to)) {
+        throw new Error(`Illegal work packet transition: ${packet.state} -> ${to} for packet ${packet.packet_id} (cause: ${cause})`);
+    }
+    const at = now();
+    return {
+        ...packet,
+        state: to,
+        transition_log: [...packet.transition_log, { from: packet.state, to, at, cause }],
+    };
+}
+/**
+ * Part 1 §2 state 14 / §4 "Completion exhaustion" — CLOSED is the only terminal state.
+ * ESCALATED and RETRY_QUEUED are explicitly not terminal: both can still transition further
+ * (ESCALATED via an explicit external unblock signal; RETRY_QUEUED back into ROUTED).
+ */
+export function isTerminalState(state) {
+    return state === "CLOSED";
+}
+/**
+ * Part 1 §2 state 3 — whether the next attempt for `packet` must be held in
+ * AWAITING_APPROVAL before its first `adaptorch_run` call, rather than going straight from
+ * ROUTED to DISPATCHED.
+ *
+ * True only if the proposed payload differs from the packet's last-human-approved baseline,
+ * or the proposed topology classification differs from the packet's currently stored topology
+ * decision — unless the loop instance is running in pre-approved-batch mode (§2 state 3's
+ * documented opt-in escape hatch), in which case this always returns false.
+ */
+export function requiresHumanApproval(packet, newPayload, newTopology, loopConfig) {
+    if (loopConfig.pre_approved_batch) {
+        return false;
+    }
+    // Pragmatic choice, not a claim of full structural equality semantics: JSON.stringify
+    // comparison is order-sensitive for object keys and does not handle non-JSON-serializable
+    // values (e.g. undefined, functions, symbols) specially. Adequate for the plain task
+    // payloads this design assumes; a caller with payloads that need true structural equality
+    // should compare upstream and pass an already-decided `newPayload` reference instead.
+    const payloadChanged = JSON.stringify(newPayload) !== JSON.stringify(packet.last_human_approved_payload);
+    const topologyChanged = newTopology !== null &&
+        packet.topology_decision !== null &&
+        newTopology !== packet.topology_decision.classification;
+    return payloadChanged || topologyChanged;
+}
+//# sourceMappingURL=state-machine.js.map