@openapi-flow/core 0.2.0 → 0.3.0

package/dist/draft/edits/native/additions/describe-workflow-draft-native-node-addition.js

@@ -0,0 +1,4 @@
+import { resolveNativeNodeAdditionContext } from './resolve-native-node-addition-context.js';
+export function describeWorkflowDraftNativeNodeAddition(input) {
+    return resolveNativeNodeAdditionContext(input).description;
+}

package/dist/draft/edits/native/additions/resolve-native-node-addition-context.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeNodeAdditionInput } from '../../../../types/workflow-draft-native-node-addition.js';
+import type { WorkflowDraftNativeNodeAdditionContext } from '../../../../types/workflow-draft-native-node-addition-internal.js';
+/** Only one already-selected addition: identities and implementation contracts are code-owned. */
+export declare function resolveNativeNodeAdditionContext(input: WorkflowDraftNativeNodeAdditionInput): WorkflowDraftNativeNodeAdditionContext;

package/dist/draft/edits/native/additions/resolve-native-node-addition-context.js

@@ -0,0 +1,58 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { resolveNativeNodeAdditionMaterials } from './resolve-native-node-addition-materials.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../../references/native-material-sources-from-draft-references.js';
+import { bindNativeMaterialContracts } from '../../../../workflow/bind-native-material-contracts.js';
+import { createWorkflowPlanningCapabilities } from '../../../../workflow/create-workflow-planning-capabilities.js';
+import { hasFixedEmptyNativeParameters } from '../../../../workflow/planning/has-fixed-empty-native-parameters.js';
+import { resolveWorkflowPlanningMessages } from '../../../../planning/evidence/resolve-workflow-planning-messages.js';
+/** Only one already-selected addition: identities and implementation contracts are code-owned. */
+export function resolveNativeNodeAdditionContext(input) {
+    const { stage, nodeId, definition, sources, instruction, missingContext, pendingSourceNodeIds, sourceDependencies, plannedNativeRoles, } = resolveNativeNodeAdditionMaterials(input);
+    if (missingContext.length || pendingSourceNodeIds.length)
+        throw new Error(`Native node addition ${nodeId} [${definition.name}] requires ${missingContext.map((entry) => `${entry.field} (at least ${entry.minimumItems}, available ${entry.availableItems})`).join(', ')}${pendingSourceNodeIds.length ? '; pending selected producers: ' + pendingSourceNodeIds.join(', ') : ''}`);
+    const capability = bindNativeMaterialContracts(definition, nativeMaterialSourcesFromDraftReferences(sources));
+    const [planning] = createWorkflowPlanningCapabilities({
+        capabilities: [capability],
+        apiCallIds: sources.values
+            .filter((source) => source.kind === 'api')
+            .map((source) => source.nodeId),
+    });
+    const parametersSchema = JSON.parse(JSON.stringify(z.toJSONSchema(planning.parametersSchema, {
+        io: 'input',
+        target: 'draft-2020-12',
+        reused: 'inline',
+        cycles: 'ref',
+    })));
+    const fields = {
+        stage,
+        nodeId,
+        capability: {
+            name: capability.name,
+            description: capability.description,
+            supportsRuntimeParameters: capability.supportsRuntimeParameters === true,
+        },
+        instruction,
+        parametersSchema,
+        parameterMode: hasFixedEmptyNativeParameters(parametersSchema, capability)
+            ? 'fixed-empty'
+            : 'values',
+        sources,
+        ...(sourceDependencies === undefined ? {} : { sourceDependencies }),
+        ...(plannedNativeRoles === undefined ? {} : { plannedNativeRoles }),
+        messages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => input.requestMessageIds.includes(message.id))),
+        backgroundMessages: structuredClone(resolveWorkflowPlanningMessages(input.context).filter((message) => !input.requestMessageIds.includes(message.id))),
+        includeExplanations: input.plan.options.includeExplanations,
+        allowRuntimeParameters: input.allowRuntimeParameters === true,
+    };
+    return {
+        capability,
+        parametersSchema: planning.parametersSchema,
+        description: {
+            fingerprint: createHash('sha256')
+                .update(JSON.stringify(fields))
+                .digest('hex'),
+            ...fields,
+        },
+    };
+}

package/dist/draft/edits/native/additions/resolve-native-node-addition-materials.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeNodeAdditionInput } from '../../../../types/workflow-draft-native-node-addition.js';
+import type { WorkflowDraftNativeAdditionMaterials } from '../../../../types/workflow-draft-native-node-addition-internal.js';
+/** Validate the selected unfinished instance before deciding whether its original sources exist. */
+export declare function resolveNativeNodeAdditionMaterials(input: WorkflowDraftNativeNodeAdditionInput): WorkflowDraftNativeAdditionMaterials;

package/dist/draft/edits/native/additions/resolve-native-node-addition-materials.js

@@ -0,0 +1,78 @@
+import { nativeMaterialRequirementsSchema } from '../../../../schemas/native-material-requirements-schema.js';
+import { stageWorkflowDraftEdit } from '../../stage-workflow-draft-edit.js';
+import { describeWorkflowDraftReferenceSources } from '../../references/describe-workflow-draft-reference-sources.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../../references/native-material-sources-from-draft-references.js';
+import { validateWorkflowDraftNativeDependencies } from './resolve-workflow-draft-native-dependencies.js';
+/** Validate the selected unfinished instance before deciding whether its original sources exist. */
+export function resolveNativeNodeAdditionMaterials(input) {
+    if (input.allowRuntimeParameters !== undefined &&
+        typeof input.allowRuntimeParameters !== 'boolean')
+        throw new Error('Native node addition allowRuntimeParameters must be a boolean');
+    const stage = stageWorkflowDraftEdit(input);
+    const step = input.plan.steps.find((step) => step.id === input.stepId);
+    if (!step || step.decision.kind !== 'add-native-node')
+        throw new Error('Native node addition stepId must identify an add-native-node decision');
+    if (!stage.pendingResolutionStepIds.includes(step.id))
+        throw new Error('Native node addition already has an explicit result; remove it before replanning');
+    if (typeof step.newNodeId !== 'string' || !step.newNodeId.trim())
+        throw new Error('Native node addition requires its code-allocated newNodeId');
+    const nodeId = step.newNodeId;
+    if (stage.content.requirements.some((requirement) => requirement.state !== 'confirmed' &&
+        (requirement.scope.kind === 'workflow' ||
+            requirement.scope.nodeIds.includes(nodeId))))
+        throw new Error(`Native node addition ${nodeId} is blocked by an unresolved requirement`);
+    const capabilityName = step.decision.capability;
+    const definition = input.context.capabilities.find((capability) => capability.name === capabilityName);
+    if (!definition)
+        throw new Error(`Native node addition requires registered capability ${capabilityName}`);
+    const dependencies = input.producerDependencies === undefined
+        ? undefined
+        : validateWorkflowDraftNativeDependencies({
+            ...input,
+            producerDependencies: input.producerDependencies,
+        });
+    const sourceIds = dependencies?.proposal.sourcesByNodeId[nodeId].sourceNodeIds;
+    const available = describeWorkflowDraftReferenceSources({
+        stage,
+        context: input.context,
+        excludedNodeIds: [nodeId],
+    });
+    const sources = {
+        values: available.values.filter((source) => sourceIds === undefined || sourceIds.includes(source.nodeId)),
+        exclusiveOutputs: available.exclusiveOutputs.filter((source) => sourceIds === undefined || sourceIds.includes(source.nodeId)),
+    };
+    const pendingSourceNodeIds = sourceIds === undefined
+        ? []
+        : sourceIds.filter((id) => !sources.values.some((source) => source.nodeId === id) &&
+            !sources.exclusiveOutputs.some((source) => source.nodeId === id));
+    const materials = nativeMaterialSourcesFromDraftReferences(sources);
+    const requirements = definition.materialRequirements === undefined
+        ? []
+        : nativeMaterialRequirementsSchema.parse(definition.materialRequirements);
+    const missingContext = requirements.flatMap((requirement) => materials[requirement.field].length < requirement.minimumItems
+        ? [
+            {
+                ...requirement,
+                availableItems: materials[requirement.field].length,
+            },
+        ]
+        : []);
+    return {
+        stage,
+        nodeId,
+        definition,
+        sources,
+        instruction: step.decision.instruction,
+        missingContext,
+        pendingSourceNodeIds,
+        ...(dependencies === undefined
+            ? {}
+            : {
+                sourceDependencies: {
+                    planId: dependencies.id,
+                    sourceNodeIds: [...sourceIds],
+                },
+                plannedNativeRoles: structuredClone(dependencies.context.roles),
+            }),
+    };
+}

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-dependencies.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowDraftNativeDependenciesInput, WorkflowDraftNativeDependencyContext, WorkflowDraftNativeDependencies, ResolveWorkflowDraftNativeDependenciesInput, ValidateWorkflowDraftNativeDependenciesInput, ValidateWorkflowDraftNativeDependencyResolutionsInput } from '../../../../types/workflow-draft-native-dependencies.js';
+/** Reconstruct the original semantic plan before any value generation. Progress never rebases this receipt. */
+export declare function describeWorkflowDraftNativeDependencies(input: WorkflowDraftNativeDependenciesInput): WorkflowDraftNativeDependencyContext;
+export declare function resolveWorkflowDraftNativeDependencies(input: ResolveWorkflowDraftNativeDependenciesInput): WorkflowDraftNativeDependencies;
+export declare function validateWorkflowDraftNativeDependencies(input: ValidateWorkflowDraftNativeDependenciesInput): WorkflowDraftNativeDependencies;
+/** Revalidate actual completed additions before final connection planning/adoption, not just the model wrapper. */
+export declare function validateWorkflowDraftNativeDependencyResolutions(input: ValidateWorkflowDraftNativeDependencyResolutionsInput): void;

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-dependencies.js

@@ -0,0 +1,137 @@
+import { createHash } from 'node:crypto';
+import { stageWorkflowDraftEdit } from '../../stage-workflow-draft-edit.js';
+import { describeWorkflowDraftReferenceSources } from '../../references/describe-workflow-draft-reference-sources.js';
+import { resolveWorkflowPlanningMessages } from '../../../../planning/evidence/resolve-workflow-planning-messages.js';
+import { createWorkflowDraftNativeDependenciesSchema } from '../../../../schemas/workflow-draft-native-dependencies-schema.js';
+import { validateNativeProducerDependencyGraph } from '../../../../workflow/planning/validate-native-producer-dependency-graph.js';
+import { validateNativeNodeProducerReferences } from '../../../../workflow/planning/resolve-native-configuration-materials.js';
+import { nativeMaterialSourcesFromDraftReferences } from '../../references/native-material-sources-from-draft-references.js';
+import { bindNativeMaterialContracts } from '../../../../workflow/bind-native-material-contracts.js';
+import { jsonValuesEqual } from '../../../../utils/json-values-equal.js';
+import { requireNativeParameterReferenceSources, describePendingNativeProducer, selectNativeParameterProducers, } from '../../../../workflow/planning/select-native-parameter-producers.js';
+/** Reconstruct the original semantic plan before any value generation. Progress never rebases this receipt. */
+export function describeWorkflowDraftNativeDependencies(input) {
+    const stage = stageWorkflowDraftEdit({
+        ...input,
+        resolutions: [],
+        repairs: [],
+    });
+    const sources = describeWorkflowDraftReferenceSources({
+        stage,
+        context: input.context,
+        excludedNodeIds: [],
+    });
+    const roles = [];
+    const pendingNativeSources = [];
+    for (const step of input.plan.steps) {
+        const decision = step.decision;
+        if (decision.kind !== 'add-native-node' &&
+            decision.kind !== 'revise-native-node')
+            continue;
+        const nodeId = decision.kind === 'add-native-node' ? step.newNodeId : decision.nodeId;
+        const capability = decision.kind === 'add-native-node'
+            ? decision.capability
+            : input.draft.nativeNodes.find((node) => node.id === decision.nodeId)
+                .capability;
+        if (typeof nodeId !== 'string' || !nodeId.trim())
+            throw new Error(`Draft native dependency step ${step.id} requires its original allocated node ID`);
+        const definition = input.context.capabilities.find((entry) => entry.name === capability);
+        if (!definition)
+            throw new Error(`Draft native dependency ${nodeId} requires registered capability ${capability}`);
+        const role = {
+            nodeId,
+            stepId: step.id,
+            capability,
+            description: definition.description,
+            instruction: decision.instruction,
+            parameterReferenceSources: requireNativeParameterReferenceSources(definition),
+        };
+        if (decision.kind === 'add-native-node')
+            roles.push(role);
+        else
+            pendingNativeSources.push(role);
+    }
+    const candidates = [
+        ...stage.apiResponseSources.map((source) => ({
+            nodeId: source.nodeId,
+            referenceSources: ['response'],
+        })),
+        ...sources.values.map((source) => ({
+            nodeId: source.nodeId,
+            referenceSources: [
+                source.kind === 'api' ? 'response' : 'node-output',
+            ],
+        })),
+        ...sources.exclusiveOutputs.map((source) => ({
+            nodeId: source.nodeId,
+            referenceSources: ['exclusive-output'],
+        })),
+        ...[...pendingNativeSources, ...roles].map((role) => describePendingNativeProducer(role.nodeId, input.context.capabilities.find((entry) => entry.name === role.capability))),
+    ];
+    const messages = resolveWorkflowPlanningMessages(input.context);
+    return structuredClone({
+        plan: input.plan,
+        sources,
+        roles,
+        pendingNativeSources,
+        sourceCandidatesByNodeId: Object.fromEntries(roles.map((role) => [
+            role.nodeId,
+            selectNativeParameterProducers({
+                nodeId: role.nodeId,
+                capability: input.context.capabilities.find((entry) => entry.name === role.capability),
+                producers: candidates,
+            }),
+        ])),
+        messages: messages.filter((message) => input.requestMessageIds.includes(message.id)),
+        backgroundMessages: messages.filter((message) => !input.requestMessageIds.includes(message.id)),
+        includeExplanations: input.plan.options.includeExplanations,
+    });
+}
+export function resolveWorkflowDraftNativeDependencies(input) {
+    const context = describeWorkflowDraftNativeDependencies(input);
+    const proposal = createWorkflowDraftNativeDependenciesSchema(input).parse(input.proposal);
+    if (!jsonValuesEqual(proposal, input.proposal))
+        throw new Error('Draft native producer choices cannot be coerced, defaulted or transformed');
+    validateNativeProducerDependencyGraph(context.roles.map((role) => role.nodeId), proposal);
+    const fields = { context, proposal };
+    return {
+        id: 'draft-native-dependencies:' +
+            createHash('sha256').update(JSON.stringify(fields)).digest('hex'),
+        ...structuredClone(fields),
+    };
+}
+export function validateWorkflowDraftNativeDependencies(input) {
+    if (!input.producerDependencies?.proposal)
+        throw new Error('Draft native dependencies require their original proposal');
+    const expected = resolveWorkflowDraftNativeDependencies({
+        ...input,
+        proposal: input.producerDependencies.proposal,
+    });
+    if (!jsonValuesEqual(expected, input.producerDependencies))
+        throw new Error('Draft native dependency choices are stale or their original plan/source contracts changed');
+    return expected;
+}
+/** Revalidate actual completed additions before final connection planning/adoption, not just the model wrapper. */
+export function validateWorkflowDraftNativeDependencyResolutions(input) {
+    const dependencies = validateWorkflowDraftNativeDependencies(input);
+    const stage = stageWorkflowDraftEdit(input);
+    for (const role of dependencies.context.roles) {
+        if (stage.pendingResolutionStepIds.includes(role.stepId))
+            throw new Error(`Draft native dependency ${role.nodeId} has no completed addition resolution`);
+        const node = stage.content.nativeNodes.find((entry) => entry.id === role.nodeId);
+        if (!node)
+            throw new Error(`Draft native dependency ${role.nodeId} has no actual staged node`);
+        const ids = dependencies.proposal.sourcesByNodeId[role.nodeId].sourceNodeIds;
+        const available = describeWorkflowDraftReferenceSources({
+            stage,
+            context: input.context,
+            excludedNodeIds: [role.nodeId],
+        });
+        const sources = {
+            values: available.values.filter((source) => ids.includes(source.nodeId)),
+            exclusiveOutputs: available.exclusiveOutputs.filter((source) => ids.includes(source.nodeId)),
+        };
+        const capability = bindNativeMaterialContracts(input.context.capabilities.find((entry) => entry.name === role.capability), nativeMaterialSourcesFromDraftReferences(sources));
+        validateNativeNodeProducerReferences(node, capability, ids);
+    }
+}

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-node-addition.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveWorkflowDraftNativeNodeAdditionInput, WorkflowDraftNativeNodeAdditionResult } from '../../../../types/workflow-draft-native-node-addition.js';
+export declare function resolveWorkflowDraftNativeNodeAddition(input: ResolveWorkflowDraftNativeNodeAdditionInput): WorkflowDraftNativeNodeAdditionResult;

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-node-addition.js

@@ -0,0 +1,101 @@
+import { createHash } from 'node:crypto';
+import { createWorkflowDraftNativeNodeAdditionSchema } from '../../../../schemas/workflow-draft-native-node-addition-schema.js';
+import { resolveNativeNodeAdditionContext } from './resolve-native-node-addition-context.js';
+import { resolveWorkflowDraftSourceEvidence } from '../../references/resolve-workflow-draft-source-evidence.js';
+import { validateWorkflowDraftNativeReferences } from '../../references/validate-workflow-draft-native-references.js';
+import { collectNativeRuntimeInputSlots } from '../../../../inputs/native/collect-native-runtime-input-slots.js';
+import { jsonValuesEqual } from '../../../../utils/json-values-equal.js';
+import { validateWorkflowDraftNativeNodeParameterOwnershipContract } from './resolve-workflow-draft-native-node-parameter-ownership.js';
+import { validateNativeNodeProducerReferences } from '../../../../workflow/planning/resolve-native-configuration-materials.js';
+export function resolveWorkflowDraftNativeNodeAddition(input) {
+    const { description, capability } = resolveNativeNodeAdditionContext(input);
+    if (input.fingerprint !== description.fingerprint)
+        throw new Error('Native node addition fingerprint is stale or describes different staged materials');
+    const proposal = createWorkflowDraftNativeNodeAdditionSchema(input).parse(input.proposal);
+    const ownership = input.parameterOwnership === undefined
+        ? undefined
+        : validateWorkflowDraftNativeNodeParameterOwnershipContract(input);
+    if (!jsonValuesEqual(proposal, input.proposal))
+        throw new Error('Native node addition schema must validate without defaults, coercion or transformation');
+    const evidence = resolveWorkflowDraftSourceEvidence({
+        description,
+        decision: proposal.decision,
+        capabilities: input.context.capabilities,
+    });
+    const decision = { ...proposal.decision, ...evidence };
+    // Wire evidence IDs remain in the unchanged proposal; resolved decisions carry only canonical evidence.
+    const choice = proposal.decision.status === 'provided'
+        ? { status: 'provided', parameters: proposal.decision.parameters }
+        : proposal.decision.status === 'runtime-parameters'
+            ? { status: 'runtime-parameters' }
+            : { status: 'needs-clarification', message: proposal.decision.message };
+    const fields = {
+        fingerprint: description.fingerprint,
+        proposal,
+        decision: { ...choice, ...evidence },
+        ...(ownership === undefined ? {} : { parameterOwnership: ownership }),
+    };
+    if (decision.status === 'needs-clarification')
+        return {
+            status: 'needs-clarification',
+            ...fields,
+            questions: [
+                {
+                    id: 'native-addition-question:' +
+                        createHash('sha256')
+                            .update(JSON.stringify([description.fingerprint, proposal]))
+                            .digest('hex'),
+                    nodeId: description.nodeId,
+                    message: decision.message,
+                    ...evidence,
+                },
+            ],
+        };
+    const node = decision.status === 'provided'
+        ? {
+            id: description.nodeId,
+            capability: capability.name,
+            parameters: decision.parameters,
+            ...(ownership?.runtimeParameters === undefined
+                ? {}
+                : { runtimeParameters: ownership.runtimeParameters }),
+        }
+        : {
+            id: description.nodeId,
+            capability: capability.name,
+            parameters: {},
+            runtimeParameters: true,
+        };
+    if (node.runtimeParameters !== undefined)
+        collectNativeRuntimeInputSlots({
+            nativeNodes: [node],
+            capabilities: [capability],
+        });
+    validateWorkflowDraftNativeReferences({
+        node,
+        capability,
+        sources: description.sources,
+    });
+    if (description.sourceDependencies !== undefined)
+        validateNativeNodeProducerReferences(node, capability, description.sourceDependencies.sourceNodeIds);
+    return {
+        status: 'ready',
+        ...fields,
+        resolution: decision.status === 'provided' &&
+            ownership?.runtimeParameters !== undefined &&
+            ownership.runtimeParameters !== true
+            ? {
+                stepId: input.stepId,
+                kind: 'native-mixed',
+                parameters: structuredClone(decision.parameters),
+                runtimeParameters: structuredClone(ownership.runtimeParameters),
+            }
+            : decision.status === 'provided'
+                ? {
+                    stepId: input.stepId,
+                    kind: 'native-literal',
+                    parameters: structuredClone(decision.parameters),
+                }
+                : { stepId: input.stepId, kind: 'native-runtime' },
+    };
+}

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-node-parameter-ownership.d.ts

@@ -0,0 +1,5 @@
+import type { ResolveWorkflowDraftNativeNodeParameterOwnershipInput, WorkflowDraftNativeNodeParameterOwnershipResult, WorkflowDraftNativeNodeAdditionInput, WorkflowDraftNativeNodeParameterOwnershipContract } from '../../../../types/workflow-draft-native-node-addition.js';
+/** A validated ownership receipt, not literal values, node readiness or a new schema chosen by a model. */
+export declare function resolveWorkflowDraftNativeNodeParameterOwnership(input: ResolveWorkflowDraftNativeNodeParameterOwnershipInput): WorkflowDraftNativeNodeParameterOwnershipResult;
+/** Recompute from original authority rather than trusting persisted schema/owner metadata. */
+export declare function validateWorkflowDraftNativeNodeParameterOwnershipContract(input: WorkflowDraftNativeNodeAdditionInput): WorkflowDraftNativeNodeParameterOwnershipContract;

package/dist/draft/edits/native/additions/resolve-workflow-draft-native-node-parameter-ownership.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { resolveNativeNodeAdditionContext } from './resolve-native-node-addition-context.js';
+import { createWorkflowDraftNativeNodeParameterOwnershipSchema } from '../../../../schemas/workflow-draft-native-node-addition-schema.js';
+import { resolveWorkflowDraftSourceEvidence } from '../../references/resolve-workflow-draft-source-evidence.js';
+import { createNativeParameterGenerationContract } from '../../../../schemas/create-native-parameter-generation-contract.js';
+import { jsonValuesEqual } from '../../../../utils/json-values-equal.js';
+/** A validated ownership receipt, not literal values, node readiness or a new schema chosen by a model. */
+export function resolveWorkflowDraftNativeNodeParameterOwnership(input) {
+    const { description, capability, parametersSchema } = resolveNativeNodeAdditionContext(input);
+    if (input.fingerprint !== description.fingerprint)
+        throw new Error('Native addition ownership fingerprint is stale or describes different staged materials');
+    const proposal = createWorkflowDraftNativeNodeParameterOwnershipSchema(input).parse(input.proposal);
+    if (!jsonValuesEqual(proposal, input.proposal))
+        throw new Error('Native addition ownership must validate without defaults, coercion or transformation');
+    const evidence = resolveWorkflowDraftSourceEvidence({
+        description,
+        decision: proposal.decision,
+        capabilities: input.context.capabilities,
+    });
+    const choice = proposal.decision.status === 'runtime-fields'
+        ? { status: 'runtime-fields', pointers: proposal.decision.pointers }
+        : proposal.decision.status === 'needs-clarification'
+            ? { status: 'needs-clarification', message: proposal.decision.message }
+            : { status: proposal.decision.status };
+    const decision = { ...choice, ...evidence };
+    if (decision.status === 'needs-clarification')
+        return {
+            status: 'needs-clarification',
+            fingerprint: description.fingerprint,
+            proposal,
+            questions: [
+                {
+                    id: 'native-ownership-question:' +
+                        createHash('sha256')
+                            .update(JSON.stringify([description.fingerprint, proposal]))
+                            .digest('hex'),
+                    nodeId: description.nodeId,
+                    message: decision.message,
+                    ...evidence,
+                },
+            ],
+        };
+    const runtimeParameters = decision.status === 'runtime-parameters'
+        ? true
+        : decision.status === 'runtime-fields'
+            ? { pointers: decision.pointers }
+            : undefined;
+    const contract = createNativeParameterGenerationContract({
+        nodeId: description.nodeId,
+        capability: { ...capability, parametersSchema },
+        runtimeParameters,
+    });
+    const fields = {
+        fingerprint: description.fingerprint,
+        stepId: input.stepId,
+        nodeId: description.nodeId,
+        proposal,
+        decision,
+        literalParametersSchema: contract.literalParametersSchema,
+        hasLiteralParameters: contract.hasLiteralParameters,
+        ...(runtimeParameters === undefined ? {} : { runtimeParameters }),
+    };
+    return {
+        status: 'ready',
+        contract: {
+            id: 'native-ownership:' +
+                createHash('sha256').update(JSON.stringify(fields)).digest('hex'),
+            ...fields,
+        },
+    };
+}
+/** Recompute from original authority rather than trusting persisted schema/owner metadata. */
+export function validateWorkflowDraftNativeNodeParameterOwnershipContract(input) {
+    const contract = input.parameterOwnership;
+    if (!contract ||
+        typeof contract.fingerprint !== 'string' ||
+        !contract.proposal)
+        throw new Error('Native addition parameterOwnership requires fingerprint and original proposal');
+    const result = resolveWorkflowDraftNativeNodeParameterOwnership({
+        ...input,
+        fingerprint: contract.fingerprint,
+        proposal: contract.proposal,
+    });
+    if (result.status !== 'ready' || !jsonValuesEqual(result.contract, contract))
+        throw new Error('Native addition parameterOwnership is stale or has modified identities, ownership or schemas');
+    return result.contract;
+}

package/dist/draft/edits/native/apply-workflow-draft-native-parameter-changes.d.ts

@@ -0,0 +1,4 @@
+import type { ApplyWorkflowDraftNativeParameterChangesInput } from '../../../types/workflow-draft-native-parameter-edit.js';
+import type { PlannedNativeNode } from '../../../types/workflow-plan.js';
+/** The same explicit ownership/literal changes are used by planning and final assembly. */
+export declare function applyWorkflowDraftNativeParameterChanges(input: ApplyWorkflowDraftNativeParameterChangesInput): PlannedNativeNode;

package/dist/draft/edits/native/apply-workflow-draft-native-parameter-changes.js

@@ -0,0 +1,106 @@
+import { hasPointer, pointerTokens, pointerValue, } from '../../../bindings/json-pointer.js';
+import { workflowDraftNativeNodeSchema } from '../../../schemas/workflow-draft-schema.js';
+import { workflowDraftNativeParameterChangeSchema } from '../../../schemas/workflow-draft-edit-assembly-schema.js';
+import { applyWorkflowDraftValueEdits } from '../values/apply-workflow-draft-value-edits.js';
+import { orderWorkflowDraftValueEdits } from '../values/order-workflow-draft-value-edits.js';
+import { createNativeRuntimeParametersSchema } from '../../../schemas/create-native-runtime-parameters-schema.js';
+import { createSchemaResourceContext } from '../../../bindings/resources/create-schema-resource-context.js';
+import { schemasAtPointer } from '../../../bindings/schema-at-pointer.js';
+import { schemaAllowsContainer } from '../../../bindings/schema-allows-container.js';
+/** The same explicit ownership/literal changes are used by planning and final assembly. */
+export function applyWorkflowDraftNativeParameterChanges(input) {
+    const node = workflowDraftNativeNodeSchema.parse(input.node);
+    const edits = workflowDraftNativeParameterChangeSchema
+        .array()
+        .parse(input.edits);
+    const previous = node.runtimeParameters === undefined || node.runtimeParameters === true
+        ? []
+        : node.runtimeParameters.pointers;
+    const seen = [];
+    for (const edit of edits) {
+        pointerTokens(edit.pointer);
+        if (seen.some((pointer) => pointer === '' ||
+            edit.pointer === '' ||
+            pointer === edit.pointer ||
+            pointer.startsWith(edit.pointer + '/') ||
+            edit.pointer.startsWith(pointer + '/')))
+            throw new Error(`${input.source}: duplicate or overlapping parameter targets`);
+        seen.push(edit.pointer);
+        if (node.runtimeParameters === true &&
+            (edit.kind !== 'set' || edit.pointer !== ''))
+            throw new Error(`${input.source}: runtime-owned native parameters need an explicit whole-object literal replacement`);
+        const parentOwner = previous.find((pointer) => edit.pointer.startsWith(pointer + '/'));
+        if (parentOwner !== undefined)
+            throw new Error(`${input.source}${edit.pointer}: runtime-owned parent ${parentOwner} needs an explicit whole-parent replacement`);
+        if (edit.kind === 'remove' && edit.pointer === '')
+            throw new Error(`${input.source}: cannot remove the parameter root`);
+        if (edit.kind === 'defer' &&
+            input.capability.supportsRuntimeParameters !== true)
+            throw new Error(`${input.source}: capability does not support runtime-independent parameters`);
+    }
+    const pointers = previous.filter((pointer) => !edits.some((edit) => edit.pointer === '' ||
+        pointer === edit.pointer ||
+        pointer.startsWith(edit.pointer + '/')));
+    pointers.push(...edits
+        .filter((edit) => edit.kind === 'defer')
+        .map((edit) => edit.pointer));
+    const values = [];
+    for (const edit of edits) {
+        if (edit.kind === 'set') {
+            values.push(edit);
+            continue;
+        }
+        const parentPointer = edit.pointer.slice(0, edit.pointer.lastIndexOf('/'));
+        const parent = pointerValue(node.parameters, parentPointer);
+        let arrayParent = Array.isArray(parent);
+        if (parent === undefined && edit.kind === 'remove' && previous.length) {
+            const schema = createNativeRuntimeParametersSchema(input.capability);
+            const resources = createSchemaResourceContext(schema);
+            const projections = schemasAtPointer(resources.root, parentPointer, resources);
+            const kinds = ['object', 'array'].filter((kind) => projections.some((projection) => schemaAllowsContainer(projection, kind)));
+            if (kinds.length !== 1)
+                throw new Error(`${input.source}${edit.pointer}: removal needs an explicit parent container`);
+            arrayParent = kinds[0] === 'array';
+        }
+        if (arrayParent && edit.kind === 'remove') {
+            const tokens = pointerTokens(edit.pointer);
+            const index = Number(tokens.at(-1));
+            if (pointers.some((pointer) => {
+                const owner = pointerTokens(pointer);
+                return (owner.length >= tokens.length &&
+                    tokens
+                        .slice(0, -1)
+                        .every((token, position) => owner[position] === token) &&
+                    Number(owner[tokens.length - 1]) > index);
+            }))
+                throw new Error(`${input.source}${edit.pointer}: removal would shift a runtime-owned array index; explicitly replace the array`);
+        }
+        if (hasPointer(node.parameters, edit.pointer))
+            values.push({ kind: 'remove', pointer: edit.pointer });
+        else if (edit.kind === 'remove' &&
+            !previous.some((pointer) => pointer === edit.pointer || pointer.startsWith(edit.pointer + '/')))
+            throw new Error(`${input.source}${edit.pointer}: cannot remove an absent value or owner`);
+    }
+    let parameters = node.parameters;
+    for (const edit of orderWorkflowDraftValueEdits(values)) {
+        const parentPointer = edit.pointer.slice(0, edit.pointer.lastIndexOf('/'));
+        const parent = pointerValue(parameters, parentPointer);
+        if (edit.kind === 'remove' &&
+            edits.some((change) => change.kind === 'defer' && change.pointer === edit.pointer) &&
+            Array.isArray(parent) &&
+            Number(pointerTokens(edit.pointer).at(-1)) !== parent.length - 1)
+            throw new Error(`${input.source}${edit.pointer}: deferral would create a sparse literal array; explicitly defer its suffix or whole array`);
+        const updated = applyWorkflowDraftValueEdits({
+            value: parameters,
+            edits: [edit],
+            source: input.source,
+        });
+        parameters = workflowDraftNativeNodeSchema.shape.parameters.parse(updated);
+    }
+    return workflowDraftNativeNodeSchema.parse({
+        id: node.id,
+        capability: node.capability,
+        parameters,
+        ...(pointers.length ? { runtimeParameters: { pointers } } : {}),
+    });
+}

package/dist/draft/edits/native/describe-workflow-draft-native-parameter-edit.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftNativeParameterEditInput, WorkflowDraftNativeParameterEditDescription } from '../../../types/workflow-draft-native-parameter-edit.js';
+/** Resolve an unfinished native revision, never replace its identity or registered capability. */
+export declare function describeWorkflowDraftNativeParameterEdit(input: WorkflowDraftNativeParameterEditInput): WorkflowDraftNativeParameterEditDescription;