@openapi-flow/core 0.2.0 → 0.3.0

package/dist/draft/impact/analyze-draft-change-impact.js

@@ -0,0 +1,92 @@
+import { isDeepStrictEqual } from 'node:util';
+import { validateWorkflowDraft } from '../validate-workflow-draft.js';
+import { createWorkflowDraft } from '../create-workflow-draft.js';
+import { workflowDraftDependencies } from './workflow-draft-dependencies.js';
+import { draftEdgeKey } from '../changes/draft-edge-key.js';
+export function analyzeDraftChangeImpact(input) {
+    validateWorkflowDraft({ draft: input.before, context: input.context });
+    const after = createWorkflowDraft({
+        content: input.after,
+        context: input.context,
+    });
+    if (input.before.id !== after.id)
+        throw new Error('Draft changes cannot replace the workflow identity');
+    const beforeNodes = draftNodes(input.before);
+    const afterNodes = draftNodes(after);
+    const allIds = new Set([...beforeNodes.keys(), ...afterNodes.keys()]);
+    const changedNodeIds = [...allIds].filter((id) => !isDeepStrictEqual(beforeNodes.get(id), afterNodes.get(id)));
+    const affected = new Set(changedNodeIds);
+    const propagated = new Set(changedNodeIds);
+    const beforeEdges = new Set(input.before.edges.map(draftEdgeKey));
+    const afterEdges = new Set(after.edges.map(draftEdgeKey));
+    for (const edge of [...input.before.edges, ...after.edges])
+        if (beforeEdges.has(draftEdgeKey(edge)) !== afterEdges.has(draftEdgeKey(edge))) {
+            affected.add(edge.from);
+            affected.add(edge.to);
+            // A new consumer changes its own incoming route, not existing sibling
+            // consumers of an unchanged producer. Review the producer's new wire,
+            // but propagate only from the changed input endpoint.
+            propagated.add(edge.to);
+        }
+    const oldRequirements = new Map(input.before.requirements.map((item) => [item.id, item]));
+    const newRequirements = new Map(after.requirements.map((item) => [item.id, item]));
+    const changedRequirementIds = [
+        ...new Set([...oldRequirements.keys(), ...newRequirements.keys()]),
+    ].filter((id) => !isDeepStrictEqual(oldRequirements.get(id), newRequirements.get(id)));
+    for (const id of changedRequirementIds)
+        for (const requirement of [
+            oldRequirements.get(id),
+            newRequirements.get(id),
+        ]) {
+            if (!requirement)
+                continue;
+            for (const nodeId of requirement.scope.kind === 'workflow'
+                ? allIds
+                : requirement.scope.nodeIds) {
+                affected.add(nodeId);
+                propagated.add(nodeId);
+            }
+        }
+    const beforeDependencies = workflowDraftDependencies({
+        draft: input.before,
+        context: input.context,
+    });
+    const afterDependencies = workflowDraftDependencies({
+        draft: after,
+        context: input.context,
+    });
+    let expanded;
+    do {
+        expanded = false;
+        for (const [id, dependencies] of [
+            ...beforeDependencies,
+            ...afterDependencies,
+        ])
+            if (!propagated.has(id) &&
+                [...dependencies].some((dependency) => propagated.has(dependency))) {
+                affected.add(id);
+                propagated.add(id);
+                expanded = true;
+            }
+    } while (expanded);
+    return {
+        changedNodeIds,
+        addedNodeIds: [...afterNodes.keys()].filter((id) => !beforeNodes.has(id)),
+        removedNodeIds: [...beforeNodes.keys()].filter((id) => !afterNodes.has(id)),
+        affectedNodeIds: [...affected],
+        preservedNodeIds: [...afterNodes.keys()].filter((id) => !affected.has(id)),
+        changedRequirementIds,
+        invalidatedApprovalIds: input.before.approvals
+            .filter((approval) => approval.nodeIds.some((id) => affected.has(id) && !approval.invalidatedNodeIds.includes(id)))
+            .map((approval) => approval.id),
+    };
+}
+function draftNodes(draft) {
+    return new Map([
+        ...draft.apiCalls.map((call) => [call.id, call]),
+        ...draft.nativeNodes.map((node) => [node.id, node]),
+        ...(draft.gapNodes === undefined
+            ? []
+            : draft.gapNodes.map((node) => [node.id, node])),
+    ]);
+}

package/dist/draft/impact/workflow-draft-dependencies.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftInput } from '../../types/workflow-draft.js';
+export declare function workflowDraftDependencies(input: WorkflowDraftInput): Map<string, Set<string>>;
+export declare function transitiveDraftDependencies(nodeId: string, dependencies: Map<string, Set<string>>): string[];

package/dist/draft/impact/workflow-draft-dependencies.js

@@ -0,0 +1,38 @@
+import { resolveWorkflowDraftNodeContracts } from '../contracts/resolve-workflow-draft-node-contracts.js';
+export function workflowDraftDependencies(input) {
+    const contracts = resolveWorkflowDraftNodeContracts(input);
+    return new Map(contracts.map((contract) => [
+        contract.id,
+        new Set([
+            ...input.draft.edges
+                .filter((edge) => edge.to === contract.id)
+                .map((edge) => edge.from),
+            ...contract.references.map((reference) => reference.nodeId),
+            ...Object.values(contract.inputReferences ?? {})
+                .flat()
+                .map((reference) => reference.nodeId),
+            ...contract.dependencyNodeIds,
+            ...(contract.rejoinsExclusiveOutputs === undefined
+                ? []
+                : [contract.rejoinsExclusiveOutputs]),
+        ]),
+    ]));
+}
+export function transitiveDraftDependencies(nodeId, dependencies) {
+    const seen = new Set();
+    const pending = [...requiredDependencies(nodeId, dependencies)];
+    while (pending.length) {
+        const id = pending.shift();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        pending.push(...requiredDependencies(id, dependencies));
+    }
+    return [...seen];
+}
+function requiredDependencies(nodeId, dependencies) {
+    const found = dependencies.get(nodeId);
+    if (!found)
+        throw new Error(`Draft dependencies do not declare node ${nodeId}`);
+    return found;
+}

package/dist/draft/inspect-draft-readiness.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDraftInput, WorkflowDraftReadiness } from '../types/workflow-draft.js';
+export declare function inspectDraftReadiness(input: WorkflowDraftInput): WorkflowDraftReadiness;

package/dist/draft/inspect-draft-readiness.js

@@ -0,0 +1,66 @@
+import { validateWorkflowDraft } from './validate-workflow-draft.js';
+import { resolveWorkflowDraftMaterials } from './resolve-workflow-draft-materials.js';
+import { workflowDraftDependencies, transitiveDraftDependencies, } from './impact/workflow-draft-dependencies.js';
+export function inspectDraftReadiness(input) {
+    validateWorkflowDraft(input);
+    const { slots: apiSlots, nativeSlots } = resolveWorkflowDraftMaterials(input);
+    const slots = [...apiSlots, ...nativeSlots];
+    const dependencies = workflowDraftDependencies(input);
+    const nodes = [...dependencies.keys()].map((nodeId) => {
+        const upstream = transitiveDraftDependencies(nodeId, dependencies);
+        const scope = new Set([nodeId, ...upstream]);
+        const blockingGapNodeIds = (input.draft.gapNodes === undefined ? [] : input.draft.gapNodes)
+            .filter((gap) => scope.has(gap.id))
+            .map((gap) => gap.id);
+        const unresolvedRequirementIds = input.draft.requirements
+            .filter((requirement) => requirement.state !== 'confirmed' &&
+            (requirement.scope.kind === 'workflow' ||
+                requirement.scope.nodeIds.some((id) => scope.has(id))))
+            .map((requirement) => requirement.id);
+        const inputSlotIds = slots
+            .filter((slot) => scope.has(slot.kind === 'api-request-input' ? slot.callId : slot.nodeId))
+            .map((slot) => slot.id);
+        const requestSlots = apiSlots.filter((slot) => scope.has(slot.callId));
+        const blocked = unresolvedRequirementIds.length > 0;
+        return {
+            nodeId,
+            planningStatus: blocked
+                ? 'blocked-by-decision'
+                : blockingGapNodeIds.length
+                    ? 'blocked-by-capability'
+                    : 'ready',
+            requestInputStatus: blocked
+                ? 'blocked-by-decision'
+                : blockingGapNodeIds.length
+                    ? 'blocked-by-capability'
+                    : requestSlots.length
+                        ? 'needs-input'
+                        : 'ready',
+            runtimeInputStatus: blocked
+                ? 'blocked-by-decision'
+                : blockingGapNodeIds.length
+                    ? 'blocked-by-capability'
+                    : inputSlotIds.length
+                        ? 'needs-input'
+                        : 'ready',
+            unresolvedRequirementIds,
+            inputSlotIds,
+            dependencyNodeIds: upstream,
+            ...(blockingGapNodeIds.length ? { blockingGapNodeIds } : {}),
+            reviewed: input.draft.approvals.some((approval) => approval.nodeIds.includes(nodeId) &&
+                !approval.invalidatedNodeIds.includes(nodeId)),
+        };
+    });
+    return {
+        designReady: nodes.length > 0 &&
+            nodes.every((node) => node.planningStatus === 'ready'),
+        requestInputsReady: nodes.length > 0 &&
+            nodes.every((node) => node.requestInputStatus === 'ready'),
+        nativeInputsReady: nodes.length > 0 && nativeSlots.length === 0,
+        runtimeInputsReady: nodes.length > 0 &&
+            nodes.every((node) => node.runtimeInputStatus === 'ready'),
+        reviewed: nodes.length > 0 && nodes.every((node) => node.reviewed),
+        nodes,
+        slots,
+    };
+}

package/dist/draft/requirements/create-workflow-draft-edit-candidate-context.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftContext } from '../../types/workflow-draft.js';
+import type { WorkflowDraftEditCandidateContextInput, WorkflowDraftEditCandidateContext } from '../../types/workflow-draft-requirement-history.js';
+/** Explicit typed human answers are audit evidence, never new semantic-plan or model-output authority. */
+export declare function createWorkflowDraftEditCandidateContext<Context extends WorkflowDraftContext>(input: WorkflowDraftEditCandidateContextInput<Context>): WorkflowDraftEditCandidateContext<Context>;

package/dist/draft/requirements/create-workflow-draft-edit-candidate-context.js

@@ -0,0 +1,55 @@
+import { isDeepStrictEqual } from 'node:util';
+import { workflowDraftEditResolutionSchema } from '../../schemas/workflow-draft-edit-assembly-schema.js';
+import { validateWorkflowDraftEditPlan } from '../edits/validate-workflow-draft-edit-plan.js';
+import { resolveWorkflowPlanningMessages } from '../../planning/evidence/resolve-workflow-planning-messages.js';
+import { describeWorkflowDraftRequirementEdit } from './describe-workflow-draft-requirement-edit.js';
+import { createWorkflowDraftRequirementAnswerSchema } from '../../schemas/create-workflow-draft-requirement-answer-schema.js';
+/** Explicit typed human answers are audit evidence, never new semantic-plan or model-output authority. */
+export function createWorkflowDraftEditCandidateContext(input) {
+    validateWorkflowDraftEditPlan(input);
+    const resolutions = workflowDraftEditResolutionSchema
+        .array()
+        .parse(input.resolutions);
+    const messages = structuredClone(input.context.messages);
+    const answerIds = new Set();
+    for (const resolution of resolutions) {
+        if (resolution.kind !== 'requirement')
+            continue;
+        const step = input.plan.steps.find((entry) => entry.id === resolution.stepId);
+        if (!step ||
+            (step.decision.kind !== 'revise-requirement' &&
+                step.decision.kind !== 'restore-requirement'))
+            throw new Error(`Requirement answer ${resolution.stepId} must name a selected revise-requirement or restore-requirement step`);
+        if (answerIds.has(resolution.answerMessageId))
+            throw new Error(`Requirement answer message ID is repeated: ${resolution.answerMessageId}`);
+        createWorkflowDraftRequirementAnswerSchema(describeWorkflowDraftRequirementEdit({ ...input, stepId: step.id })).parse({
+            answerMessageId: resolution.answerMessageId,
+            text: resolution.text,
+            state: resolution.state,
+            scope: resolution.scope,
+        });
+        answerIds.add(resolution.answerMessageId);
+        const message = {
+            id: resolution.answerMessageId,
+            text: JSON.stringify({
+                kind: 'typed-requirement-answer',
+                stepId: resolution.stepId,
+                requirement: {
+                    text: resolution.text,
+                    state: resolution.state,
+                    scope: resolution.scope,
+                },
+            }),
+        };
+        const existing = messages.find((entry) => entry.id === message.id);
+        if (existing && !isDeepStrictEqual(existing, message))
+            throw new Error(`Requirement answer message ID conflicts with declared evidence: ${message.id}`);
+        if (!existing)
+            messages.push(message);
+    }
+    return {
+        ...input.context,
+        messages,
+        planningMessageIds: resolveWorkflowPlanningMessages(input.context).map((message) => message.id),
+    };
+}

package/dist/draft/requirements/describe-workflow-draft-clarification-scopes.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftClarificationScopeInput, WorkflowDraftClarificationScopeDescription } from '../../types/workflow-draft-clarification.js';
+/** Facts and question states are code-owned; the remaining choice is their actual semantic scope. */
+export declare function describeWorkflowDraftClarificationScopes(input: WorkflowDraftClarificationScopeInput): WorkflowDraftClarificationScopeDescription;

package/dist/draft/requirements/describe-workflow-draft-clarification-scopes.js

@@ -0,0 +1,67 @@
+import { createHash } from 'node:crypto';
+import { describeWorkflowDraftEditContext } from '../edits/describe-workflow-draft-edit-context.js';
+import { validateWorkflowDraftEditPlan } from '../edits/validate-workflow-draft-edit-plan.js';
+import { describeWorkflowDraftSelectedNodes } from '../edits/describe-workflow-draft-selected-nodes.js';
+/** Facts and question states are code-owned; the remaining choice is their actual semantic scope. */
+export function describeWorkflowDraftClarificationScopes(input) {
+    validateWorkflowDraftEditPlan(input);
+    const described = describeWorkflowDraftEditContext(input);
+    const active = input.context.clarification;
+    const clarification = described.planning.clarification;
+    const requirements = [];
+    if (active && clarification && input.plan.status !== 'no-change') {
+        for (const fact of clarification.facts) {
+            const sourceMessageIds = [
+                ...new Set(fact.sources.map((source) => {
+                    if (source.kind === 'message')
+                        return source.messageId;
+                    const index = active.resolution.replies.findIndex((reply) => reply.questionId === source.questionId);
+                    if (index < 0 || !active.answerMessages[index])
+                        throw new Error(`Clarified fact ${fact.id} requires its original reply evidence`);
+                    return active.answerMessages[index].id;
+                })),
+            ];
+            requirements.push({
+                id: `requirement:${fact.id}`,
+                text: fact.text,
+                state: 'confirmed',
+                sourceMessageIds,
+                origin: {
+                    kind: 'clarification-fact',
+                    roundId: clarification.roundId,
+                    sourceId: fact.id,
+                },
+            });
+        }
+        for (const question of [
+            ...clarification.pendingQuestions,
+            ...clarification.deferredQuestions,
+        ])
+            requirements.push({
+                id: `requirement:${question.id}`,
+                text: question.message,
+                state: active.resolution.deferredQuestionIds.includes(question.id)
+                    ? 'deferred'
+                    : 'needs-clarification',
+                sourceMessageIds: active.round.sourceMessages.map((message) => message.id),
+                origin: {
+                    kind: 'clarification-question',
+                    roundId: clarification.roundId,
+                    sourceId: question.id,
+                },
+            });
+    }
+    const nodes = describeWorkflowDraftSelectedNodes(input);
+    const fields = {
+        requirements,
+        nodes,
+        messages: described.planning.messages.filter((message) => described.requestMessageIds.includes(message.id)),
+        includeExplanations: input.plan.options.includeExplanations,
+    };
+    return {
+        fingerprint: createHash('sha256')
+            .update(JSON.stringify([input.plan.id, described.contextFingerprint, fields]))
+            .digest('hex'),
+        ...fields,
+    };
+}

package/dist/draft/requirements/describe-workflow-draft-requirement-edit.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftRequirementEditInput, WorkflowDraftRequirementEditDescription } from '../../types/workflow-draft-requirement-edit.js';
+/** Typed human answers choose a real final identity, without requiring its executable material. */
+export declare function describeWorkflowDraftRequirementEdit(input: WorkflowDraftRequirementEditInput): WorkflowDraftRequirementEditDescription;

package/dist/draft/requirements/describe-workflow-draft-requirement-edit.js

@@ -0,0 +1,26 @@
+import { describeWorkflowDraftSelectedNodes } from '../edits/describe-workflow-draft-selected-nodes.js';
+import { listRemovedWorkflowDraftRequirements } from './history/list-removed-workflow-draft-requirements.js';
+/** Typed human answers choose a real final identity, without requiring its executable material. */
+export function describeWorkflowDraftRequirementEdit(input) {
+    const nodes = describeWorkflowDraftSelectedNodes(input);
+    const step = input.plan.steps.find((entry) => entry.id === input.stepId);
+    if (!step ||
+        (step.decision.kind !== 'revise-requirement' &&
+            step.decision.kind !== 'restore-requirement'))
+        throw new Error(`Requirement edit ${input.stepId} must name a selected revise-requirement or restore-requirement step`);
+    const requirementId = step.decision.requirementId;
+    const candidates = step.decision.kind === 'restore-requirement'
+        ? listRemovedWorkflowDraftRequirements(input.draft)
+        : input.draft.requirements;
+    const requirement = candidates.find((entry) => entry.id === requirementId);
+    if (!requirement)
+        throw new Error(`Requirement edit ${input.stepId} has no original requirement ${requirementId}`);
+    return {
+        action: step.decision.kind === 'restore-requirement' ? 'restore' : 'revise',
+        planId: input.plan.id,
+        baseRevision: input.plan.baseRevision,
+        stepId: step.id,
+        requirement: structuredClone(requirement),
+        nodes,
+    };
+}

package/dist/draft/requirements/history/append-workflow-draft-requirement-history.d.ts

@@ -0,0 +1,3 @@
+import type { AppendWorkflowDraftRequirementHistoryInput, WorkflowDraftRequirementHistoryEntry } from '../../../types/workflow-draft-requirement-history.js';
+/** Snapshots, source quotes and predecessor identity are code-owned, not model fields. */
+export declare function appendWorkflowDraftRequirementHistory(input: AppendWorkflowDraftRequirementHistoryInput): WorkflowDraftRequirementHistoryEntry;

package/dist/draft/requirements/history/append-workflow-draft-requirement-history.js

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+/** Snapshots, source quotes and predecessor identity are code-owned, not model fields. */
+export function appendWorkflowDraftRequirementHistory(input) {
+    const requirement = input.after === undefined ? input.before : input.after;
+    if (!requirement ||
+        (input.before && input.after && input.before.id !== input.after.id))
+        throw new Error('Requirement history needs an actual unchanged requirement identity');
+    if (input.before &&
+        input.after &&
+        isDeepStrictEqual(input.before, input.after))
+        throw new Error(`Requirement history cannot record a no-op: ${requirement.id}`);
+    if (input.after &&
+        !isDeepStrictEqual(input.sourceMessageIds, input.after.sourceMessageIds))
+        throw new Error(`Requirement history ${requirement.id} must preserve the current requirement sourceMessageIds`);
+    if (!Array.isArray(input.sourceMessageIds) ||
+        !input.sourceMessageIds.length ||
+        new Set(input.sourceMessageIds).size !== input.sourceMessageIds.length)
+        throw new Error('Requirement history needs distinct explicit sourceMessageIds');
+    if (!Array.isArray(input.messages))
+        throw new Error('Requirement history requires context.messages');
+    const evidence = input.sourceMessageIds.map((id) => {
+        const message = input.messages.find((entry) => entry.id === id);
+        if (!message)
+            throw new Error(`Requirement history ${requirement.id} references unknown source message ${id}`);
+        return {
+            kind: 'message',
+            messageId: message.id,
+            quote: message.text,
+        };
+    });
+    const previous = input.history.findLast((entry) => entry.requirementId === requirement.id);
+    const change = input.before === undefined
+        ? {
+            kind: previous === undefined
+                ? 'created'
+                : 'restored',
+            after: structuredClone(input.after),
+        }
+        : input.after === undefined
+            ? { kind: 'removed', before: structuredClone(input.before) }
+            : {
+                kind: 'revised',
+                before: structuredClone(input.before),
+                after: structuredClone(input.after),
+            };
+    const fields = {
+        revision: input.revision,
+        requirementId: requirement.id,
+        ...(previous === undefined ? {} : { previousEntryId: previous.id }),
+        evidence,
+        ...change,
+    };
+    return {
+        id: 'requirement-history:' +
+            createHash('sha256')
+                .update(JSON.stringify([input.draftId, fields]))
+                .digest('hex'),
+        ...fields,
+    };
+}

package/dist/draft/requirements/history/describe-workflow-draft-requirement-history.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftInput } from '../../../types/workflow-draft.js';
+import type { WorkflowDraftRequirementHistoryDescription } from '../../../types/workflow-draft-requirement-history.js';
+export declare function describeWorkflowDraftRequirementHistory(input: WorkflowDraftInput): WorkflowDraftRequirementHistoryDescription;

package/dist/draft/requirements/history/describe-workflow-draft-requirement-history.js

@@ -0,0 +1,22 @@
+import { validateWorkflowDraft } from '../../validate-workflow-draft.js';
+export function describeWorkflowDraftRequirementHistory(input) {
+    validateWorkflowDraft(input);
+    const heads = new Map(input.draft.requirementHistory.map((entry) => [entry.requirementId, entry]));
+    return {
+        draftId: input.draft.id,
+        revision: input.draft.revision,
+        entries: structuredClone(input.draft.requirementHistory),
+        current: [...heads.values()]
+            .filter((entry) => entry.kind !== 'removed')
+            .map((entry) => ({
+            requirementId: entry.requirementId,
+            entryId: entry.id,
+        })),
+        removed: [...heads.values()]
+            .filter((entry) => entry.kind === 'removed')
+            .map((entry) => ({
+            requirementId: entry.requirementId,
+            entryId: entry.id,
+        })),
+    };
+}

package/dist/draft/requirements/history/list-removed-workflow-draft-requirements.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraft, WorkflowDraftRequirement } from '../../../types/workflow-draft.js';
+/** Called only after canonical validation; the latest history head owns removal state. */
+export declare function listRemovedWorkflowDraftRequirements(draft: WorkflowDraft): WorkflowDraftRequirement[];

package/dist/draft/requirements/history/list-removed-workflow-draft-requirements.js

@@ -0,0 +1,5 @@
+/** Called only after canonical validation; the latest history head owns removal state. */
+export function listRemovedWorkflowDraftRequirements(draft) {
+    const heads = new Map(draft.requirementHistory.map((entry) => [entry.requirementId, entry]));
+    return [...heads.values()].flatMap((entry) => entry.kind === 'removed' ? [structuredClone(entry.before)] : []);
+}

package/dist/draft/requirements/history/validate-workflow-draft-requirement-history.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftInput } from '../../../types/workflow-draft.js';
+/** Validate the chain and its current projection. Hashes are consistency checks, not authentication. */
+export declare function validateWorkflowDraftRequirementHistory(input: WorkflowDraftInput): void;

package/dist/draft/requirements/history/validate-workflow-draft-requirement-history.js

@@ -0,0 +1,35 @@
+import { isDeepStrictEqual } from 'node:util';
+import { appendWorkflowDraftRequirementHistory } from './append-workflow-draft-requirement-history.js';
+/** Validate the chain and its current projection. Hashes are consistency checks, not authentication. */
+export function validateWorkflowDraftRequirementHistory(input) {
+    const active = new Map();
+    const seen = [];
+    let revision = 0;
+    for (const entry of input.draft.requirementHistory) {
+        if (entry.revision < revision || entry.revision > input.draft.revision)
+            throw new Error(`Requirement history ${entry.requirementId} has an invalid revision`);
+        revision = entry.revision;
+        const after = 'after' in entry ? entry.after : undefined;
+        if (after && after.id !== entry.requirementId)
+            throw new Error('Requirement history snapshot has a different requirementId');
+        const actual = appendWorkflowDraftRequirementHistory({
+            draftId: input.draft.id,
+            revision: entry.revision,
+            history: seen,
+            before: active.get(entry.requirementId),
+            after,
+            sourceMessageIds: entry.evidence.map((item) => item.messageId),
+            messages: input.context.messages,
+        });
+        if (!isDeepStrictEqual(actual, entry))
+            throw new Error(`Requirement history ${entry.requirementId} has changed snapshots, sources, ordering or identity`);
+        if (after)
+            active.set(entry.requirementId, after);
+        else
+            active.delete(entry.requirementId);
+        seen.push(entry);
+    }
+    if (active.size !== input.draft.requirements.length ||
+        input.draft.requirements.some((requirement) => !isDeepStrictEqual(active.get(requirement.id), requirement)))
+        throw new Error('Requirement history does not match the current draft requirements');
+}

package/dist/draft/requirements/project-workflow-draft-clarification-requirements.d.ts

@@ -0,0 +1,4 @@
+import type { PrepareWorkflowDraftEditInput } from '../../types/workflow-draft-edit-assembly.js';
+import type { WorkflowDraftRequirement } from '../../types/workflow-draft.js';
+/** The receipt is not authority: re-derive exact facts, provenance, states and selected-instance scopes. */
+export declare function projectWorkflowDraftClarificationRequirements(input: PrepareWorkflowDraftEditInput): WorkflowDraftRequirement[];

package/dist/draft/requirements/project-workflow-draft-clarification-requirements.js

@@ -0,0 +1,24 @@
+import { isDeepStrictEqual } from 'node:util';
+import { describeWorkflowDraftClarificationScopes } from './describe-workflow-draft-clarification-scopes.js';
+import { resolveWorkflowDraftClarificationScopes } from './resolve-workflow-draft-clarification-scopes.js';
+/** The receipt is not authority: re-derive exact facts, provenance, states and selected-instance scopes. */
+export function projectWorkflowDraftClarificationRequirements(input) {
+    if (input.context.clarification === undefined) {
+        if (input.clarificationScopes !== undefined)
+            throw new Error('Clarification scope receipt requires its original context.clarification');
+        return [];
+    }
+    if (input.clarificationScopes === undefined) {
+        if (describeWorkflowDraftClarificationScopes(input).requirements.length)
+            throw new Error('Active clarified facts/questions require an explicit clarificationScopes result before material planning');
+        return [];
+    }
+    const actual = resolveWorkflowDraftClarificationScopes({
+        ...input,
+        fingerprint: input.clarificationScopes.fingerprint,
+        proposal: input.clarificationScopes.proposal,
+    });
+    if (!isDeepStrictEqual(actual, input.clarificationScopes))
+        throw new Error('Clarification scope receipt has modified requirements, states or provenance');
+    return actual.requirements;
+}

package/dist/draft/requirements/resolve-workflow-draft-clarification-scopes.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveWorkflowDraftClarificationScopesInput, ResolvedWorkflowDraftClarificationScopes } from '../../types/workflow-draft-clarification.js';
+export declare function resolveWorkflowDraftClarificationScopes(input: ResolveWorkflowDraftClarificationScopesInput): ResolvedWorkflowDraftClarificationScopes;

package/dist/draft/requirements/resolve-workflow-draft-clarification-scopes.js

@@ -0,0 +1,31 @@
+import { isDeepStrictEqual } from 'node:util';
+import { describeWorkflowDraftClarificationScopes } from './describe-workflow-draft-clarification-scopes.js';
+import { createWorkflowDraftClarificationScopeSchema } from '../../schemas/create-workflow-draft-clarification-scope-schema.js';
+import { validateWorkflowPlanningEvidence } from '../../planning/evidence/validate-workflow-planning-evidence.js';
+export function resolveWorkflowDraftClarificationScopes(input) {
+    const description = describeWorkflowDraftClarificationScopes(input);
+    if (input.fingerprint !== description.fingerprint)
+        throw new Error('Clarification scope fingerprint is stale or describes a different plan, reply or original contract');
+    const proposal = createWorkflowDraftClarificationScopeSchema(input).parse(input.proposal);
+    if (!isDeepStrictEqual(proposal, input.proposal))
+        throw new Error('Clarification scopes must validate without defaults, coercion or output repair');
+    for (const decision of Object.values(proposal.scopes))
+        if (decision.explanation)
+            validateWorkflowPlanningEvidence({
+                context: { messages: description.messages },
+                evidence: decision.explanation.evidence,
+            });
+    return {
+        fingerprint: description.fingerprint,
+        proposal,
+        requirements: description.requirements.flatMap((requirement) => {
+            const scope = proposal.scopes[requirement.id].scope;
+            return scope.kind === 'unselected-work'
+                ? []
+                : [{ ...requirement, scope: structuredClone(scope) }];
+        }),
+        unselectedQuestionIds: description.requirements.flatMap((requirement) => proposal.scopes[requirement.id].scope.kind === 'unselected-work'
+            ? [requirement.origin.sourceId]
+            : []),
+    };
+}

package/dist/draft/resolve-workflow-draft-api-materials.d.ts

@@ -0,0 +1,4 @@
+import type { ResolveWorkflowDraftApiMaterialsInput } from '../types/workflow-draft.js';
+import type { DeferredApiInputMaterial } from '../types/deferred-api-inputs.js';
+/** Resolve content without fabricating canonical revision/approval metadata. */
+export declare function resolveWorkflowDraftApiMaterials(input: ResolveWorkflowDraftApiMaterialsInput): DeferredApiInputMaterial[];

package/dist/draft/resolve-workflow-draft-api-materials.js

@@ -0,0 +1,21 @@
+import { apiOperationKeyEquals } from '../openapi/catalog/api-operation-key-equals.js';
+/** Resolve content without fabricating canonical revision/approval metadata. */
+export function resolveWorkflowDraftApiMaterials(input) {
+    return input.content.apiCalls.map((call) => {
+        const matches = input.context.operations.filter((operation) => apiOperationKeyEquals(operation.key, call.operation));
+        if (matches.length !== 1)
+            throw new Error(`Draft API ${call.id} requires exactly one original OAS contract for its operation and snapshot`);
+        return {
+            operation: matches[0],
+            callId: call.id,
+            values: call.values,
+            bindings: call.bindings,
+            ...(call.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: call.requestedInputs }),
+            ...(call.requestMediaType === undefined
+                ? {}
+                : { requestMediaType: call.requestMediaType }),
+        };
+    });
+}

package/dist/draft/resolve-workflow-draft-materials.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDraftInput, WorkflowDraftMaterials } from '../types/workflow-draft.js';
+export declare function resolveWorkflowDraftMaterials(input: WorkflowDraftInput): WorkflowDraftMaterials;