@gate-forge/core 0.7.1 → 0.8.0

package/dist/twin-paths.js

@@ -0,0 +1,233 @@
+/**
+ * Twin path coverage (E64): the pure half of "did the raw test and its
+ * witnessed twin actually exercise the same requests?"
+ *
+ * The reported bug is not a red test. It is a GREEN one: a raw test and
+ * its witnessed twin shared a helper whose parameter defaults sent them
+ * down different paths — the list call carried `?tab=all` in one and
+ * `?tab=open` in the other — so "green three times" proved nothing
+ * about the path the witnessed twin covered, and nobody could say so
+ * from the run.
+ *
+ * This module turns two sets of observed requests into the honest
+ * question: which request shapes did one twin exercise that the other
+ * never did? The observation itself lives engine-side (the proxy); the
+ * comparison, the shape vocabulary and the finding text live here, in
+ * core, because they are domain logic and must be testable without a
+ * browser.
+ *
+ * What a shape may contain is deliberately narrow. A shape is a method,
+ * a route TEMPLATE (never a concrete id) and the values of an
+ * owner-declared query-key allowlist. No body, no header, no cookie, no
+ * non-allowlisted value: a shape list is something an owner pastes into
+ * a bug, so it must be impossible for it to carry a secret.
+ */
+import { compareStrings } from './graph/util.js';
+/** Segments that identify nothing: an id is an id wherever it appears. */
+const IDENTIFIER_SEGMENT = /^(\d+|[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+/** Splits a request target into its path and its decoded query pairs. */
+function splitTarget(url) {
+    const cut = url.search(/[?#]/);
+    const path = cut === -1 ? url : url.slice(0, cut);
+    const search = cut === -1 ? '' : url.slice(cut + 1).split('#')[0] ?? '';
+    const query = search === ''
+        ? []
+        : search.split('&').map((pair) => {
+            const equals = pair.indexOf('=');
+            return equals === -1
+                ? [pair, '']
+                : [pair.slice(0, equals), decodeURIComponent(pair.slice(equals + 1).replace(/\+/g, ' '))];
+        });
+    return { path: path === '' ? '/' : path, query };
+}
+/**
+ * Rewrites a concrete path to a template: every numeric or UUID segment
+ * becomes `{}`. Used when the run has no compiled route inventory to
+ * resolve against, so a shape still never carries an identifier.
+ */
+function templatizePath(path) {
+    return path
+        .split('/')
+        .map((segment) => (IDENTIFIER_SEGMENT.test(segment) ? '{}' : segment))
+        .join('/');
+}
+/**
+ * Resolves a concrete path against the compiled route inventory: the
+ * first template whose segment count and static segments match wins. A
+ * run with no inventory (or no match) falls back to the identifier-
+ * blind template, never to the raw path.
+ */
+function routeOf(path, inventory) {
+    const segments = path.split('/');
+    for (const template of inventory?.templates ?? []) {
+        const parts = template.split('/');
+        if (parts.length !== segments.length)
+            continue;
+        const matches = parts.every((part, index) => part === '{}' || part === segments[index]);
+        if (matches)
+            return template;
+    }
+    return templatizePath(path);
+}
+/**
+ * Turns one observed request into its comparable shape.
+ *
+ * Args:
+ *   request: the method and target the proxy observed.
+ *   options: the run's route inventory and owner-declared query keys.
+ *
+ * Returns:
+ *   TwinShape: method + route template + allowlisted query values.
+ */
+export function twinShapeOf(request, options = {}) {
+    const { path, query } = splitTarget(request.url);
+    const allowlist = new Set(options.queryKeys ?? []);
+    const values = {};
+    for (const [key, value] of [...query].sort((left, right) => compareStrings(left[0], right[0]))) {
+        // The KEY is always recorded; the VALUE only when the owner named
+        // this key. A non-allowlisted value cannot reach a shape, and a
+        // shape is what every report and state document carries.
+        if (allowlist.has(key))
+            values[key] = value;
+    }
+    return {
+        method: request.method.toUpperCase(),
+        route: routeOf(path, options.inventory),
+        ...(Object.keys(values).length === 0 ? {} : { query: values }),
+    };
+}
+/** The stable comparable identity of a shape. */
+function shapeKey(shape) {
+    const query = Object.keys(shape.query ?? {})
+        .sort(compareStrings)
+        .map((key) => `${key}=${shape.query[key]}`)
+        .join('&');
+    return `${shape.method} ${shape.route}${query === '' ? '' : `?${query}`}`;
+}
+/** Renders one shape for a human, naming exactly what it carries. */
+function describeShape(shape) {
+    const query = Object.keys(shape.query ?? {});
+    if (query.length === 0)
+        return `${shape.method} ${shape.route}`;
+    return `${shape.method} ${shape.route}?${query
+        .sort(compareStrings)
+        .map((key) => `${key}=${shape.query[key]}`)
+        .join('&')}`;
+}
+/**
+ * Compares two twins' shapes and returns both directions of the
+ * divergence: what the witnessed twin did that the raw twin never did,
+ * and what the raw twin did that the witnessed twin never did. A shape
+ * both exercised is not reported — twins that agree are the healthy
+ * case and must stay silent.
+ *
+ * Args:
+ *   witnessed: the witnessed twin's shapes.
+ *   raw: the raw twin's shapes.
+ *
+ * Returns:
+ *   TwinDivergence[]: every one-sided shape, witnessed-side first,
+ *   deterministic in shape identity.
+ */
+export function twinPathDivergence(witnessed, raw) {
+    const rawKeys = new Set(raw.shapes.map(shapeKey));
+    const witnessedKeys = new Set(witnessed.shapes.map(shapeKey));
+    const oneSided = (shapes, other, presentIn, missingFrom) => shapes
+        .filter((shape) => !other.has(shapeKey(shape)))
+        .map((shape) => ({ presentIn, missingFrom, shape }));
+    return [
+        ...oneSided(witnessed.shapes, rawKeys, witnessed.logicalKey, raw.logicalKey),
+        ...oneSided(raw.shapes, witnessedKeys, raw.logicalKey, witnessed.logicalKey),
+    ];
+}
+/** The finding text a divergence produces, naming BOTH tests and the shape. */
+export function twinDivergenceDetail(divergence) {
+    return (`${describeShape(divergence.shape)} is exercised by '${divergence.presentIn}' and never by ` +
+        `'${divergence.missingFrom}' — the twins do not cover the same request path`);
+}
+/**
+ * The tag a title carries to declare itself the WITNESSED twin. It is
+ * part of the title convention, not a gate: the link is a naming
+ * convention an owner follows, and the engine only reads it when the
+ * owner switched twin coverage on.
+ */
+export const WITNESSED_TITLE_TAG = '[witnessed]';
+/**
+ * Resolves the raw/witnessed pairs a run should compare.
+ *
+ * Two rules, in that order, and never a guess:
+ * - `twinOf`: the explicit test-map declaration — the only link that
+ *   survives a rename of either test, because it names logical keys.
+ * - the title convention: a witnessed title that carries
+ *   {@link WITNESSED_TITLE_TAG} links to the untagged title with the
+ *   same stem: `X raw`, else the one `X raw: <description>`, else a
+ *   bare `X`.
+ *
+ * A link is only returned when BOTH tests exist in the catalog: a
+ * dangling `twinOf` or a title with no partner names nothing, because
+ * a pair with one missing side has no shapes to compare and a finding
+ * about it would be a ghost.
+ *
+ * Args:
+ *   candidates: every test the catalog knows (logical key + title).
+ *   twinOf: explicit `witnessed -> raw` logical-key declarations.
+ *
+ * Returns:
+ *   TwinLink[]: every resolvable pair, deterministic in witnessed key.
+ */
+export function twinLinksFor(candidates, twinOf = {}) {
+    const known = new Set(candidates.map((candidate) => candidate.logicalKey));
+    const links = new Map();
+    for (const witnessed of [...candidates].sort((left, right) => compareStrings(left.logicalKey, right.logicalKey))) {
+        const declared = twinOf[witnessed.logicalKey];
+        if (declared !== undefined && known.has(declared) && declared !== witnessed.logicalKey) {
+            links.set(witnessed.logicalKey, { witnessed: witnessed.logicalKey, raw: declared, source: 'test-map' });
+            continue;
+        }
+        const tagIndex = witnessed.title.lastIndexOf(WITNESSED_TITLE_TAG);
+        if (tagIndex === -1)
+            continue;
+        const stem = witnessed.title.slice(0, tagIndex).trim();
+        if (stem === '')
+            continue;
+        // `X [witnessed]` pairs with `X raw` first, then with the ONE
+        // `X raw: <description>`, then with a bare `X`: the explicit raw twin
+        // is the owner's clearer statement, and a same-title bare match is
+        // only taken when nothing else claims it.
+        const untagged = candidates.filter((candidate) => candidate.logicalKey !== witnessed.logicalKey && !candidate.title.includes(WITNESSED_TITLE_TAG));
+        const described = untagged.filter((candidate) => candidate.title.startsWith(`${stem} raw:`));
+        // A described partner is only unambiguous when the label names ONE
+        // test on each side: two witnessed tests under one label (or two
+        // described raw ones) leave the pairing to the owner (`twinOf`) —
+        // never a guess, and never a fallback to a bare title.
+        const witnessedUnderLabel = candidates.filter((candidate) => {
+            const index = candidate.title.lastIndexOf(WITNESSED_TITLE_TAG);
+            return index !== -1 && candidate.title.slice(0, index).trim() === stem;
+        }).length;
+        const describedPartner = described.length === 1 && witnessedUnderLabel === 1 ? described[0] : undefined;
+        const partner = untagged.find((candidate) => candidate.title === `${stem} raw`) ?? describedPartner;
+        if (partner === undefined && described.length > 0)
+            continue;
+        const bare = partner ??
+            candidates.find((candidate) => candidate.logicalKey !== witnessed.logicalKey &&
+                !candidate.title.includes(WITNESSED_TITLE_TAG) &&
+                candidate.title === stem);
+        if (partner === undefined && bare !== undefined) {
+            // A bare `X` may also be the stem of another witnessed title's
+            // partner; the first witnessed key (sorted) owns it, so the same
+            // raw test is never reported as the twin of two witnessed ones.
+            const alreadyLinked = [...links.values()].some((link) => link.raw === bare.logicalKey);
+            if (alreadyLinked)
+                continue;
+        }
+        if (bare !== undefined) {
+            links.set(witnessed.logicalKey, {
+                witnessed: witnessed.logicalKey,
+                raw: bare.logicalKey,
+                source: 'title',
+            });
+        }
+    }
+    return [...links.values()].sort((left, right) => compareStrings(left.witnessed, right.witnessed));
+}
+//# sourceMappingURL=twin-paths.js.map

package/dist/twin-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twin-paths.js","sourceRoot":"","sources":["../src/twin-paths.ts"],"names":[],"mappings":"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"}

package/dist/verdict/behavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"behavior.d.ts","sourceRoot":"","sources":["../../src/verdict/behavior.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,gCAAgC,CAAC;AAO5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAGpD,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAM7C,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAMnD,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAMjD,CAAC;AAEH,0EAA0E;AAC1E,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAM7C,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAMhD,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAOtD,CAAC;AAEH,qFAAqF;AACrF,MAAM,WAAW,yBAAyB;IACxC,oEAAoE;IACpE,OAAO,EAAE,eAAe,CAAC;IACzB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,OAAO,EAAE,eAAe,CAAC;IACzB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,yEAAyE;IACzE,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,wDAAwD;AACxD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,yCAAyC;AACzC,MAAM,MAAM,mBAAmB,GAC3B;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAC5C;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAE9D;AAopBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,UAAU,EAAE,SAAS,kBAAkB,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;CAC9D,GAAG,mBAAmB,CA8BtB"}
+{"version":3,"file":"behavior.d.ts","sourceRoot":"","sources":["../../src/verdict/behavior.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,gCAAgC,CAAC;AAO5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAGpD,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAM7C,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAMnD,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAMjD,CAAC;AAEH,0EAA0E;AAC1E,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAM7C,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAMhD,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAOtD,CAAC;AAEH,qFAAqF;AACrF,MAAM,WAAW,yBAAyB;IACxC,oEAAoE;IACpE,OAAO,EAAE,eAAe,CAAC;IACzB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,OAAO,EAAE,eAAe,CAAC;IACzB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,yEAAyE;IACzE,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,wDAAwD;AACxD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,yCAAyC;AACzC,MAAM,MAAM,mBAAmB,GAC3B;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAC5C;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAE9D;AA2pBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,UAAU,EAAE,SAAS,kBAAkB,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;CAC9D,GAAG,mBAAmB,CA8BtB"}

package/dist/verdict/behavior.js

@@ -21,9 +21,14 @@
  * - declarative bulk/import exact-set comparison (missing, extra, or
  *   duplicate entities fail).
  *
- * Phase 5 grades `request` actions over the `engine-http` channel.
- * `surface` (Phase 6), `deliver`, and `sequence` (Phase 8) actions, and
- * non-HTTP channels, block with an explicit phase cause — never a pass.
+ * `request` cases grade over the `engine-http` channel, `surface` cases
+ * over `engine-browser` (the Phase 6 browser driver), and `deliver`
+ * cases over `engine-task`: the engine
+ * produces the delivery, reads the queue back until every job settled,
+ * and seals that read — `attempts` rules grade from it, and a delivery
+ * case without one settles nothing about the background job.
+ * `sequence` actions and non-HTTP channels still block with an
+ * explicit phase cause — never a pass.
  */
 import { canonicalJson, sha256Canonical } from '../canonical-json.js';
 import { compareStrings } from '../graph/util.js';
@@ -301,13 +306,18 @@ function scopeDelta(before, after) {
     }
     return { added, removed, changed };
 }
+/** Whether a declared state rule is an `attempts` rule (graded only over a queue observation). */
+function isAttemptsRule(rule) {
+    return typeof rule === 'object' && rule !== null && 'kind' in rule && rule.kind === 'attempts';
+}
 /** Grades one state rule; records explained identities for atomicity. */
 function gradeStateRule(obligationId, rule, before, after, valueCtx, explained, scopeKeyOf) {
     const kind = rule['kind'];
     if (kind === 'attempts') {
         return {
             ok: false,
-            reason: `'${obligationId}': 'attempts' rules require the Phase 8 delivery trace — blocked, never satisfied`,
+            reason: `'${obligationId}': 'attempts' rules are graded over the engine's own queue ` +
+                "observation, not a scope snapshot — declare the case on the 'engine-task' channel; blocked, never satisfied",
         };
     }
     if (typeof rule['scope'] !== 'string') {
@@ -772,6 +782,9 @@ function gradeRequiredCase(obligation, caseId, records, context, httpRoutes) {
             recordIds: [],
         };
     }
+    if (action['kind'] === 'deliver') {
+        return gradeTaskCase(obligation, compiled, caseId, records, context);
+    }
     if (action['kind'] !== 'request' && action['kind'] !== 'surface') {
         return {
             status: 'missing',
@@ -924,19 +937,17 @@ function gradeRequiredCase(obligation, caseId, records, context, httpRoutes) {
     // forbidden change in one case result.
     const explained = new Map();
     const scopeKeyOf = (effectId) => compiled.effects.find((effect) => effect.id === effectId)?.scope ?? null;
-    let sawAttemptsRule = false;
     for (const rule of compiled.definition.expect.state) {
-        if (rule.kind === 'attempts')
-            sawAttemptsRule = true;
         const graded = gradeStateRule(obligationId, rule, beforeIndex, afterIndex, valueCtx, explained, scopeKeyOf);
         if (!graded.ok) {
-            if (graded.reason.includes('Phase 8')) {
+            // No queue observation exists on this channel: the evidence is
+            // absent (fail closed), not contradicted.
+            if (isAttemptsRule(rule) || graded.reason.includes('Phase 8')) {
                 return { status: 'missing', reason: graded.reason, recordIds: [recordId] };
             }
             return { status: 'invalid', reason: `${graded.reason} (BEHAVIOR_EFFECT_MISMATCH)`, recordIds: [recordId] };
         }
     }
-    void sawAttemptsRule;
     const declaredScopes = new Set(compiled.effects.map((effect) => effect.scope));
     // Read contracts additionally require zero delta on every scope.
     if (obligation.contract === 'http:read-result-verified') {
@@ -1201,7 +1212,7 @@ function gradeSurfaceCase(obligation, compiled, caseId, records, context) {
     for (const rule of compiled.definition.expect.state) {
         const graded = gradeStateRule(obligationId, rule, beforeIndex, afterIndex, valueCtx, explained, scopeKeyOf);
         if (!graded.ok) {
-            if (graded.reason.includes('Phase 8')) {
+            if (isAttemptsRule(rule) || graded.reason.includes('Phase 8')) {
                 return { status: 'missing', reason: graded.reason, recordIds: [recordId] };
             }
             return { status: 'invalid', reason: `${graded.reason} (BEHAVIOR_EFFECT_MISMATCH)`, recordIds: [recordId] };
@@ -1233,6 +1244,269 @@ function gradeSurfaceCase(obligation, compiled, caseId, records, context) {
     }
     return { status: 'satisfied', recordIds: [recordId] };
 }
+/**
+ * Grades one `attempts` rule over the engine's OWN read of the queue.
+ * Nothing here consults the test: the
+ * sealed observation carries the delivery identities the engine
+ * stamped, the per-job attempt counts the queue reported, and the
+ * transition timeline the engine sampled.
+ *
+ * The claims it settles:
+ * - `terminal: succeeded` — every produced job reached the queue's
+ *   completed state (a job still waiting, delayed, active or paused is
+ *   not a success, it is an unsettled delivery);
+ * - `terminal: failed` — every job reached the queue's failed state;
+ * - `terminal: rejected` — every job failed on its FIRST attempt (the
+ *   error class the policy declares non-retryable);
+ * - `count` — the declared attempt bound: no job may exceed it and the
+ *   queue's own declared bound may not exceed it either;
+ * - `minAttempts` (optional) — every job must have USED at least that
+ *   many attempts, so "retries up to N" cannot be satisfied by a queue
+ *   that never retried anything;
+ * - `recoveredFromStall` (optional) — the timeline must show a lost
+ *   worker being reclaimed: a job sampled `active` and later observed
+ *   non-terminal with UNCHANGED attempts and no failure reason (an
+ *   error retry raises both), and the delivery still settled.
+ *
+ * Args:
+   obligationId: the obligation being graded (diagnostics).
+   rule: the compiled `attempts` rule.
+ *   action: the case's compiled `deliver` action.
+   observation: the sealed engine queue observation.
+
+ * Returns:
+   AttemptsGrade: pass, or the verdict polarity plus the reason.
+ */
+function gradeAttemptsRule(obligationId, rule, action, observation) {
+    const fail = (reason) => ({ ok: false, reason, status: 'invalid' });
+    const declaredResource = rule['resourceId'];
+    if (declaredResource !== action['resourceId']) {
+        return fail(`'${obligationId}': the 'attempts' rule names resource '${String(declaredResource)}' but the case ` +
+            `delivers to '${String(action['resourceId'])}' (BEHAVIOR_BINDING_MISMATCH)`);
+    }
+    if (observation.complete !== true) {
+        return fail(`'${obligationId}': the engine read queue '${observation.queue}' for ${String(observation.waitedMs)} ms and ` +
+            'the delivery never reached a terminal state — a stuck background job is not a terminal outcome (BEHAVIOR_EFFECT_MISMATCH)');
+    }
+    const declaredDeliveries = action['count'];
+    if (observation.deliveryIds.length !== declaredDeliveries) {
+        return fail(`'${obligationId}': the engine produced ${String(declaredDeliveries)} deliveries but sealed ` +
+            `${String(observation.deliveryIds.length)} (BEHAVIOR_BINDING_MISMATCH)`);
+    }
+    if (observation.jobs.length !== observation.deliveryIds.length) {
+        return fail(`'${obligationId}': the queue holds ${String(observation.jobs.length)} job(s) for ` +
+            `${String(observation.deliveryIds.length)} engine deliveries — a duplicate or an extra delivery is ambiguity, not proof (BEHAVIOR_BINDING_MISMATCH)`);
+    }
+    const produced = new Set(observation.deliveryIds);
+    const terminal = rule['terminal'];
+    const bound = rule['count'];
+    const floor = rule['minAttempts'];
+    for (const job of observation.jobs) {
+        if (job.deliveryId === null || !produced.has(job.deliveryId)) {
+            return fail(`'${obligationId}': queue job '${job.jobId}' carries no engine delivery identity ` +
+                `(read as '${String(job.deliveryId)}') — the engine only grades deliveries it produced itself (BEHAVIOR_BINDING_MISMATCH)`);
+        }
+        if (terminal === 'succeeded' && job.state !== 'completed') {
+            return fail(`'${obligationId}': job '${job.jobId}' ended in state '${job.state}', not 'completed' — the queue itself ` +
+                'says the delivery did not succeed (BEHAVIOR_EFFECT_MISMATCH)');
+        }
+        if (terminal === 'failed' && job.state !== 'failed') {
+            return fail(`'${obligationId}': job '${job.jobId}' ended in state '${job.state}', not 'failed' (BEHAVIOR_EFFECT_MISMATCH)`);
+        }
+        if (terminal === 'rejected' && (job.state !== 'failed' || job.attemptsMade !== 1)) {
+            return fail(`'${obligationId}': job '${job.jobId}' is declared terminal-on-error but the queue reports state ` +
+                `'${job.state}' after ${String(job.attemptsMade)} attempt(s) — the error class was retried (BEHAVIOR_EFFECT_MISMATCH)`);
+        }
+        if (job.maxAttempts === null) {
+            return fail(`'${obligationId}': job '${job.jobId}' declares no attempt bound in the queue, so a retry bound ` +
+                `of ${String(bound)} cannot be proven (OBSERVATION_SCOPE_INCOMPLETE)`);
+        }
+        if (job.maxAttempts > bound) {
+            return fail(`'${obligationId}': job '${job.jobId}' declares an attempt bound of ${String(job.maxAttempts)}, above the ` +
+                `declared ${String(bound)} (BEHAVIOR_BINDING_MISMATCH)`);
+        }
+        if (job.attemptsMade > bound) {
+            return fail(`'${obligationId}': job '${job.jobId}' ran ${String(job.attemptsMade)} attempts, above the declared bound of ` +
+                `${String(bound)} (BEHAVIOR_EFFECT_MISMATCH)`);
+        }
+        if (typeof floor === 'number' && job.attemptsMade < floor) {
+            return fail(`'${obligationId}': job '${job.jobId}' ran ${String(job.attemptsMade)} attempt(s) — the declared rule ` +
+                `requires at least ${String(floor)}, so the retry path was never exercised (BEHAVIOR_EFFECT_MISMATCH)`);
+        }
+    }
+    if (rule['recoveredFromStall'] === true) {
+        // A lost-worker reclaim, as the engine's own timeline saw it: the
+        // same job was handed out AGAIN with UNCHANGED attempts and no
+        // failure reason recorded between the two hand-outs (an error retry
+        // raises attemptsMade and sets a reason before the re-queue). A
+        // reclaim back onto the wait list is accepted too, for a queue that
+        // parked the job before another worker took it.
+        const reclaims = new Set();
+        const activeAt = new Map();
+        for (const sample of observation.samples) {
+            if (sample.failedReason !== null)
+                continue;
+            if (sample.state === 'active') {
+                const key = `${sample.jobId}|${String(sample.attemptsMade)}`;
+                if (activeAt.has(key))
+                    reclaims.add(sample.jobId);
+                else
+                    activeAt.set(key, sample.atMs);
+                continue;
+            }
+            if (sample.state !== 'waiting' && sample.state !== 'delayed')
+                continue;
+            const startedAt = activeAt.get(`${sample.jobId}|${String(sample.attemptsMade)}`);
+            if (startedAt !== undefined && sample.atMs > startedAt)
+                reclaims.add(sample.jobId);
+        }
+        const settled = observation.jobs.filter((job) => reclaims.has(job.jobId));
+        if (settled.length === 0) {
+            return fail(`'${obligationId}': no job was observed being reclaimed from a lost worker (handed out again with ` +
+                'unchanged attempts and no failure reason) — nothing proves the queue recovers a killed worker ' +
+                '(BEHAVIOR_EFFECT_MISMATCH)');
+        }
+    }
+    return { ok: true };
+}
+/**
+ * Grades one task-driven required case:
+ * the engine produced the delivery itself, read the queue back until
+ * every job settled, and sealed that read. Proof is the sealed
+ * observation plus the declared state effects — never the suite's
+ * account of what the job did. HTTP attempts and browser observations
+ * are rejected outright: a task claim proved by a request would be a
+ * different (transport) claim.
+ *
+ * @param obligation the obligation being graded.
+ * @param compiled the compiled case from the trusted catalog.
+ * @param caseId the compiled case id.
+ * @param records the run's ledger records.
+ * @param context the trusted grading context.
+ *
+ * @returns the case outcome.
+ */
+function gradeTaskCase(obligation, compiled, caseId, records, context) {
+    const obligationId = obligation.id;
+    if (compiled.definition.channel !== 'engine-task') {
+        return {
+            status: 'missing',
+            reason: `'${obligationId}': delivery case '${compiled.definition.id}' requires the ` +
+                `'${compiled.definition.channel}' channel — a delivery is only provable engine-side`,
+            recordIds: [],
+        };
+    }
+    const matched = matchSingleCaseRecord(obligation, compiled, caseId, records, context);
+    if (matched.kind === 'outcome')
+        return matched.outcome;
+    const { recordId, payload } = matched;
+    const bound = validateCaseBindings(obligation, compiled, caseId, recordId, payload, context);
+    if (bound.kind === 'outcome')
+        return bound.outcome;
+    if (payload.attempts.length > 0 || payload.browserObservation !== undefined) {
+        return {
+            status: 'invalid',
+            reason: `'${obligationId}': delivery case record '${recordId}' carries transport evidence — a background ` +
+                'delivery is proved by the queue state the engine read, not by an HTTP attempt (BEHAVIOR_BINDING_MISMATCH)',
+            recordIds: [recordId],
+        };
+    }
+    const observation = payload.queueObservation;
+    if (observation === undefined) {
+        return {
+            status: 'missing',
+            reason: `'${obligationId}': delivery case '${compiled.definition.id}' sealed no queue observation — the ` +
+                "engine's own queue observer produces that evidence",
+            recordIds: [recordId],
+        };
+    }
+    const beforeBuilt = indexSnapshots(payload.before, compiled);
+    const afterBuilt = indexSnapshots(payload.after, compiled);
+    if (!beforeBuilt.ok || !afterBuilt.ok) {
+        return {
+            status: 'invalid',
+            reason: `'${obligationId}': ${(beforeBuilt.ok ? afterBuilt : beforeBuilt).reason}`,
+            recordIds: [recordId],
+        };
+    }
+    const valueCtx = {
+        fixtureValues: payload.fixtureValues,
+        observation: null,
+        before: beforeBuilt.index,
+    };
+    const beforeIndex = beforeBuilt.index;
+    const afterIndex = afterBuilt.index;
+    const action = compiled.definition.action;
+    // The engine produced the delivery: the sealed submitted values and
+    // the queue jobs must agree on the identity the engine stamped.
+    const submitted = payload.submittedValues;
+    if (typeof submitted !== 'object' || submitted === null || Array.isArray(submitted)) {
+        return {
+            status: 'invalid',
+            reason: `'${obligationId}': case record '${recordId}' sealed no delivery identity (BEHAVIOR_BINDING_MISMATCH)`,
+            recordIds: [recordId],
+        };
+    }
+    const stampedKey = submitted['idempotencyKey'];
+    const mismatchedKey = observation.jobs.find((job) => typeof stampedKey === 'string' && job.idempotencyKey !== stampedKey);
+    if (mismatchedKey !== undefined) {
+        return {
+            status: 'invalid',
+            reason: `'${obligationId}': queue job '${mismatchedKey.jobId}' carries idempotency key ` +
+                `'${mismatchedKey.idempotencyKey}', not the engine-stamped '${String(stampedKey)}' (BEHAVIOR_BINDING_MISMATCH)`,
+            recordIds: [recordId],
+        };
+    }
+    const explained = new Map();
+    const scopeKeyOf = (effectId) => compiled.effects.find((effect) => effect.id === effectId)?.scope ?? null;
+    let sawAttemptsRule = false;
+    for (const rule of compiled.definition.expect.state) {
+        if (rule.kind === 'attempts') {
+            sawAttemptsRule = true;
+            const graded = gradeAttemptsRule(obligationId, rule, action, observation);
+            if (!graded.ok) {
+                return { status: graded.status, reason: graded.reason, recordIds: [recordId] };
+            }
+            continue;
+        }
+        const graded = gradeStateRule(obligationId, rule, beforeIndex, afterIndex, valueCtx, explained, scopeKeyOf);
+        if (!graded.ok) {
+            return { status: 'invalid', reason: `${graded.reason} (BEHAVIOR_EFFECT_MISMATCH)`, recordIds: [recordId] };
+        }
+    }
+    if (!sawAttemptsRule) {
+        return {
+            status: 'invalid',
+            reason: `'${obligationId}': delivery case '${compiled.definition.id}' declares no 'attempts' rule — without one ` +
+                'the queue read settles nothing about the background job (BEHAVIOR_BINDING_MISMATCH)',
+            recordIds: [recordId],
+        };
+    }
+    for (const scope of new Set(compiled.effects.map((effect) => effect.scope))) {
+        const beforeScope = beforeIndex.get(scope);
+        const afterScope = afterIndex.get(scope);
+        if (beforeScope === undefined || afterScope === undefined)
+            continue;
+        const ledger = explained.get(scope);
+        if (ledger?.complete.has(scope) === true)
+            continue;
+        const delta = scopeDelta(beforeScope, afterScope);
+        const unexplained = [
+            ...delta.added.filter((key) => !ledger?.added.has(key)),
+            ...delta.removed.filter((key) => !ledger?.removed.has(key)),
+            ...delta.changed.filter((key) => !ledger?.changed.has(key)),
+        ];
+        if (unexplained.length > 0) {
+            return {
+                status: 'invalid',
+                reason: `'${obligationId}': scope '${scope}' has ${String(unexplained.length)} unexplained change(s) ` +
+                    'beside the declared effect — a correct delivery plus a wrong secondary effect still fails (BEHAVIOR_UNEXPECTED_EFFECT)',
+                recordIds: [recordId],
+            };
+        }
+    }
+    return { status: 'satisfied', recordIds: [recordId] };
+}
 /**
  * Checks declared route/query/body identity selectors: the observed
  * concrete path must equal the template filled with resolved params,