@open-agent-toolkit/cli 0.3.19 → 0.3.20

package/dist/commands/project/closeout-check/closeout-invariant.js

@@ -1,3 +1,4 @@
+import { parseBriefOutcomes, parsePhaseMarkers, parseTaskProgress, validateGoalOutcomeAudit, } from '@open-agent-toolkit/control-plane';
 import YAML, { isMap } from 'yaml';
 /**
  * The closeout invariant shared by `oat project closeout-check` and
@@ -12,6 +13,13 @@ import YAML, { isMap } from 'yaml';
  * persists. Once a snapshot exists it is authoritative: current configuration
  * is never consulted, so a later config change cannot invalidate a persisted
  * run.
+ *
+ * A goal project additionally passes the goal terminal boundary before either
+ * success return (`complete` or `not_required`): the terminal declaration, an
+ * exhaustive outcome audit validated by the control plane's single audit
+ * predicate, resolved extraction and delivery coverage over current
+ * observations. A complete snapshot cannot waive it, and every refusal names
+ * the actual next owner.
  */
 export const SEQUENCE_FIELD = 'oat_post_implement_sequence';
 export const RECOVERY_SKILL = 'oat-project-implement';
@@ -37,6 +45,392 @@ export const STEP_SKILLS = {
     pr: 'oat-project-pr-final',
     retro: 'oat-project-retro',
 };
+const GOAL_SKILL = 'oat-project-goal';
+const DELIVERY_SKILL = 'oat-project-pr-progress';
+const TERMINAL_DELIVERY_SKILL = 'oat-project-pr-final';
+const REVIEW_SKILL = 'oat-project-review-provide';
+/** The next owner for each refusal reason (A3 diagnostics). */
+const REASON_OWNERS = {
+    'plan-unreadable': GOAL_SKILL,
+    'journal-unreadable': GOAL_SKILL,
+    'registry-unreadable': DELIVERY_SKILL,
+    'not-declared': GOAL_SKILL,
+    'audit-invalid': GOAL_SKILL,
+    'extraction-target-mismatch': GOAL_SKILL,
+    'child-missing': GOAL_SKILL,
+    'child-backlink-mismatch': GOAL_SKILL,
+    'child-incomplete': GOAL_SKILL,
+    'child-deferral-under-met': GOAL_SKILL,
+    'member-unobserved': DELIVERY_SKILL,
+    'delivery-duplicate-id': DELIVERY_SKILL,
+    'delivery-self-link': DELIVERY_SKILL,
+    'delivery-missing-target': DELIVERY_SKILL,
+    'delivery-link-mismatch': DELIVERY_SKILL,
+    'delivery-conflicting-predecessor': DELIVERY_SKILL,
+    'delivery-source-not-superseded': DELIVERY_SKILL,
+    'delivery-missing-link': DELIVERY_SKILL,
+    'delivery-cycle': DELIVERY_SKILL,
+    'delivery-replaced-after-endpoint': DELIVERY_SKILL,
+    'correction-claims-inherited-scope': DELIVERY_SKILL,
+    'delivery-registering': DELIVERY_SKILL,
+    'terminal-scopes-overlap': DELIVERY_SKILL,
+    'endpoint-unmet': DELIVERY_SKILL,
+    'evidence-unevaluated': DELIVERY_SKILL,
+    'review-not-fresh': REVIEW_SKILL,
+    'exit-carrier-not-fresh': RECOVERY_SKILL,
+    'scope-claim-unknown': DELIVERY_SKILL,
+    'scope-claim-unaccepted': DELIVERY_SKILL,
+    'phase-uncovered': TERMINAL_DELIVERY_SKILL,
+};
+function goalReason(code, message, subject) {
+    return subject === undefined ? { code, message } : { code, message, subject };
+}
+/**
+ * Validate the supersession graph and resolve every replacement chain to its
+ * terminal delivery (A4). In v1.5 each replacement has at most one direct
+ * predecessor: `covers_scope_of` names it and the predecessor's
+ * `superseded_by` points back. Missing targets, self-links, cycles,
+ * conflicting predecessors, mismatched links, a non-superseded source and a
+ * replacement of a delivery that already reached its endpoint are refused.
+ * `corrects_delivery_id` is additive and inherits no coverage, so a
+ * correction may not claim its target's scope.
+ */
+export function resolveDeliveryGraph(deliveries, phaseOrder = []) {
+    const errors = [];
+    const byId = new Map();
+    for (const delivery of deliveries) {
+        if (byId.has(delivery.delivery_id)) {
+            errors.push(goalReason('delivery-duplicate-id', `delivery id ${delivery.delivery_id} is registered more than once`, delivery.delivery_id));
+            continue;
+        }
+        byId.set(delivery.delivery_id, delivery);
+    }
+    const replacedBy = new Map();
+    for (const delivery of byId.values()) {
+        const id = delivery.delivery_id;
+        const predecessorId = delivery.covers_scope_of;
+        if (predecessorId !== null) {
+            const predecessor = byId.get(predecessorId);
+            if (predecessorId === id) {
+                errors.push(goalReason('delivery-self-link', `${id} covers its own scope`, id));
+            }
+            else if (predecessor === undefined) {
+                errors.push(goalReason('delivery-missing-target', `${id} covers the scope of ${predecessorId}, which is not registered`, id));
+            }
+            else {
+                const existing = replacedBy.get(predecessorId);
+                if (existing !== undefined) {
+                    errors.push(goalReason('delivery-conflicting-predecessor', `${predecessorId} is replaced by both ${existing} and ${id}`, predecessorId));
+                }
+                else {
+                    replacedBy.set(predecessorId, id);
+                }
+                if (predecessor.superseded_by !== id) {
+                    errors.push(goalReason('delivery-link-mismatch', `${id} covers ${predecessorId}, but ${predecessorId} records superseded_by ${predecessor.superseded_by ?? 'null'}`, id));
+                }
+                if (predecessor.status !== 'superseded') {
+                    errors.push(goalReason('delivery-source-not-superseded', `${id} replaces ${predecessorId}, whose status is ${predecessor.status ?? 'unrecorded'}, not superseded`, predecessorId));
+                }
+                if (predecessor.endpoint_attainment !== null) {
+                    errors.push(goalReason('delivery-replaced-after-endpoint', `${predecessorId} already reached its agreed endpoint; later corrections are additive and may not replace it`, predecessorId));
+                }
+            }
+        }
+        const successorId = delivery.superseded_by;
+        if (successorId !== null) {
+            const successor = byId.get(successorId);
+            if (successorId === id) {
+                errors.push(goalReason('delivery-self-link', `${id} supersedes itself`, id));
+            }
+            else if (successor === undefined) {
+                errors.push(goalReason('delivery-missing-target', `${id} is superseded by ${successorId}, which is not registered`, id));
+            }
+            else if (successor.covers_scope_of !== id) {
+                errors.push(goalReason('delivery-link-mismatch', `${id} is superseded by ${successorId}, but ${successorId} covers ${successor.covers_scope_of ?? 'nothing'}`, id));
+            }
+        }
+        else if (delivery.status === 'superseded') {
+            errors.push(goalReason('delivery-missing-link', `${id} is superseded but names no replacement`, id));
+        }
+    }
+    // Cycles: follow each predecessor chain.
+    for (const delivery of byId.values()) {
+        const seen = new Set();
+        let current = delivery;
+        while (current !== undefined && current.covers_scope_of !== null) {
+            if (seen.has(current.delivery_id)) {
+                errors.push(goalReason('delivery-cycle', `the replacement chain through ${delivery.delivery_id} is a cycle`, delivery.delivery_id));
+                break;
+            }
+            seen.add(current.delivery_id);
+            current = byId.get(current.covers_scope_of);
+        }
+    }
+    if (errors.length > 0) {
+        return { terminals: [], errors: dedupe(errors) };
+    }
+    const order = new Map(phaseOrder.map((phaseId, index) => [phaseId, index]));
+    const rank = (phaseId) => order.get(phaseId) ?? order.size;
+    const terminals = [];
+    for (const delivery of byId.values()) {
+        if (delivery.status === 'superseded')
+            continue;
+        const scope = new Set(delivery.scope);
+        const inherits = [];
+        let predecessorId = delivery.covers_scope_of;
+        while (predecessorId !== null) {
+            const predecessor = byId.get(predecessorId);
+            inherits.push(predecessorId);
+            for (const phaseId of predecessor.scope)
+                scope.add(phaseId);
+            predecessorId = predecessor.covers_scope_of;
+        }
+        terminals.push({
+            delivery,
+            effectiveScope: [...scope].sort((left, right) => rank(left) - rank(right)),
+            inherits,
+        });
+    }
+    for (const delivery of byId.values()) {
+        const targetId = delivery.corrects_delivery_id;
+        if (targetId === null)
+            continue;
+        const target = byId.get(targetId);
+        if (targetId === delivery.delivery_id) {
+            errors.push(goalReason('delivery-self-link', `${delivery.delivery_id} corrects itself`, delivery.delivery_id));
+            continue;
+        }
+        if (target === undefined) {
+            errors.push(goalReason('delivery-missing-target', `${delivery.delivery_id} corrects ${targetId}, which is not registered`, delivery.delivery_id));
+            continue;
+        }
+        const targetScope = new Set(target.scope);
+        for (const terminal of terminals) {
+            if (terminal.delivery.delivery_id === targetId ||
+                terminal.inherits.includes(targetId)) {
+                for (const phaseId of terminal.effectiveScope)
+                    targetScope.add(phaseId);
+            }
+        }
+        const claimed = delivery.scope.filter((phaseId) => targetScope.has(phaseId));
+        if (claimed.length > 0) {
+            errors.push(goalReason('correction-claims-inherited-scope', `${delivery.delivery_id} is an additive correction of ${targetId} but claims its scope (${claimed.join(', ')}); corrections use new phase ids`, delivery.delivery_id));
+        }
+    }
+    return { terminals: errors.length > 0 ? [] : terminals, errors };
+}
+function dedupe(reasons) {
+    const seen = new Set();
+    return reasons.filter((entry) => {
+        const key = `${entry.code}:${entry.subject ?? ''}:${entry.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function sameMembers(left, right) {
+    return (left.length === right.length &&
+        [...left].sort().join(',') === [...right].sort().join(','));
+}
+/** Endpoint satisfaction on observed member state (design "Endpoint satisfaction"). */
+function endpointObserved(delivery) {
+    const { endpoint, members } = delivery;
+    if (members.length === 0 || endpoint === null)
+        return false;
+    return endpoint === 'merged'
+        ? members.every((member) => member.status === 'merged')
+        : members.every((member) => member.status === 'open' || member.status === 'merged');
+}
+/**
+ * The goal delivery coverage predicate (A4), over current observations:
+ * no registering entries; a valid supersession graph whose terminal
+ * deliveries have disjoint effective scopes; every terminal delivery at its
+ * agreed endpoint with a passed, fresh integrated review and an allowed,
+ * fresh exit-gate result evaluated against its entire effective scope; and
+ * every audited-accepted phase in exactly one terminal effective scope, with
+ * no claim of an unknown or unaccepted phase.
+ */
+export function evaluateGoalCoverage(input) {
+    const reasons = [];
+    for (const delivery of input.deliveries) {
+        if (delivery.status === 'registering') {
+            reasons.push(goalReason('delivery-registering', `${delivery.delivery_id} is still registering; resume its idempotent registration`, delivery.delivery_id));
+        }
+    }
+    const graph = resolveDeliveryGraph(input.deliveries, input.phaseOrder);
+    if (graph.errors.length > 0) {
+        return [...reasons, ...graph.errors];
+    }
+    const owners = new Map();
+    const known = new Set(input.phaseOrder);
+    for (const terminal of graph.terminals) {
+        const id = terminal.delivery.delivery_id;
+        if (terminal.delivery.status === 'registering')
+            continue;
+        for (const phaseId of terminal.effectiveScope) {
+            const owner = owners.get(phaseId);
+            if (owner !== undefined) {
+                reasons.push(goalReason('terminal-scopes-overlap', `${phaseId} is in the effective scope of both ${owner} and ${id}`, phaseId));
+            }
+            else {
+                owners.set(phaseId, id);
+            }
+            if (!known.has(phaseId)) {
+                reasons.push(goalReason('scope-claim-unknown', `${id} claims ${phaseId}, which the brief does not declare`, phaseId));
+            }
+            else if (!input.acceptedPhases.has(phaseId)) {
+                reasons.push(goalReason('scope-claim-unaccepted', `${id} claims ${phaseId}, which the audit does not record as accepted`, phaseId));
+            }
+        }
+        if (!endpointObserved(terminal.delivery)) {
+            reasons.push(goalReason('endpoint-unmet', `${id} is not observed at its agreed endpoint (${terminal.delivery.endpoint ?? 'unrecorded'})`, id));
+        }
+        const fact = input.evidence[id];
+        if (fact === undefined ||
+            !sameMembers(fact.scope, terminal.effectiveScope)) {
+            reasons.push(goalReason('evidence-unevaluated', `${id}'s evidence was not evaluated against its effective scope (${terminal.effectiveScope.join(', ')})`, id));
+            continue;
+        }
+        if (!fact.review.fresh || fact.review.disposition !== 'passed') {
+            reasons.push(goalReason('review-not-fresh', `${id} has no passed, fresh integrated review over ${terminal.effectiveScope.join(', ')}: ${fact.review.reason ?? `disposition ${fact.review.disposition ?? 'unrecorded'}`}`, id));
+        }
+        if (fact.exit.outcome !== 'allowed' || fact.exit.freshness !== 'fresh') {
+            reasons.push(goalReason('exit-carrier-not-fresh', `${id}'s exit-gate result is ${fact.exit.outcome}, ${fact.exit.freshness}${fact.exit.reason ? `: ${fact.exit.reason}` : ''}`, id));
+        }
+    }
+    for (const phaseId of input.phaseOrder) {
+        if (input.acceptedPhases.has(phaseId) && !owners.has(phaseId)) {
+            reasons.push(goalReason('phase-uncovered', `accepted phase ${phaseId} is in no terminal delivery's effective scope`, phaseId));
+        }
+    }
+    return reasons;
+}
+/**
+ * The goal terminal boundary (A3, A4): declaration, an exhaustive audit
+ * validated through the single audit predicate, resolved extraction, member
+ * observation and delivery coverage, in that order. Returns null when every
+ * check holds. Pure: every input arrives as data.
+ */
+export function evaluateGoalBoundary(frontmatter, goal) {
+    if (goal === undefined) {
+        return {
+            invariant: 'goal_inputs_unreadable',
+            reasons: [
+                goalReason('registry-unreadable', 'the goal boundary inputs were not loaded'),
+            ],
+        };
+    }
+    const unreadable = [];
+    if (goal.planContent === null) {
+        unreadable.push(goalReason('plan-unreadable', 'plan.md could not be read'));
+    }
+    if (goal.implementationContent === null) {
+        unreadable.push(goalReason('journal-unreadable', 'implementation.md could not be read'));
+    }
+    if (goal.deliveries === null) {
+        unreadable.push(goalReason('registry-unreadable', 'the delivery registry could not be read'));
+    }
+    if (unreadable.length > 0 ||
+        goal.planContent === null ||
+        goal.implementationContent === null ||
+        goal.deliveries === null) {
+        return { invariant: 'goal_inputs_unreadable', reasons: unreadable };
+    }
+    if (frontmatter.oat_goal_status !== 'declared_met') {
+        return {
+            invariant: 'goal_not_declared',
+            reasons: [
+                goalReason('not-declared', '`oat_goal_status` is not `declared_met`; only oat-project-goal records the terminal declaration'),
+            ],
+        };
+    }
+    const inventory = parseTaskProgress(goal.planContent, goal.implementationContent, { phaseUnits: true, extractedUnits: true }).phases;
+    const validation = validateGoalOutcomeAudit(frontmatter.oat_goal_outcome_audit, inventory, parseBriefOutcomes(goal.planContent));
+    if (!validation.valid || validation.audit === null) {
+        return {
+            invariant: 'goal_audit_invalid',
+            reasons: validation.errors.map((error) => goalReason('audit-invalid', `${error.code}: ${error.message}`, error.subject)),
+        };
+    }
+    const extraction = evaluateExtraction(goal, goal.planContent, inventory, validation.audit);
+    if (extraction.length > 0) {
+        return { invariant: 'goal_extraction_unresolved', reasons: extraction };
+    }
+    if (goal.observationFailures.length > 0) {
+        return {
+            invariant: 'goal_observation_failed',
+            reasons: goal.observationFailures.map((failure) => goalReason('member-unobserved', `${failure}; failure to observe a member is not endpoint success`)),
+        };
+    }
+    const acceptedPhases = new Set(Object.entries(validation.audit.phases)
+        .filter(([, entry]) => entry.disposition === 'accepted')
+        .map(([phaseId]) => phaseId));
+    const coverage = evaluateGoalCoverage({
+        deliveries: goal.deliveries,
+        phaseOrder: inventory.map((phase) => phase.phaseId),
+        acceptedPhases,
+        evidence: goal.evidence,
+    });
+    return coverage.length > 0
+        ? { invariant: 'goal_coverage_incomplete', reasons: coverage }
+        : null;
+}
+/**
+ * Every extracted phase needs matching plan and journal targets and a child
+ * carrying the matching `oat_extracted_from` backlink that is complete, or
+ * whose outstanding obligation the audit defers with a reason and scope
+ * decision under `met_with_deferrals`.
+ */
+function evaluateExtraction(goal, planContent, inventory, audit) {
+    const reasons = [];
+    const planMarkers = parsePhaseMarkers(planContent);
+    for (const phase of inventory) {
+        const planTarget = planMarkers.get(phase.phaseId)?.extractedTo ?? null;
+        const journalTarget = phase.extracted?.to ?? null;
+        if (planTarget !== journalTarget) {
+            reasons.push(goalReason('extraction-target-mismatch', `${phase.phaseId}: the brief names ${planTarget ?? 'no extraction target'} but the journal names ${journalTarget ?? 'none'}`, phase.phaseId));
+            continue;
+        }
+        if (journalTarget === null)
+            continue;
+        const child = goal.children.find((entry) => entry.slug === journalTarget);
+        if (child === undefined || child.status !== 'found') {
+            reasons.push(goalReason('child-missing', `${phase.phaseId} is extracted to ${journalTarget}, but that child project is ${child?.status ?? 'missing'}`, phase.phaseId));
+            continue;
+        }
+        if (child.extractedFrom !== goal.goalSlug) {
+            reasons.push(goalReason('child-backlink-mismatch', `${journalTarget} records oat_extracted_from ${child.extractedFrom ?? 'null'}, not ${goal.goalSlug}`, phase.phaseId));
+            continue;
+        }
+        if (child.lifecycle === 'complete')
+            continue;
+        const entry = audit.phases[phase.phaseId];
+        const deferred = entry !== undefined &&
+            (entry.reason ?? '').trim() !== '' &&
+            (entry.scope_decision_ref ?? '').trim() !== '';
+        if (!deferred) {
+            reasons.push(goalReason('child-incomplete', `${journalTarget} is ${child.lifecycle ?? 'not complete'} and the audit records no approved deferral (reason and scope_decision_ref) for ${phase.phaseId}`, phase.phaseId));
+        }
+        else if (audit.disposition === 'met') {
+            reasons.push(goalReason('child-deferral-under-met', `${phase.phaseId}'s child obligation is deferred, so the audit must be met_with_deferrals`, phase.phaseId));
+        }
+    }
+    return reasons;
+}
+function goalRefusal(verdict, inputs) {
+    const skill = REASON_OWNERS[verdict.reasons[0]?.code ?? 'registry-unreadable'];
+    return {
+        status: 'incomplete',
+        invariant: verdict.invariant,
+        detail: `the goal closeout boundary refuses: ${verdict.reasons
+            .map((entry) => `${entry.code} (${entry.message})`)
+            .join('; ')}`,
+        route: skill,
+        nextOwner: { kind: 'goal', skill, reasons: verdict.reasons },
+        inputs,
+    };
+}
 class MalformedSnapshotError extends Error {
 }
 function malformed(detail) {
@@ -57,6 +451,16 @@ function readFrontmatter(content) {
     const value = document.toJS();
     return value;
 }
+/** The state's `oat_workflow_mode`, or null when the frontmatter cannot be read. */
+export function readStateWorkflowMode(stateContent) {
+    try {
+        const mode = readFrontmatter(stateContent).oat_workflow_mode;
+        return typeof mode === 'string' ? mode : null;
+    }
+    catch {
+        return null;
+    }
+}
 function readEnum(record, key, allowed, options = {}) {
     if (!(key in record)) {
         if (options.optional)
@@ -104,7 +508,40 @@ function assertCompletedPrefix(stored, completed, storedKey, completedKey) {
         malformed(`\`${completedKey}\` is not a prefix of the stored \`${storedKey}\` order`);
     }
 }
-export function parseCloseoutSnapshot(value) {
+const SATISFIED_BY_VALUES = ['delivery-coverage'];
+/**
+ * Goal only: `satisfied_by` records a step completed by delivery coverage.
+ * Only the `pr` step may be satisfied that way, and only once execution of
+ * the stored order reached it, so the record must name a completed step.
+ */
+function readSatisfiedBy(record, workflowMode, completed) {
+    if (!('satisfied_by' in record) || record.satisfied_by === null) {
+        return {};
+    }
+    const value = record.satisfied_by;
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        malformed('`satisfied_by` must be a map of step to `delivery-coverage`');
+    }
+    if (workflowMode !== 'goal') {
+        malformed('`satisfied_by` is recorded only by a goal closeout');
+    }
+    const satisfiedBy = {};
+    for (const [step, source] of Object.entries(value)) {
+        if (step !== 'pr') {
+            malformed(`\`satisfied_by\` names \`${step}\`; only the \`pr\` step is satisfied by delivery coverage`);
+        }
+        if (typeof source !== 'string' ||
+            !SATISFIED_BY_VALUES.includes(source)) {
+            malformed('`satisfied_by.pr` must be `delivery-coverage`');
+        }
+        if (!completed.includes('pr')) {
+            malformed("`satisfied_by.pr` is recorded before the `pr` step's position in the stored order was reached");
+        }
+        satisfiedBy.pr = 'delivery-coverage';
+    }
+    return satisfiedBy;
+}
+export function parseCloseoutSnapshot(value, workflowMode = null) {
     if (value === null || typeof value !== 'object' || Array.isArray(value)) {
         malformed('the snapshot must be a map');
     }
@@ -148,6 +585,10 @@ export function parseCloseoutSnapshot(value) {
         approval,
         postApproval,
         postApprovalCompleted,
+        satisfiedBy: readSatisfiedBy(record, workflowMode, [
+            ...preApprovalCompleted,
+            ...postApprovalCompleted,
+        ]),
         failure: record.failure ?? null,
     };
     if (status === 'complete') {
@@ -234,10 +675,18 @@ export async function evaluateCloseout(options) {
         snapshot: snapshotPresent ? 'present' : 'absent',
         snapshotSource: null,
     };
+    // Goal: declaration, an exhaustive audit and delivery coverage are required
+    // before either success return; a complete snapshot cannot waive them.
+    if (workflowMode === 'goal') {
+        const verdict = evaluateGoalBoundary(frontmatter, options.goal);
+        if (verdict !== null) {
+            return goalRefusal(verdict, inputs);
+        }
+    }
     if (snapshotPresent) {
         let snapshot;
         try {
-            snapshot = parseCloseoutSnapshot(rawSnapshot);
+            snapshot = parseCloseoutSnapshot(rawSnapshot, workflowMode);
         }
         catch (error) {
             if (!(error instanceof MalformedSnapshotError))
@@ -289,6 +738,9 @@ export async function evaluateCloseout(options) {
  */
 export function formatCloseoutRefusal(projectPath, result) {
     const owner = result.nextOwner;
+    if (owner.kind === 'goal') {
+        return `Closeout invariant not satisfied for ${projectPath} (${result.invariant}): ${result.detail}. Resume with ${owner.skill}.`;
+    }
     const next = owner.kind === 'step'
         ? ` Next stored step: \`${owner.step}\` (${owner.skill}).`
         : owner.kind === 'approval'

package/dist/commands/project/closeout-check/index.d.ts

@@ -1,10 +1,13 @@
 import { readFile as defaultReadFile } from 'node:fs/promises';
 import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type GhRunner } from '../../project/links/refresh.js';
+import { type GitRunner } from '../../project/sync/git.js';
 import { resolveEffectiveConfig } from '../../../config/resolve.js';
 import { dirExists, fileExists } from '../../../fs/io.js';
+import { type ProjectState } from '@open-agent-toolkit/control-plane';
 import { Command } from 'commander';
-import { type CloseoutResult } from './closeout-invariant.js';
-export { evaluateCloseout, formatCloseoutRefusal, type CloseoutResult, } from './closeout-invariant.js';
+import { type CloseoutResult, type GoalCloseoutInputs } from './closeout-invariant.js';
+export { evaluateCloseout, evaluateGoalBoundary, evaluateGoalCoverage, formatCloseoutRefusal, resolveDeliveryGraph, type CloseoutResult, type DeliveryEvidenceFact, type ExtractedChildFact, type GoalCloseoutInputs, } from './closeout-invariant.js';
 export interface CloseoutCheckDependencies {
     buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
     resolveProjectRoot: (cwd: string) => Promise<string>;
@@ -17,8 +20,23 @@ export interface CloseoutCheckDependencies {
      * `--autonomous` under `OAT_AUTONOMOUS=1` still cannot fail open.
      */
     env: NodeJS.ProcessEnv;
+    /** Goal only: read-only member observation (`gh pr view`). */
+    gh: GhRunner;
+    /** Goal only: read-only Git inspection for the shared evidence evaluator. */
+    git: GitRunner;
+    getProjectState: (projectPath: string) => Promise<ProjectState>;
+    listDirectories: (path: string) => Promise<string[]>;
 }
 export declare const DEFAULT_CLOSEOUT_CHECK_DEPENDENCIES: CloseoutCheckDependencies;
+/** The dependencies `checkProjectCloseout` reads through. */
+export type CloseoutInputDependencies = Pick<CloseoutCheckDependencies, 'resolveProjectRoot' | 'resolveEffectiveConfig' | 'readFile' | 'dirExists' | 'fileExists' | 'env' | 'gh' | 'git' | 'getProjectState' | 'listDirectories'>;
+/**
+ * Load the goal boundary inputs read-only (A3): the brief, the journal, the
+ * registry with fresh member observations merged in (never persisted; that is
+ * `delivery refresh`'s job), each extracted child's facts, and the shared
+ * evaluator's verdict for every terminal delivery's effective scope.
+ */
+export declare function loadGoalCloseoutInputs(repoRoot: string, targetProjectPath: string, dependencies: CloseoutInputDependencies): Promise<GoalCloseoutInputs>;
 export interface ProjectCloseoutCheck {
     repoRoot: string;
     targetProjectPath: string;
@@ -33,6 +51,6 @@ export interface ProjectCloseoutCheck {
  */
 export declare function checkProjectCloseout(projectPath: string, options: {
     autonomous: boolean;
-}, context: CommandContext, dependencies: Pick<CloseoutCheckDependencies, 'resolveProjectRoot' | 'resolveEffectiveConfig' | 'readFile' | 'dirExists' | 'fileExists' | 'env'>): Promise<ProjectCloseoutCheck>;
+}, context: CommandContext, dependencies: CloseoutInputDependencies): Promise<ProjectCloseoutCheck>;
 export declare function createProjectCloseoutCheckCommand(overrides?: Partial<CloseoutCheckDependencies>): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/project/closeout-check/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/closeout-check/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAG/D,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,yBAAyB;IACxC,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,mCAAmC,EAAE,yBAQjD,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,EAChC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,IAAI,CAChB,yBAAyB,EACvB,oBAAoB,GACpB,wBAAwB,GACxB,UAAU,GACV,WAAW,GACX,YAAY,GACZ,KAAK,CACR,GACA,OAAO,CAAC,oBAAoB,CAAC,CA+B/B;AAmED,wBAAgB,iCAAiC,CAC/C,SAAS,GAAE,OAAO,CAAC,yBAAyB,CAAM,GACjD,OAAO,CA2BT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/closeout-check/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAW,MAAM,kBAAkB,CAAC;AAGxE,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAQhF,OAAO,EAEL,KAAK,QAAQ,EACd,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAKL,KAAK,cAAc,EAGnB,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,yBAAyB;IACxC,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;IACtD,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,8DAA8D;IAC9D,EAAE,EAAE,QAAQ,CAAC;IACb,6EAA6E;IAC7E,GAAG,EAAE,SAAS,CAAC;IACf,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAChE,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACtD;AASD,eAAO,MAAM,mCAAmC,EAAE,yBAYjD,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,yBAAyB,EACvB,oBAAoB,GACpB,wBAAwB,GACxB,UAAU,GACV,WAAW,GACX,YAAY,GACZ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,iBAAiB,GACjB,iBAAiB,CACpB,CAAC;AA4EF;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,yBAAyB,GACtC,OAAO,CAAC,kBAAkB,CAAC,CAuH7B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,EAChC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,yBAAyB,GACtC,OAAO,CAAC,oBAAoB,CAAC,CAoC/B;AAmED,wBAAgB,iCAAiC,CAC/C,SAAS,GAAE,OAAO,CAAC,yBAAyB,CAAM,GACjD,OAAO,CA2BT"}