@aiwg/cli 2026.9.19 → 2026.9.21

package/dist/src/effects/verifiers/git.js

@@ -0,0 +1,206 @@
+/**
+ * Built-in `git.commit` and `git.tag` verifiers over a local repository.
+ *
+ * - Object lookups go through `git cat-file --batch-check` on stdin, so a
+ *   target is never parsed as a command-line option and "missing" is a
+ *   complete, successful answer rather than an error exit.
+ * - `absent` needs a complete repository: a shallow or partial clone gives
+ *   `unknown` / `paging-incomplete` for a missing commit.
+ * - Signature checks reuse `git verify-commit` / `git verify-tag` (as
+ *   `tools/ci/verify-signed-tag.sh` does). A required signature that is not
+ *   good is never `present`: it is `unknown` / `evidence-conflict`, or
+ *   `unknown` / `container-unreadable` when it cannot be checked (no key).
+ *
+ * @see docs/contracts/effect-ledger.v1.md "Built-in verifiers"
+ */
+import { spawn } from 'node:child_process';
+import { EffectVerifierError } from './types.js';
+export const GIT_VERIFIER_VERSION = '1.0.0';
+const OBJECT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+const TAG_NAME = /^[A-Za-z0-9][A-Za-z0-9._+/-]{0,254}$/;
+const MAX_OUTPUT = 4 * 1024 * 1024;
+function spawnRunner(repoDir, binary) {
+    return (args, options = {}) => new Promise((resolve, reject) => {
+        const child = spawn(binary, ['-C', repoDir, ...args], {
+            stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, signal: options.signal,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0', LC_ALL: 'C' },
+        });
+        const out = [];
+        const err = [];
+        let size = 0;
+        const collect = (sink) => (chunk) => {
+            size += chunk.length;
+            if (size > MAX_OUTPUT)
+                child.kill();
+            else
+                sink.push(chunk);
+        };
+        child.stdout.on('data', collect(out));
+        child.stderr.on('data', collect(err));
+        // A git binary that cannot start is an unreadable container; an abort is the framework timeout.
+        child.once('error', error => reject(options.signal?.aborted ? error : new EffectVerifierError('container-unreadable')));
+        child.stdin.once('error', () => { });
+        child.once('close', code => {
+            if (size > MAX_OUTPUT)
+                reject(new EffectVerifierError('malformed-response'));
+            else
+                resolve({ stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8'), exitCode: code ?? 1 });
+        });
+        child.stdin.end(options.stdin ?? '');
+    });
+}
+const unknown = (reason, evidence) => ({ result: 'unknown', reason, complete: false, ...(evidence ? { evidence } : {}) });
+/** Read an expectation member from `expected`, falling back to the identity context. */
+function expectation(request, name) {
+    return request.expected[name] ?? request.context[name];
+}
+function gitFor(options) {
+    if (!options || typeof options.repoDir !== 'string' || !options.repoDir)
+        throw new TypeError('git verifiers need repoDir');
+    const run = options.runner ?? spawnRunner(options.repoDir, options.gitBinary ?? 'git');
+    return {
+        run,
+        async assertReadable(signal) {
+            const result = await run(['rev-parse', '--git-dir'], { signal });
+            if (result.exitCode !== 0)
+                throw new EffectVerifierError('container-unreadable');
+        },
+        async lookup(name, signal) {
+            const result = await run(['cat-file', '--batch-check=%(objectname) %(objecttype)'], { stdin: `${name}\n`, signal });
+            if (result.exitCode !== 0)
+                throw new EffectVerifierError('container-unreadable');
+            const line = result.stdout.trim();
+            if (line === `${name} missing`)
+                return null;
+            if (line === `${name} ambiguous`)
+                throw new EffectVerifierError('evidence-conflict');
+            const match = /^([a-f0-9]{40}|[a-f0-9]{64}) ([a-z]+)$/.exec(line);
+            if (!match)
+                throw new EffectVerifierError('malformed-response');
+            return { oid: match[1], type: match[2] };
+        },
+        async complete(signal) {
+            const shallow = await run(['rev-parse', '--is-shallow-repository'], { signal });
+            if (shallow.exitCode !== 0 || !/^(?:true|false)$/.test(shallow.stdout.trim()))
+                throw new EffectVerifierError('container-unreadable');
+            if (shallow.stdout.trim() === 'true')
+                return false;
+            const partial = await run(['config', '--get', 'extensions.partialclone'], { signal });
+            if (partial.exitCode === 0 && partial.stdout.trim())
+                return false;
+            if (partial.exitCode !== 0 && partial.exitCode !== 1)
+                throw new EffectVerifierError('container-unreadable');
+            return true;
+        },
+    };
+}
+/** Classify a failed `verify-commit` / `verify-tag --raw` from its status output. */
+function failedSignature(stderr) {
+    if (/\b(?:REVKEYSIG)\b|revoked/i.test(stderr))
+        return 'revoked';
+    if (/\b(?:EXPKEYSIG|EXPSIG)\b|expired/i.test(stderr))
+        return 'expired';
+    if (/\bBADSIG\b|bad signature/i.test(stderr))
+        return 'bad';
+    if (/\b(?:NO_PUBKEY|ERRSIG)\b|allowedSignersFile|No principal matched|no public key|can't check signature|gpg failed|cannot run/i.test(stderr))
+        return 'unverifiable';
+    return 'bad';
+}
+async function signatureStatus(git, command, oid, hasSignature, signal) {
+    if (!hasSignature)
+        return 'unsigned';
+    const result = await git.run([command, '--raw', oid], { signal });
+    return result.exitCode === 0 ? 'good' : failedSignature(result.stderr);
+}
+/** A required signature that is not good is never `present`. */
+function signatureBlocks(status) {
+    if (status === 'good' || status === 'unchecked')
+        return null;
+    return status === 'unverifiable' ? 'container-unreadable' : 'evidence-conflict';
+}
+/** `git.commit`: target `git:<sha>` (full 40 or 64 hex). */
+export function gitCommitVerifier(options) {
+    const git = gitFor(options);
+    return {
+        kind: 'git.commit',
+        version: GIT_VERIFIER_VERSION,
+        canReportAbsent: true,
+        async verify(request) {
+            const sha = request.target.startsWith('git:') ? request.target.slice(4) : '';
+            if (!OBJECT_ID.test(sha))
+                return unknown('malformed-response');
+            const signed = expectation(request, 'signed') === true;
+            await git.assertReadable(request.signal);
+            const object = await git.lookup(sha, request.signal);
+            if (!object) {
+                if (!await git.complete(request.signal))
+                    return unknown('paging-incomplete');
+                return { result: 'absent', reason: 'complete-query-no-match', complete: true, evidence: { object: sha, found: false } };
+            }
+            if (object.type !== 'commit' || object.oid !== sha)
+                return unknown('evidence-conflict', { object: sha, type: object.type });
+            const body = await git.run(['cat-file', 'commit', sha], { signal: request.signal });
+            if (body.exitCode !== 0)
+                return unknown('container-unreadable');
+            const header = body.stdout.split('\n\n', 1)[0] ?? '';
+            const hasSignature = /^gpgsig(?:-sha256)? /m.test(header);
+            const signature = signed ? await signatureStatus(git, 'verify-commit', sha, hasSignature, request.signal) : 'unchecked';
+            const trailers = await git.run(['log', '-1', '--format=%(trailers:key=Effect-Id,valueonly)', sha], { signal: request.signal });
+            if (trailers.exitCode !== 0)
+                return unknown('container-unreadable');
+            const marker = trailers.stdout.split('\n').map(line => line.trim()).includes(request.effectId);
+            const evidence = { object: sha, type: 'commit', signature, signatureRequired: signed, marker };
+            const blocked = signed ? signatureBlocks(signature) : null;
+            if (blocked)
+                return unknown(blocked, evidence);
+            return { result: 'present', reason: marker ? 'marker-match' : 'state-match', complete: true, evidence };
+        },
+    };
+}
+/** `git.tag`: target `git-tag:<name>`; the expected peeled object comes from `expected.object` or `context.object`. */
+export function gitTagVerifier(options) {
+    const git = gitFor(options);
+    return {
+        kind: 'git.tag',
+        version: GIT_VERIFIER_VERSION,
+        canReportAbsent: true,
+        async verify(request) {
+            const name = request.target.startsWith('git-tag:') ? request.target.slice(8) : '';
+            if (!TAG_NAME.test(name) || name.includes('..') || name.includes('//') || name.endsWith('.lock') || name.endsWith('/') || name.endsWith('.')) {
+                return unknown('malformed-response');
+            }
+            const expectedObject = expectation(request, 'object');
+            if (expectedObject !== undefined && (typeof expectedObject !== 'string' || !OBJECT_ID.test(expectedObject)))
+                return unknown('malformed-response');
+            const signed = expectation(request, 'signed') === true;
+            await git.assertReadable(request.signal);
+            const ref = `refs/tags/${name}`;
+            const tag = await git.lookup(ref, request.signal);
+            if (!tag)
+                return { result: 'absent', reason: 'complete-query-no-match', complete: true, evidence: { tag: name, found: false } };
+            const peeled = await git.lookup(`${ref}^{}`, request.signal);
+            if (!peeled)
+                return unknown('evidence-conflict');
+            let hasSignature = false;
+            if (tag.type === 'tag') {
+                const body = await git.run(['cat-file', 'tag', tag.oid], { signal: request.signal });
+                if (body.exitCode !== 0)
+                    return unknown('container-unreadable');
+                hasSignature = /-----BEGIN (?:PGP|SSH) SIGNATURE-----/.test(body.stdout);
+            }
+            const signature = signed ? await signatureStatus(git, 'verify-tag', tag.oid, hasSignature, request.signal) : 'unchecked';
+            const evidence = {
+                tag: name, tagObject: tag.oid, annotated: tag.type === 'tag', object: peeled.oid,
+                expectedObject: typeof expectedObject === 'string' ? expectedObject : null, signature, signatureRequired: signed,
+            };
+            // The tag name exists but points elsewhere: a replay would collide, so never `absent`.
+            if (typeof expectedObject === 'string' && peeled.oid !== expectedObject && tag.oid !== expectedObject)
+                return unknown('evidence-conflict', evidence);
+            const blocked = signed ? signatureBlocks(signature) : null;
+            if (blocked)
+                return unknown(blocked, evidence);
+            return { result: 'present', reason: 'state-match', complete: true, evidence };
+        },
+    };
+}
+//# sourceMappingURL=git.js.map

package/dist/src/effects/verifiers/index.js

@@ -0,0 +1,90 @@
+/**
+ * Effect verifiers (#2718, epic #2714): the tri-state verifier interface, the
+ * registry, and the built-in verifiers.
+ *
+ * ## Interface
+ *
+ * A verifier is a plain object:
+ *
+ * ```ts
+ * interface EffectVerifier {
+ *   readonly kind: string;             // core kind or x.<vendor>.<name>
+ *   readonly version: string;          // semver, recorded in every verification
+ *   readonly canReportAbsent: boolean; // false: any `absent` becomes `unknown`
+ *   verify(request: EffectVerifierRequest): Promise<EffectVerifierObservation>;
+ * }
+ * ```
+ *
+ * `verify` receives the intent's identity (`effectId`, `scope`, `kind`,
+ * `target`, `context`, `payloadDigest`, `intentRecordedAt`), the caller's
+ * `expected` digests and references, and an `AbortSignal` that fires at the
+ * framework timeout. It answers `{result, reason, complete, evidence?}` with a
+ * reason code from the contract table. Classified failures either return
+ * `unknown` or throw `EffectVerifierError(reason)`.
+ *
+ * The framework (`runVerifier`, used by `reconcileEffect`) never lets a
+ * verifier bypass the rules: a missing verifier, a kind or pinned-version
+ * mismatch, any throw, a timeout, a malformed answer, a reason that does not
+ * belong to the result, `absent` from a verifier that cannot report it, and
+ * `absent` without `complete: true` all become `unknown`. Evidence is digested
+ * into `evidenceDigest`; only the digest reaches the ledger.
+ *
+ * ## Registering
+ *
+ * ```ts
+ * const registry = createBuiltinVerifierRegistry(
+ *   { git: { repoDir }, file: { root }, decision: { receipts, jobs } },
+ *   [...createTrackerVerifiers({ config, remoteUrls }), myVendorVerifier],   // extensions
+ * );
+ * await reconcileEffect(ledger, id, { verifiers: registry, expected: { signed: true } });
+ * ```
+ *
+ * ## Extension point: `x.<vendor>.<name>`
+ *
+ * A vendor verifier uses a kind matching
+ * `^x\.[a-z0-9][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)+$` and a target in the
+ * `x-<vendor>:<ref>` scheme, and is passed in the extension list (or to
+ * `createVerifierRegistry`). It follows exactly the same interface and rules;
+ * it cannot shadow a registered kind, and adding a new core kind is a contract
+ * revision.
+ *
+ * @see docs/contracts/effect-ledger.v1.md "Verifier interface"
+ */
+import { createVerifierRegistry } from './registry.js';
+import { decisionReceiptVerifier } from './decision.js';
+import { FILE_DIGEST_VERIFIER_VERSION, fileDigestVerifier } from './file.js';
+import { GIT_VERIFIER_VERSION, gitCommitVerifier, gitTagVerifier } from './git.js';
+import { REVIEW_CONTINUATION_VERIFIER_VERSION, reviewContinuationVerifier } from './review.js';
+import { EffectVerifierError } from './types.js';
+export * from './types.js';
+export { DEFAULT_VERIFIER_TIMEOUT_MS, createVerifierRegistry, evidenceDigest, runVerifier, } from './registry.js';
+export { GIT_VERIFIER_VERSION, gitCommitVerifier, gitTagVerifier, } from './git.js';
+export { FILE_DIGEST_VERIFIER_VERSION, fileDigestVerifier } from './file.js';
+export { DECISION_RECEIPT_VERIFIER_VERSION, REVIEW_CONTINUATION_PLACEHOLDER_VERSION, decisionReceiptVerifier, reviewContinuationPlaceholderVerifier, } from './decision.js';
+export { REVIEW_CONTINUATION_VERIFIER_VERSION, reviewContinuationTarget, reviewContinuationVerifier, } from './review.js';
+export { DEFAULT_MAX_COMMENT_PAGES, DEFAULT_MIN_ABSENT_AGE_MS, TRACKER_VERIFIER_VERSION, createTrackerVerifiers, parseEffectIdTrailers, parseEffectMarkers, renderEffectMarker, trackerCommentVerifier, trackerIssueClosedVerifier, trackerPrMergedVerifier, } from './tracker.js';
+/** Stand-in for a built-in whose container is not configured on this host. */
+function unconfigured(kind, version) {
+    return {
+        kind, version, canReportAbsent: true,
+        async verify() { throw new EffectVerifierError('container-unreadable', 'Effect verifier is not configured on this host'); },
+    };
+}
+/**
+ * The five built-in verifiers: `git.commit`, `git.tag`, `file.digest`,
+ * `decision.receipt` and `decision.review.continuation`.
+ */
+export function createBuiltinVerifiers(options = {}) {
+    return [
+        options.git ? gitCommitVerifier(options.git) : unconfigured('git.commit', GIT_VERIFIER_VERSION),
+        options.git ? gitTagVerifier(options.git) : unconfigured('git.tag', GIT_VERIFIER_VERSION),
+        options.file ? fileDigestVerifier(options.file) : unconfigured('file.digest', FILE_DIGEST_VERIFIER_VERSION),
+        decisionReceiptVerifier(options.decision ?? {}),
+        options.review ? reviewContinuationVerifier(options.review) : unconfigured('decision.review.continuation', REVIEW_CONTINUATION_VERIFIER_VERSION),
+    ];
+}
+/** A registry of the built-ins plus `extensions` (tracker verifiers, `x.<vendor>.<name>` kinds). Duplicate kinds are refused. */
+export function createBuiltinVerifierRegistry(options = {}, extensions = []) {
+    return createVerifierRegistry([...createBuiltinVerifiers(options), ...extensions]);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/effects/verifiers/registry.js

@@ -0,0 +1,148 @@
+/**
+ * Verifier registry keyed by kind, and the framework runner that enforces the
+ * tri-state rules on every verifier answer.
+ *
+ * @see docs/contracts/effect-ledger.v1.md "Verifier interface"
+ */
+import { canonicalJson } from '../../security/artifact-trust.js';
+import { usageError } from '../errors.js';
+import { isEffectKind, sha256Digest } from '../identity.js';
+import { assertDigestOnly } from '../redaction.js';
+import { ABSENT_REASONS, PRESENT_REASONS, UNKNOWN_REASONS, } from '../types.js';
+import { EffectVerifierError, } from './types.js';
+const SEMVER = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+/**
+ * Build a registry. Kinds must be core kinds or `x.<vendor>.<name>` extension
+ * kinds, versions must be semver, and each kind has exactly one verifier.
+ * The default registry is empty: every reconcile is `unknown` / `verifier-missing`.
+ */
+export function createVerifierRegistry(verifiers = []) {
+    const byKind = new Map();
+    for (const verifier of verifiers) {
+        if (!verifier || typeof verifier.verify !== 'function' || typeof verifier.canReportAbsent !== 'boolean') {
+            throw usageError('A verifier needs kind, version, canReportAbsent and verify', 'invalid-verifier');
+        }
+        if (!isEffectKind(verifier.kind))
+            throw usageError('Verifier kind must be a core kind or x.<vendor>.<name>', 'invalid-verifier');
+        if (byKind.has(verifier.kind))
+            throw usageError('Only one verifier may be registered per kind', 'duplicate-verifier');
+        if (typeof verifier.version !== 'string' || !SEMVER.test(verifier.version))
+            throw usageError('Verifier version must be semver', 'invalid-verifier');
+        byKind.set(verifier.kind, verifier);
+    }
+    const kinds = () => [...byKind.keys()].sort();
+    return {
+        get: kind => byKind.get(kind),
+        kinds,
+        listKinds: () => kinds().map(kind => refFor(byKind.get(kind))),
+    };
+}
+function refFor(verifier) {
+    return { kind: verifier.kind, version: verifier.version, canReportAbsent: verifier.canReportAbsent };
+}
+/** Digest of structured evidence: `sha256:` over `canonicalJson(evidence)`. */
+export function evidenceDigest(evidence) {
+    return sha256Digest(canonicalJson(evidence));
+}
+export const DEFAULT_VERIFIER_TIMEOUT_MS = 30_000;
+const unknown = (reason) => ({ result: 'unknown', reason, complete: false });
+/** Enforce the tri-state rules: `absent` needs a capable verifier and a complete query; reasons must match the result. */
+function normalize(verifier, observation) {
+    const value = observation;
+    if (!value || typeof value !== 'object' || typeof value.complete !== 'boolean'
+        || (value.evidenceDigest !== undefined && !DIGEST.test(value.evidenceDigest)))
+        return { observation: unknown('malformed-response') };
+    let evidence;
+    let digest = value.evidenceDigest;
+    if (value.evidence !== undefined) {
+        const candidate = value.evidence;
+        const flat = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+            && Object.values(candidate).every(item => item === null || ['string', 'number', 'boolean'].includes(typeof item));
+        if (!flat)
+            return { observation: unknown('malformed-response') };
+        try {
+            assertDigestOnly(candidate);
+        }
+        catch {
+            return { observation: unknown('malformed-response') };
+        }
+        evidence = structuredClone(candidate);
+        const computed = evidenceDigest(evidence);
+        if (digest !== undefined && digest !== computed)
+            return { observation: unknown('malformed-response') };
+        digest = computed;
+    }
+    const withEvidence = (base) => ({
+        observation: { ...base, ...(digest ? { evidenceDigest: digest } : {}) },
+        ...(evidence ? { evidence } : {}),
+    });
+    if (value.result === 'present') {
+        return PRESENT_REASONS.includes(value.reason)
+            ? withEvidence({ result: 'present', reason: value.reason, complete: value.complete })
+            : { observation: unknown('malformed-response') };
+    }
+    if (value.result === 'absent') {
+        if (!verifier.canReportAbsent)
+            return { observation: unknown('verifier-cannot-report-absent') };
+        if (!value.complete)
+            return { observation: unknown('paging-incomplete') };
+        if (!ABSENT_REASONS.includes(value.reason))
+            return { observation: unknown('malformed-response') };
+        return withEvidence({ result: 'absent', reason: value.reason, complete: true });
+    }
+    if (value.result === 'unknown') {
+        return UNKNOWN_REASONS.includes(value.reason)
+            ? withEvidence({ result: 'unknown', reason: value.reason, complete: value.complete })
+            : { observation: unknown('malformed-response') };
+    }
+    return { observation: unknown('malformed-response') };
+}
+function thrownReason(error, timedOut) {
+    if (timedOut)
+        return 'timeout';
+    if (error instanceof EffectVerifierError && UNKNOWN_REASONS.includes(error.reason))
+        return error.reason;
+    return 'server-error';
+}
+/**
+ * Run one verifier query under the framework rules. Never throws: a missing
+ * verifier, a kind or version mismatch, a throw, a timeout or a malformed
+ * answer all give `unknown`. `absent` survives only from a verifier with
+ * `canReportAbsent: true` reporting `complete: true`.
+ */
+export async function runVerifier(verifier, request, options = {}) {
+    if (!verifier)
+        return { verifier: { kind: request.kind, version: '0.0.0', canReportAbsent: false }, observation: unknown('verifier-missing') };
+    const ref = { kind: request.kind, version: SEMVER.test(String(verifier.version)) ? verifier.version : '0.0.0', canReportAbsent: verifier.canReportAbsent === true };
+    if (verifier.kind !== request.kind || (options.verifierVersion !== undefined && options.verifierVersion !== verifier.version)) {
+        return { verifier: ref, observation: unknown('verifier-version-mismatch') };
+    }
+    const timeoutMs = options.timeoutMs ?? DEFAULT_VERIFIER_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    let timer;
+    const expiry = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new EffectVerifierError('timeout', 'Effect verifier timed out'));
+            reject(new EffectVerifierError('timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const answer = await Promise.race([
+            Promise.resolve().then(() => verifier.verify({ ...structuredClone(request), signal: controller.signal })),
+            expiry,
+        ]);
+        if (timedOut)
+            return { verifier: ref, observation: unknown('timeout') };
+        return { verifier: ref, ...normalize(verifier, answer) };
+    }
+    catch (error) {
+        return { verifier: ref, observation: unknown(thrownReason(error, timedOut)) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/effects/verifiers/review.js

@@ -0,0 +1,123 @@
+/**
+ * Built-in `decision.review.continuation` verifier over the D13 review store
+ * (#2721). It replaces the #2718 placeholder.
+ *
+ * Target: `review:<tenant>/<project>/<reviewId>`. The context is exactly the
+ * `d13.review/v1` identity `{reviewId, continuationId, proposalVersion}`, and
+ * the effect ID must equal `reviewDigest(context)`.
+ *
+ * The review store is the authority for whether the continuation was dispatched
+ * and whether its receipt was persisted. While the review holds the
+ * continuation without a receipt (the crash window between dispatch and
+ * `execution-completed`), the store cannot settle the effect; the verifier then
+ * asks the host's `execution` probe, which queries the effect's own target. With
+ * no probe the answer is `unknown` / `consistency-lag`.
+ *
+ * `absent` never authorizes a D13 replay by itself (see the contract).
+ *
+ * @see docs/contracts/effect-ledger.v1.md "Built-in verifiers"
+ */
+import { canonicalJson } from '../../security/artifact-trust.js';
+import { ReviewAccessError, reviewDigest } from '../../decision/review/validate.js';
+import { sha256Digest } from '../identity.js';
+export const REVIEW_CONTINUATION_VERIFIER_VERSION = '1.0.0';
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+const unknown = (reason, evidence) => ({ result: 'unknown', reason, complete: false, ...(evidence ? { evidence } : {}) });
+/**
+ * Parse `review:<tenant>/<project>/<reviewId>` against the effect scope. Tenant
+ * and project may themselves contain `/`, so the prefix comes from the scope.
+ */
+function targetReviewId(target, scope) {
+    const prefix = `review:${scope.tenant}/${scope.project}/`;
+    return target.startsWith(prefix) && target.length > prefix.length ? target.slice(prefix.length) : null;
+}
+/** The `decision.review.continuation` target for a review. */
+export function reviewContinuationTarget(tenantId, projectId, reviewId) {
+    return `review:${tenantId}/${projectId}/${reviewId}`;
+}
+function receiptDigest(review) {
+    try {
+        return reviewDigest(review.effectReceipt);
+    }
+    catch {
+        return null;
+    }
+}
+async function delegate(options, request, base) {
+    if (!options.execution)
+        return unknown('consistency-lag', { ...base, execution: 'not-configured' });
+    const answer = await options.execution(request);
+    if (!answer || typeof answer !== 'object')
+        return unknown('malformed-response', base);
+    let executionEvidenceDigest = answer.evidenceDigest ?? null;
+    if (answer.evidence !== undefined) {
+        try {
+            executionEvidenceDigest = sha256Digest(canonicalJson(answer.evidence));
+        }
+        catch {
+            return unknown('malformed-response', base);
+        }
+    }
+    // The framework normalizes the delegated result and reason like any other answer.
+    return {
+        result: answer.result, reason: answer.reason, complete: answer.complete,
+        evidence: { ...base, execution: 'probed', executionReason: String(answer.reason), executionEvidenceDigest },
+    };
+}
+/** `decision.review.continuation`: the D13 review store, then the host execution probe. */
+export function reviewContinuationVerifier(options) {
+    return {
+        kind: 'decision.review.continuation',
+        version: REVIEW_CONTINUATION_VERIFIER_VERSION,
+        canReportAbsent: true,
+        async verify(request) {
+            const targetId = targetReviewId(request.target, request.scope);
+            const { reviewId, continuationId, proposalVersion } = request.context;
+            if (request.scope.subsystem !== 'review' || targetId === null || targetId !== reviewId
+                || typeof continuationId !== 'string' || typeof proposalVersion !== 'number'
+                || request.effectId !== reviewDigest({ reviewId, continuationId, proposalVersion }))
+                return unknown('malformed-response');
+            const expected = request.expected.digest;
+            if (expected !== undefined && !DIGEST.test(expected))
+                return unknown('malformed-response');
+            let review;
+            try {
+                review = await options.store.read(targetId, request.scope.tenant, request.scope.project);
+            }
+            catch (error) {
+                return unknown(error instanceof ReviewAccessError ? 'auth-denied' : 'container-unreadable');
+            }
+            const base = { source: 'd13-review', found: review !== null, expectedDigest: expected ?? null };
+            if (!review)
+                return { result: 'absent', reason: 'complete-query-no-match', complete: true, evidence: base };
+            const state = { ...base, status: review.status, revision: review.revision };
+            if (review.status === 'tombstoned')
+                return unknown('container-unreadable', state);
+            if (review.continuation.id !== continuationId)
+                return unknown('evidence-conflict', state);
+            if (review.effectReceipt) {
+                const actual = receiptDigest(review);
+                const evidence = { ...state, receiptDigest: actual };
+                if (!actual)
+                    return unknown('malformed-response', state);
+                // A receipt for another proposal version means this identity never completed here, but a
+                // replay under it would still race the recorded effect: never absent.
+                if (review.effectReceipt.effectId !== request.effectId)
+                    return unknown('evidence-conflict', evidence);
+                if (expected === undefined)
+                    return { result: 'present', reason: 'state-match', complete: true, evidence };
+                return actual === expected
+                    ? { result: 'present', reason: 'digest-match', complete: true, evidence }
+                    : unknown('evidence-conflict', evidence);
+            }
+            const dispatched = review.events.some(event => event.type === 'resumed' && event.data?.effectId === request.effectId);
+            if (!dispatched)
+                return { result: 'absent', reason: 'complete-query-no-match', complete: true, evidence: { ...state, dispatched: false } };
+            // A definitive executor failure is recorded only when the target rejected the effect.
+            if (review.status === 'execution-failed')
+                return { result: 'absent', reason: 'complete-query-no-match', complete: true, evidence: { ...state, dispatched: true } };
+            return delegate(options, request, { ...state, dispatched: true });
+        },
+    };
+}
+//# sourceMappingURL=review.js.map