@openapi-flow/core 0.2.0 → 0.3.1

package/dist/public-api.js

@@ -5,24 +5,176 @@ export { UnsupportedOperationError } from './openapi/common/unsupported-operatio
 export { createApiCatalog } from './openapi/catalog/create-api-catalog.js';
 export { listApiOperations } from './openapi/catalog/list-api-operations.js';
 export { resolveApiOperations } from './openapi/resolve-api-operations.js';
+export { describeApiSelectionContext } from './openapi/selection/evidence/describe-api-selection-context.js';
+export { createApiSelectionExplanation } from './openapi/selection/evidence/create-api-selection-explanation.js';
+export { validateApiSelectionExplanation } from './openapi/selection/evidence/validate-api-selection-explanation.js';
 export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
 export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
+export { describeApiLiteralGeneration } from './arguments/generation/describe-api-literal-generation.js';
+export { createApiLiteralGenerationRecord } from './arguments/generation/create-api-literal-generation-record.js';
+export { validateApiLiteralGenerationRecord } from './arguments/generation/validate-api-literal-generation-record.js';
+export { createWorkflowDraftCapabilityGap } from './draft/gaps/create-workflow-draft-capability-gap.js';
+export { inspectWorkflowDraftCapabilityGap } from './draft/gaps/inspect-workflow-draft-capability-gap.js';
+export { describeWorkflowDraftCapabilityGap } from './draft/gaps/describe-workflow-draft-capability-gap.js';
+export { listMissingRequestedApiInputs } from './arguments/clarification/list-missing-requested-api-inputs.js';
+export { describeApiInputSources } from './arguments/sources/describe-api-input-sources.js';
+export { resolveApiInputSourceSelections } from './arguments/clarification/extraction/resolve-api-input-source-selections.js';
+export { createApiInputSourceSelectionSchema } from './schemas/api-input-source-selection-schema.js';
+export { captureApiInputAnswerContext } from './arguments/clarification/extraction/capture-api-input-answer-context.js';
+export { resolveApiInputAnswerSources } from './arguments/clarification/extraction/resolve-api-input-answer-sources.js';
+export { createApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/create-api-input-answer-extraction-record.js';
+export { validateApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/validate-api-input-answer-extraction-record.js';
+export { applyConfirmedApiInputs } from './arguments/clarification/apply-confirmed-api-inputs.js';
+export { inspectApiArgumentRequirements } from './arguments/clarification/inspect-api-argument-requirements.js';
+export { validateApiInputAnswers } from './arguments/clarification/validate-api-input-answers.js';
+export { createApiInputAnswersSchema } from './schemas/create-api-input-answers-schema.js';
+export { resolveApiSelectionAnswers } from './openapi/selection/resolve-api-selection-answers.js';
+export { collectDeferredApiInputSlots } from './inputs/collect-deferred-api-input-slots.js';
+export { createDeferredApiInputsSchema } from './schemas/create-deferred-api-inputs-schema.js';
+export { inspectDeferredApiInputs } from './inputs/inspect-deferred-api-inputs.js';
+export { materializeDeferredApiInputs } from './inputs/materialize-deferred-api-inputs.js';
+export { DeferredApiInputError } from './inputs/deferred-api-input-error.js';
+export { describeWorkflowDraftClarificationOwnership } from './draft/edits/clarification/describe-workflow-draft-clarification-ownership.js';
+export { describeWorkflowDraftSelectedNodes } from './draft/edits/describe-workflow-draft-selected-nodes.js';
+export { describeWorkflowDraftRequirementEdit } from './draft/requirements/describe-workflow-draft-requirement-edit.js';
+export { createWorkflowDraftRequirementAnswerSchema } from './schemas/create-workflow-draft-requirement-answer-schema.js';
+export { clarificationQuestionLimitsSchema } from './schemas/workflow-clarification-settings-schema.js';
+export { workflowClarificationRepliesSchema } from './schemas/workflow-clarification-reply-schema.js';
+export { workflowClarificationAnswerChangesSchema } from './schemas/workflow-clarification-answer-revision-schema.js';
+export { describeWorkflowClarificationAnswerRevision } from './requirements/clarification/revisions/describe-workflow-clarification-answer-revision.js';
+export { reviseWorkflowClarificationAnswers } from './requirements/clarification/revisions/revise-workflow-clarification-answers.js';
+export { validateWorkflowClarificationAnswerRevision } from './requirements/clarification/revisions/validate-workflow-clarification-answer-revision.js';
+export { workflowDraftApiBindingAnswersSchema } from './schemas/workflow-draft-api-binding-answer-schema.js';
+export { prepareWorkflowDraftClarification } from './requirements/clarification/prepare-workflow-draft-clarification.js';
+export { describeWorkflowDraftClarification } from './requirements/clarification/describe-workflow-draft-clarification.js';
+export { describeWorkflowDraftClarificationScopes } from './draft/requirements/describe-workflow-draft-clarification-scopes.js';
+export { createWorkflowDraftClarificationScopeSchema } from './schemas/create-workflow-draft-clarification-scope-schema.js';
+export { resolveWorkflowDraftClarificationScopes } from './draft/requirements/resolve-workflow-draft-clarification-scopes.js';
+export { describeWorkflowDraftNativeReferenceRepair } from './draft/edits/native/repairs/describe-workflow-draft-native-reference-repair.js';
+export { resolveWorkflowDraftNativeReferenceRepair } from './draft/edits/native/repairs/resolve-workflow-draft-native-reference-repair.js';
+export { createWorkflowDraftNativeReferenceRepairSchema } from './schemas/workflow-draft-native-reference-repair-schema.js';
+export { describeWorkflowDraftNativeParameterEdit } from './draft/edits/native/describe-workflow-draft-native-parameter-edit.js';
+export { resolveWorkflowDraftNativeParameterEditTargets } from './draft/edits/native/resolve-workflow-draft-native-parameter-edit-targets.js';
+export { validateWorkflowDraftNativeParameterEditContract } from './draft/edits/native/validate-workflow-draft-native-parameter-edit-contract.js';
+export { resolveWorkflowDraftNativeParameterEdits } from './draft/edits/native/resolve-workflow-draft-native-parameter-edits.js';
+export { createWorkflowDraftNativeParameterEditProposalSchema } from './schemas/workflow-draft-native-parameter-edit-schema.js';
+export { createWorkflowDraftNativeParameterEditValuesSchema } from './schemas/create-workflow-draft-native-parameter-edit-values-schema.js';
+export { describeWorkflowDraftConnectionEdit } from './draft/edits/connections/describe-workflow-draft-connection-edit.js';
+export { resolveWorkflowDraftConnectionEdit } from './draft/edits/connections/resolve-workflow-draft-connection-edit.js';
+export { resolveWorkflowDraftTerminalRemoval } from './draft/edits/connections/resolve-workflow-draft-terminal-removal.js';
+export { createWorkflowDraftConnectionEditProposalSchema } from './schemas/workflow-draft-connection-edit-schema.js';
+export { stageWorkflowDraftEdit } from './draft/edits/stage-workflow-draft-edit.js';
+export { describeWorkflowDraftApiBindingEdit } from './draft/edits/bindings/describe-workflow-draft-api-binding-edit.js';
+export { resolveWorkflowDraftApiBindingEdit } from './draft/edits/bindings/resolve-workflow-draft-api-binding-edit.js';
+export { createWorkflowDraftApiBindingEditProposalSchema } from './schemas/workflow-draft-api-binding-edit-schema.js';
+export { describeWorkflowDraftApiInputEdit } from './draft/edits/inputs/describe-workflow-draft-api-input-edit.js';
+export { createWorkflowDraftApiInputEditContract } from './draft/edits/inputs/create-workflow-draft-api-input-edit-contract.js';
+export { validateWorkflowDraftApiInputEditContract } from './draft/edits/inputs/validate-workflow-draft-api-input-edit-contract.js';
+export { createWorkflowDraftApiInputEditProposalSchema } from './schemas/workflow-draft-api-input-edit-proposal-schema.js';
+export { createWorkflowDraftApiInputEditValuesSchema } from './schemas/create-workflow-draft-api-input-edit-values-schema.js';
+export { resolveWorkflowDraftApiInputEdits } from './draft/edits/inputs/resolve-workflow-draft-api-input-edits.js';
+export { prepareWorkflowDraftEdit } from './draft/edits/prepare-workflow-draft-edit.js';
+export { assembleWorkflowDraftEdit } from './draft/edits/assemble-workflow-draft-edit.js';
+export { WorkflowDraftEditAssemblyError } from './draft/edits/workflow-draft-edit-assembly-error.js';
+export { describeWorkflowDraftEditContext } from './draft/edits/describe-workflow-draft-edit-context.js';
+export { createWorkflowDraftEditPlan } from './draft/edits/create-workflow-draft-edit-plan.js';
+export { resolveWorkflowDraftEditOptions } from './draft/edits/resolve-workflow-draft-edit-options.js';
+export { validateWorkflowDraftEditPlan } from './draft/edits/validate-workflow-draft-edit-plan.js';
+export { createWorkflowDraftEditProposalSchema } from './schemas/create-workflow-draft-edit-proposal-schema.js';
+export { createWorkflowDraft } from './draft/create-workflow-draft.js';
+export { validateWorkflowDraft } from './draft/validate-workflow-draft.js';
+export { resolveWorkflowDraftMaterials } from './draft/resolve-workflow-draft-materials.js';
+export { inspectDraftReadiness } from './draft/inspect-draft-readiness.js';
+export { analyzeDraftChangeImpact } from './draft/impact/analyze-draft-change-impact.js';
+export { applyDraftChangeSet } from './draft/changes/apply-draft-change-set.js';
+export { approveWorkflowDraft } from './draft/approve-workflow-draft.js';
+export { describeWorkflowPlanningContext } from './planning/evidence/describe-workflow-planning-context.js';
+export { validateWorkflowPlanningEvidence } from './planning/evidence/validate-workflow-planning-evidence.js';
+export { createWorkflowRequirementsProposalSchema } from './schemas/create-workflow-requirements-proposal-schema.js';
+export { readClarificationQuestionLimits } from './requirements/configuration/read-clarification-question-limits.js';
+export { resolveWorkflowClarificationOptions } from './requirements/configuration/resolve-workflow-clarification-options.js';
+export { createWorkflowClarificationRound } from './requirements/clarification/create-workflow-clarification-round.js';
+export { validateWorkflowClarificationRound } from './requirements/clarification/validate-workflow-clarification-round.js';
+export { resolveWorkflowClarificationReplies } from './requirements/clarification/resolve-workflow-clarification-replies.js';
 export { validateApiArguments } from './arguments/validate-api-arguments.js';
-export { listApiRequestMediaTypes } from './arguments/list-api-request-media-types.js';
-export { selectDefaultApiRequestMediaType } from './arguments/select-default-api-request-media-type.js';
+export { listApiRequestMediaTypes } from './arguments/media/list-api-request-media-types.js';
+export { selectDefaultApiRequestMediaType } from './arguments/media/select-default-api-request-media-type.js';
+export { describeApiRequestMediaTypeContext } from './arguments/media/describe-api-request-media-type-context.js';
+export { createApiRequestMediaTypeDecision } from './arguments/media/create-api-request-media-type-decision.js';
+export { validateApiRequestMediaTypeDecision } from './arguments/media/validate-api-request-media-type-decision.js';
+export { describeNativeReferenceBindings } from './workflow/describe-native-reference-bindings.js';
+export { inspectNativeReferenceStructure } from './workflow/inspect-native-reference-structure.js';
+export { resolveNativeMaterialSnapshot } from './workflow/resolve-native-material-snapshot.js';
+export { inspectNativeNodeConfigurationReadiness } from './workflow/planning/resolve-native-configuration-materials.js';
+export { describeNativeInstanceDependencies, resolveNativeInstanceDependencies, validateNativeInstanceDependencies, } from './workflow/planning/resolve-native-instance-dependencies.js';
+export { createNativeInstanceDependenciesSchema } from './schemas/native-instance-dependencies-schema.js';
+export { resolveWorkflowDraftNativeSnapshot } from './draft/resolve-workflow-draft-native-snapshot.js';
+export { describeWorkflowDraftNativeNodeAddition } from './draft/edits/native/additions/describe-workflow-draft-native-node-addition.js';
+export { describeWorkflowDraftNativeNodeAdditionReadiness } from './draft/edits/native/additions/describe-workflow-draft-native-node-addition-readiness.js';
+export { describeWorkflowDraftRequirementHistory } from './draft/requirements/history/describe-workflow-draft-requirement-history.js';
+export { createWorkflowDraftEditCandidateContext } from './draft/requirements/create-workflow-draft-edit-candidate-context.js';
+export { resolveWorkflowPlanningMessages } from './planning/evidence/resolve-workflow-planning-messages.js';
+export { createWorkflowDraftNativeNodeAdditionSchema } from './schemas/workflow-draft-native-node-addition-schema.js';
+export { createWorkflowDraftNativeNodeParameterOwnershipSchema } from './schemas/workflow-draft-native-node-addition-schema.js';
+export { resolveWorkflowDraftNativeNodeParameterOwnership, validateWorkflowDraftNativeNodeParameterOwnershipContract, } from './draft/edits/native/additions/resolve-workflow-draft-native-node-parameter-ownership.js';
+export { resolveWorkflowDraftNativeNodeAddition } from './draft/edits/native/additions/resolve-workflow-draft-native-node-addition.js';
+export { createWorkflowDraftNativeDependenciesSchema } from './schemas/workflow-draft-native-dependencies-schema.js';
+export { describeWorkflowDraftNativeDependencies, resolveWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencyResolutions, } from './draft/edits/native/additions/resolve-workflow-draft-native-dependencies.js';
+export { describeWorkflowDraftApiBindingIntent } from './draft/edits/api/describe-workflow-draft-api-binding-intent.js';
+export { createWorkflowDraftApiBindingIntentSchema } from './schemas/workflow-draft-api-binding-intent-schema.js';
+export { resolveWorkflowDraftApiBindingIntent } from './draft/edits/api/resolve-workflow-draft-api-binding-intent.js';
+export { describeWorkflowDraftApiCallBindings } from './draft/edits/api/describe-workflow-draft-api-call-bindings.js';
+export { describeWorkflowDraftApiCallPlanning } from './draft/edits/api/describe-workflow-draft-api-call-planning.js';
+export { createWorkflowDraftApiCallBindingsSchema } from './schemas/workflow-draft-api-call-bindings-schema.js';
+export { resolveWorkflowDraftApiCallBindings } from './draft/edits/api/resolve-workflow-draft-api-call-bindings.js';
+export { describeWorkflowDraftApiCallArguments } from './draft/edits/api/describe-workflow-draft-api-call-arguments.js';
+export { createWorkflowDraftApiCallArgumentsSchema } from './schemas/workflow-draft-api-call-arguments-schema.js';
+export { resolveWorkflowDraftApiCallArguments } from './draft/edits/api/resolve-workflow-draft-api-call-arguments.js';
+export { NativeMaterialResolutionError } from './workflow/native-material-resolution-error.js';
 export { validateWorkflowGraphPlan } from './workflow/validate-workflow-graph-plan.js';
 export { createWorkflowGraphPlan } from './workflow/create-workflow-graph-plan.js';
+export { describeWorkflowGraphPlanning } from './workflow/graphs/describe-workflow-graph-planning.js';
+export { createWorkflowGraphPlanningResult } from './workflow/graphs/create-workflow-graph-planning-result.js';
+export { createWorkflowGraphPlanningRecord } from './workflow/graphs/create-workflow-graph-planning-record.js';
+export { validateWorkflowGraphPlanningRecord } from './workflow/graphs/validate-workflow-graph-planning-record.js';
+export { prepareWorkflowConnectionMaterials } from './workflow/connections/prepare-workflow-connection-materials.js';
+export { describeWorkflowConnectionPlanning } from './workflow/connections/describe-workflow-connection-planning.js';
+export { createWorkflowConnectionPlan } from './workflow/connections/create-workflow-connection-plan.js';
+export { projectWorkflowConnectionDecision } from './workflow/connections/project-workflow-connection-decision.js';
+export { createWorkflowConnectionPlanningRecord } from './workflow/connections/create-workflow-connection-planning-record.js';
+export { validateWorkflowConnectionPlanningRecord } from './workflow/connections/validate-workflow-connection-planning-record.js';
+export { describeNativeNodePlanning } from './workflow/planning/describe-native-node-planning.js';
+export { createNativePlanningCapabilityMaterial } from './workflow/planning/create-native-planning-capability-material.js';
+export { captureNativePlanningCapability } from './workflow/planning/capture-native-planning-capability.js';
+export { createPreparedNativeNodeMaterials } from './workflow/planning/create-prepared-native-node-materials.js';
+export { assembleNativeNodeMaterials } from './workflow/planning/assemble-native-node-materials.js';
+export { createNativeNodePlan } from './workflow/planning/create-native-node-plan.js';
+export { resolveNativeInstanceSelection, describeNativeInstanceSelection, } from './workflow/planning/resolve-native-instance-selection.js';
+export { describeNativeNodeConfiguration, resolveNativeNodeParameters, } from './workflow/planning/describe-native-node-configuration.js';
+export { createNativeInstanceSelectionSchema, createNativeNodeParametersSchema, } from './schemas/native-instance-planning-schema.js';
+export { createNativeNodePlanningRecord } from './workflow/planning/create-native-node-planning-record.js';
+export { validateNativeNodePlanningRecord } from './workflow/planning/validate-native-node-planning-record.js';
+export { describeApiBindingPlanning } from './bindings/planning/describe-api-binding-planning.js';
+export { createApiBindingPlanningRecord } from './bindings/planning/create-api-binding-planning-record.js';
+export { validateApiBindingPlanningRecord } from './bindings/planning/validate-api-binding-planning-record.js';
 export { createNativeOutputContracts } from './workflow/create-native-output-contracts.js';
 export { createReviewableNodeContracts } from './workflow/create-reviewable-node-contracts.js';
 export { validateWorkflowEdges } from './workflow/validate-workflow-edges.js';
 export { validateNativeOutputContracts } from './bindings/validate-native-output-contracts.js';
 export { parseNativeNodeParameters } from './workflow/parse-native-node-parameters.js';
+export { resolveNativeStructureParameters } from './workflow/resolve-native-structure-parameters.js';
+export { collectNativeRuntimeInputSlots } from './inputs/native/collect-native-runtime-input-slots.js';
+export { inspectNativeRuntimeInputs } from './inputs/native/inspect-native-runtime-inputs.js';
+export { createNativeRuntimeParameterMaterializations } from './inputs/native/create-native-runtime-parameter-materialization.js';
+export { materializeNativeRuntimeParameters } from './inputs/native/materialize-native-runtime-parameters.js';
+export { createWorkflowRuntimeInputsSchema } from './schemas/create-workflow-runtime-inputs-schema.js';
 export { createWorkflowPlanningCapabilities } from './workflow/create-workflow-planning-capabilities.js';
 export { validateNativeApiResponseReferences } from './workflow/validate-native-api-response-references.js';
 export { validateApiBindingPlan } from './bindings/validate-api-binding-plan.js';
 export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
 export { createApiRequestSchema } from './schemas/create-api-request-schema.js';
 export { validateApiBindingAssignments } from './bindings/validate-api-binding-assignments.js';
+export { validateApiBindingAssignment } from './bindings/validate-api-binding-assignment.js';
 export { validateApiBindingGaps } from './bindings/validate-api-binding-gaps.js';
 export { createReviewableWorkflowGraphPlan } from './workflow/create-reviewable-workflow-graph-plan.js';
 export { validateReviewableWorkflowGraphPlan } from './workflow/validate-reviewable-workflow-graph-plan.js';
@@ -33,3 +185,10 @@ export { createResponseArrayItemSchema } from './openapi/response/create-respons
 export { createNativeArrayItemSchema } from './bindings/create-native-array-item-schema.js';
 export { createResponseValueSchema } from './openapi/response/create-response-value-schema.js';
 export { listApiResponsePointers } from './openapi/response/list-api-response-pointers.js';
+export { describeWorkflowReviewSuggestions } from './review/suggestions/describe-workflow-review-suggestions.js';
+export { createWorkflowReviewSuggestions } from './review/suggestions/create-workflow-review-suggestions.js';
+export { validateWorkflowReviewSuggestions } from './review/suggestions/validate-workflow-review-suggestions.js';
+export { adoptWorkflowReviewSuggestion } from './review/suggestions/adopt-workflow-review-suggestion.js';
+export { readWorkflowReviewSuggestionLimits } from './review/suggestions/read-workflow-review-suggestion-limits.js';
+export { createWorkflowReviewSuggestionsProposalSchema } from './schemas/create-workflow-review-suggestions-proposal-schema.js';
+export { workflowReviewSuggestionLimitsSchema, workflowReviewSuggestionOptionsSchema, } from './schemas/workflow-review-suggestion-settings-schema.js';

package/dist/requirements/clarification/build-workflow-clarification-resolution.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowClarificationResolutionInput, WorkflowClarificationResolution } from '../../types/workflow-clarification.js';
+/** Resolve explicit answer IDs and text only; no model, guessing or scope expansion. */
+export declare function buildWorkflowClarificationResolution(input: WorkflowClarificationResolutionInput): WorkflowClarificationResolution;

package/dist/requirements/clarification/build-workflow-clarification-resolution.js

@@ -0,0 +1,75 @@
+import { workflowClarificationRepliesSchema } from '../../schemas/workflow-clarification-reply-schema.js';
+import { formatWorkflowRequirementsPrompt } from './format-workflow-requirements-prompt.js';
+/** Resolve explicit answer IDs and text only; no model, guessing or scope expansion. */
+export function buildWorkflowClarificationResolution(input) {
+    const replies = workflowClarificationRepliesSchema.parse(input.replies);
+    const questions = input.round.categories.flatMap((category) => category.questions);
+    const byQuestion = new Map(questions.map((question) => [question.id, question]));
+    for (const reply of replies)
+        if (!byQuestion.has(reply.questionId))
+            throw new Error(`Unknown clarification question ${reply.questionId}`);
+    const byReply = new Map(replies.map((reply) => [reply.questionId, reply]));
+    const facts = input.round.statements.map((statement) => ({
+        id: statement.id,
+        text: statement.text,
+        sources: structuredClone(statement.sources),
+    }));
+    for (const question of questions) {
+        const reply = byReply.get(question.id);
+        if (!reply)
+            continue;
+        if (reply.kind === 'defer')
+            continue;
+        if (reply.kind !== question.answer.kind)
+            throw new Error(`Clarification reply ${reply.questionId} must use ${question.answer.kind}`);
+        let answerText;
+        if (reply.kind === 'text')
+            answerText = reply.text;
+        else {
+            if (question.answer.kind === 'text')
+                throw new Error(`Clarification question ${reply.questionId} has no choices`);
+            const choiceIds = reply.kind === 'single-choice' ? [reply.choiceId] : reply.choiceIds;
+            const choices = choiceIds.map((id) => {
+                const choice = question.answer.kind === 'text'
+                    ? undefined
+                    : question.answer.choices.find((choice) => choice.id === id);
+                if (!choice)
+                    throw new Error(`Unknown clarification choice ${id} for ${reply.questionId}`);
+                return choice.label;
+            });
+            answerText = JSON.stringify(choices);
+        }
+        facts.push({
+            id: `${question.id}:answer`,
+            text: `${question.message}\n답변: ${answerText}`,
+            sources: [
+                {
+                    kind: 'clarification-answer',
+                    roundId: input.round.id,
+                    questionId: question.id,
+                },
+            ],
+        });
+    }
+    const pendingQuestions = questions.filter((question) => !byReply.has(question.id));
+    const deferredQuestions = questions.filter((question) => byReply.get(question.id)?.kind === 'defer');
+    return {
+        roundId: input.round.id,
+        contextFingerprint: input.round.contextFingerprint,
+        sourceMessages: structuredClone(input.round.sourceMessages),
+        replies: questions.flatMap((question) => {
+            const reply = byReply.get(question.id);
+            return reply ? [reply] : [];
+        }),
+        facts,
+        pendingQuestionIds: pendingQuestions.map((question) => question.id),
+        deferredQuestionIds: deferredQuestions.map((question) => question.id),
+        readyForPlanning: !pendingQuestions.length && !deferredQuestions.length,
+        requirementsPrompt: formatWorkflowRequirementsPrompt({
+            sourceMessages: input.round.sourceMessages,
+            facts,
+            pendingQuestions,
+            deferredQuestions,
+        }),
+    };
+}

package/dist/requirements/clarification/create-workflow-clarification-round.d.ts

@@ -0,0 +1,3 @@
+import type { CreateWorkflowClarificationRoundInput, WorkflowClarificationRound } from '../../types/workflow-clarification.js';
+/** The model proposes meaning; code validates sources and owns every identity. */
+export declare function createWorkflowClarificationRound(input: CreateWorkflowClarificationRoundInput): WorkflowClarificationRound;

package/dist/requirements/clarification/create-workflow-clarification-round.js

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+import { createWorkflowRequirementsProposalSchema } from '../../schemas/create-workflow-requirements-proposal-schema.js';
+import { workflowPlanningEvidenceSchema } from '../../schemas/planning-evidence-schema.js';
+import { clarificationQuestionLimitsSchema } from '../../schemas/workflow-clarification-settings-schema.js';
+import { workflowPlanningContextFingerprintFromDescription } from '../../planning/evidence/workflow-planning-context-fingerprint.js';
+import { describeWorkflowPlanningContext } from '../../planning/evidence/describe-workflow-planning-context.js';
+import { validateDescribedWorkflowPlanningEvidence } from '../../planning/evidence/validate-workflow-planning-evidence.js';
+import { resolveWorkflowClarificationOptions } from '../configuration/resolve-workflow-clarification-options.js';
+/** The model proposes meaning; code validates sources and owns every identity. */
+export function createWorkflowClarificationRound(input) {
+    const limits = clarificationQuestionLimitsSchema.parse(input.limits);
+    const options = resolveWorkflowClarificationOptions(input.options);
+    const context = describeWorkflowPlanningContext(input.context);
+    const contextFingerprint = workflowPlanningContextFingerprintFromDescription(context);
+    const proposal = createWorkflowRequirementsProposalSchema(limits, options, workflowPlanningEvidenceSchema).parse(input.proposal);
+    const described = [
+        ...proposal.statements,
+        ...proposal.categories,
+        ...proposal.categories.flatMap((category) => category.questions),
+        ...proposal.categories.flatMap((category) => category.questions.flatMap((question) => question.answer.kind === 'text' ? [] : question.answer.choices)),
+        ...(proposal.suggestions ?? []),
+    ];
+    for (const statement of proposal.statements)
+        validateDescribedWorkflowPlanningEvidence(context, statement.sources);
+    for (const item of described)
+        if (item.explanation)
+            validateDescribedWorkflowPlanningEvidence(context, item.explanation.evidence);
+    const id = 'clarification:' +
+        createHash('sha256')
+            .update(JSON.stringify([contextFingerprint, limits, options, proposal]))
+            .digest('hex');
+    return {
+        id,
+        contextFingerprint,
+        sourceMessages: structuredClone(context.messages),
+        limits,
+        options,
+        statements: proposal.statements.map((statement, index) => ({
+            ...statement,
+            id: `${id}:statement:${index + 1}`,
+        })),
+        categories: proposal.categories.map((category, categoryIndex) => ({
+            ...category,
+            id: `${id}:category:${categoryIndex + 1}`,
+            questions: category.questions.map((question, questionIndex) => {
+                const questionId = `${id}:question:${categoryIndex + 1}:${questionIndex + 1}`;
+                return {
+                    ...question,
+                    id: questionId,
+                    answer: question.answer.kind === 'text'
+                        ? question.answer
+                        : {
+                            ...question.answer,
+                            choices: question.answer.choices.map((choice, choiceIndex) => ({
+                                ...choice,
+                                id: `${questionId}:choice:${choiceIndex + 1}`,
+                            })),
+                        },
+                };
+            }),
+        })),
+        ...(proposal.suggestions === undefined
+            ? {}
+            : {
+                suggestions: proposal.suggestions.map((suggestion, index) => ({
+                    ...suggestion,
+                    id: `${id}:suggestion:${index + 1}`,
+                })),
+            }),
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { WorkflowPlanningContext } from '../../types/planning-evidence.js';
+import type { WorkflowDraftClarificationDescription } from '../../types/workflow-draft-clarification.js';
+/** Validate against current declarations and original source messages, never client-edited facts or receipt text. */
+export declare function describeWorkflowDraftClarification(context: WorkflowPlanningContext): WorkflowDraftClarificationDescription | undefined;

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

@@ -0,0 +1,45 @@
+import { isDeepStrictEqual } from 'node:util';
+import { prepareWorkflowDraftClarification } from './prepare-workflow-draft-clarification.js';
+/** Validate against current declarations and original source messages, never client-edited facts or receipt text. */
+export function describeWorkflowDraftClarification(context) {
+    const supplied = context.clarification;
+    if (supplied === undefined)
+        return undefined;
+    if (!supplied ||
+        !supplied.round ||
+        !supplied.resolution ||
+        !Array.isArray(supplied.answerMessages) ||
+        !Array.isArray(supplied.confirmedAnswerMessageIds))
+        throw new Error('planning context.clarification requires round, resolution, answerMessages and confirmedAnswerMessageIds');
+    for (const message of supplied.round.sourceMessages)
+        if (!context.messages.some((current) => isDeepStrictEqual(current, message)))
+            throw new Error(`Draft clarification source message ${message.id} is missing or changed`);
+    const originalContext = {
+        messages: supplied.round.sourceMessages,
+        operations: context.operations,
+        capabilities: context.capabilities,
+        ...(context.entrypoint === undefined
+            ? {}
+            : { entrypoint: context.entrypoint }),
+    };
+    const derived = prepareWorkflowDraftClarification({
+        context: originalContext,
+        round: supplied.round,
+        resolution: supplied.resolution,
+    });
+    if (!isDeepStrictEqual(derived, supplied))
+        throw new Error('Draft clarification data differs from its original validated round and replies');
+    for (const message of derived.answerMessages)
+        if (!context.messages.some((current) => isDeepStrictEqual(current, message)))
+            throw new Error(`Draft clarification reply evidence ${message.id} is missing or changed`);
+    const questions = supplied.round.categories.flatMap((category) => category.questions);
+    return {
+        roundId: supplied.round.id,
+        facts: structuredClone(derived.resolution.facts),
+        pendingQuestions: structuredClone(questions.filter((question) => derived.resolution.pendingQuestionIds.includes(question.id))),
+        deferredQuestions: structuredClone(questions.filter((question) => derived.resolution.deferredQuestionIds.includes(question.id))),
+        requirementsPrompt: derived.resolution.requirementsPrompt,
+        answerMessageIds: derived.answerMessages.map((message) => message.id),
+        confirmedAnswerMessageIds: [...derived.confirmedAnswerMessageIds],
+    };
+}

package/dist/requirements/clarification/format-workflow-requirements-prompt.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowRequirementsPromptInput } from '../../types/workflow-clarification.js';
+/** A readable projection of structured facts, never a second source of truth. */
+export declare function formatWorkflowRequirementsPrompt(input: WorkflowRequirementsPromptInput): string;

package/dist/requirements/clarification/format-workflow-requirements-prompt.js

@@ -0,0 +1,21 @@
+/** A readable projection of structured facts, never a second source of truth. */
+export function formatWorkflowRequirementsPrompt(input) {
+    return [
+        '사용자 원문',
+        ...input.sourceMessages.map((message) => `- [${message.id}] ${message.text}`),
+        '확인된 요구사항',
+        ...input.facts.map((fact) => `- ${fact.text}`),
+        ...(input.pendingQuestions.length
+            ? [
+                '미답변 질문',
+                ...input.pendingQuestions.map((question) => `- ${question.message}`),
+            ]
+            : []),
+        ...(input.deferredQuestions.length
+            ? [
+                '보류한 질문',
+                ...input.deferredQuestions.map((question) => `- ${question.message}`),
+            ]
+            : []),
+    ].join('\n');
+}

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

@@ -0,0 +1,3 @@
+import type { PrepareWorkflowDraftClarificationInput, WorkflowDraftClarification } from '../../types/workflow-draft-clarification.js';
+/** Re-derive facts and reply evidence from the original round. No summary text is promoted to a user's answer. */
+export declare function prepareWorkflowDraftClarification(input: PrepareWorkflowDraftClarificationInput): WorkflowDraftClarification;

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

@@ -0,0 +1,42 @@
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { resolveWorkflowClarificationReplies } from './resolve-workflow-clarification-replies.js';
+/** Re-derive facts and reply evidence from the original round. No summary text is promoted to a user's answer. */
+export function prepareWorkflowDraftClarification(input) {
+    if (input.context.clarification !== undefined)
+        throw new Error('prepareWorkflowDraftClarification.context must be the original question context, not a nested clarified context');
+    const resolution = resolveWorkflowClarificationReplies({
+        round: input.round,
+        context: input.context,
+        replies: input.resolution.replies,
+    });
+    if (!isDeepStrictEqual(resolution, input.resolution))
+        throw new Error('Draft clarification resolution has modified facts, replies, provenance or readiness');
+    const questions = input.round.categories.flatMap((category) => category.questions);
+    const answerMessages = resolution.replies.map((reply) => {
+        const question = questions.find((item) => item.id === reply.questionId);
+        const fact = resolution.facts.find((item) => item.sources.some((source) => source.kind === 'clarification-answer' &&
+            source.questionId === reply.questionId));
+        const text = JSON.stringify({
+            kind: 'clarification-reply-evidence',
+            roundId: input.round.id,
+            questionId: question.id,
+            question: question.message,
+            reply,
+            ...(fact === undefined ? {} : { confirmedFact: fact }),
+        });
+        return {
+            id: 'clarification-reply:' +
+                createHash('sha256').update(text).digest('hex'),
+            text,
+        };
+    });
+    return {
+        round: structuredClone(input.round),
+        resolution,
+        answerMessages,
+        confirmedAnswerMessageIds: answerMessages
+            .filter((_message, index) => resolution.replies[index].kind !== 'defer')
+            .map((message) => message.id),
+    };
+}

package/dist/requirements/clarification/proposal-from-clarification-round.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowClarificationRound, WorkflowRequirementsProposal } from '../../types/workflow-clarification.js';
+/** Remove only the code-owned identities; strict proposal parsing follows. */
+export declare function proposalFromClarificationRound(round: WorkflowClarificationRound): WorkflowRequirementsProposal;

package/dist/requirements/clarification/proposal-from-clarification-round.js

@@ -0,0 +1,28 @@
+function withoutIdentity(part) {
+    const result = { ...part };
+    Reflect.deleteProperty(result, 'id');
+    return result;
+}
+/** Remove only the code-owned identities; strict proposal parsing follows. */
+export function proposalFromClarificationRound(round) {
+    return {
+        statements: round.statements.map(withoutIdentity),
+        categories: round.categories.map((category) => ({
+            ...withoutIdentity(category),
+            questions: category.questions.map((question) => ({
+                ...withoutIdentity(question),
+                answer: question.answer.kind === 'text'
+                    ? question.answer
+                    : {
+                        ...question.answer,
+                        choices: question.answer.choices.map(withoutIdentity),
+                    },
+            })),
+        })),
+        ...(round.suggestions === undefined
+            ? {}
+            : {
+                suggestions: round.suggestions.map(withoutIdentity),
+            }),
+    };
+}

package/dist/requirements/clarification/resolve-workflow-clarification-replies.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowClarificationRepliesInput, WorkflowClarificationResolution } from '../../types/workflow-clarification.js';
+/** Retain confirmed answers across partial replies; stale/modified state fails. */
+export declare function resolveWorkflowClarificationReplies(input: ResolveWorkflowClarificationRepliesInput): WorkflowClarificationResolution;

package/dist/requirements/clarification/resolve-workflow-clarification-replies.js

@@ -0,0 +1,31 @@
+import { isDeepStrictEqual } from 'node:util';
+import { workflowClarificationRepliesSchema } from '../../schemas/workflow-clarification-reply-schema.js';
+import { buildWorkflowClarificationResolution } from './build-workflow-clarification-resolution.js';
+import { validateWorkflowClarificationRound } from './validate-workflow-clarification-round.js';
+/** Retain confirmed answers across partial replies; stale/modified state fails. */
+export function resolveWorkflowClarificationReplies(input) {
+    validateWorkflowClarificationRound(input);
+    const replies = workflowClarificationRepliesSchema.parse(input.replies);
+    if (input.previous !== undefined) {
+        if (input.previous.roundId !== input.round.id ||
+            input.previous.contextFingerprint !== input.round.contextFingerprint)
+            throw new Error('Previous clarification resolution belongs to a different round or planning context');
+        const expected = buildWorkflowClarificationResolution({
+            round: input.round,
+            replies: input.previous.replies,
+        });
+        if (!isDeepStrictEqual(expected, input.previous))
+            throw new Error('Previous clarification resolution has modified facts, answers or readiness');
+    }
+    const combined = new Map(input.previous?.replies.map((reply) => [reply.questionId, reply]));
+    for (const reply of replies) {
+        const previous = combined.get(reply.questionId);
+        if (previous && previous.kind !== 'defer')
+            throw new Error(`Clarification question ${reply.questionId} is already answered; start an explicit requirements revision to change it`);
+        combined.set(reply.questionId, reply);
+    }
+    return buildWorkflowClarificationResolution({
+        round: input.round,
+        replies: [...combined.values()],
+    });
+}

package/dist/requirements/clarification/revisions/describe-workflow-clarification-answer-revision.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowPlanningContext } from '../../../types/planning-evidence.js';
+import type { WorkflowClarificationAnswerRevisionDescription } from '../../../types/workflow-clarification-answer-revision.js';
+/** Describe only already-confirmed questions. Pending answers use the ordinary reply boundary. */
+export declare function describeWorkflowClarificationAnswerRevision(context: WorkflowPlanningContext): WorkflowClarificationAnswerRevisionDescription;

package/dist/requirements/clarification/revisions/describe-workflow-clarification-answer-revision.js

@@ -0,0 +1,18 @@
+import { createHash } from 'node:crypto';
+import { describeWorkflowPlanningContext } from '../../../planning/evidence/describe-workflow-planning-context.js';
+/** Describe only already-confirmed questions. Pending answers use the ordinary reply boundary. */
+export function describeWorkflowClarificationAnswerRevision(context) {
+    const description = describeWorkflowPlanningContext(context);
+    const clarification = context.clarification;
+    if (!clarification)
+        throw new Error('Clarification answer revision requires context.clarification');
+    const replies = clarification.resolution.replies.filter((reply) => reply.kind !== 'defer');
+    return {
+        fingerprint: createHash('sha256')
+            .update(JSON.stringify([description, clarification]))
+            .digest('hex'),
+        roundId: clarification.round.id,
+        questions: structuredClone(clarification.round.categories.flatMap((category) => category.questions.filter((question) => replies.some((reply) => reply.questionId === question.id)))),
+        replies: structuredClone(replies),
+    };
+}

package/dist/requirements/clarification/revisions/revise-workflow-clarification-answers.d.ts

@@ -0,0 +1,3 @@
+import type { ReviseWorkflowClarificationAnswersInput, WorkflowClarificationAnswerRevisionResult } from '../../../types/workflow-clarification-answer-revision.js';
+/** Explicit, atomic answer replacement/reopening. No model call, guessed choice or in-place mutation. */
+export declare function reviseWorkflowClarificationAnswers(input: ReviseWorkflowClarificationAnswersInput): WorkflowClarificationAnswerRevisionResult;