agentweaver 0.1.15 → 0.1.17

package/dist/runtime/planning-bundle.js

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, latestArtifactIteration, planFile, planJsonFile, qaFile, qaJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+function planningPrefixes(options) {
+    return options.requireQa ? ["design", "plan", "qa"] : ["design", "plan"];
+}
+function maxPlanningIteration(taskKey, options) {
+    let maxIteration = null;
+    for (const prefix of planningPrefixes(options)) {
+        for (const extension of ["md", "json"]) {
+            const iteration = latestArtifactIteration(taskKey, prefix, extension);
+            if (iteration === null) {
+                continue;
+            }
+            maxIteration = maxIteration === null ? iteration : Math.max(maxIteration, iteration);
+        }
+    }
+    return maxIteration;
+}
+export function planningBundlePaths(taskKey, iteration) {
+    return {
+        designFile: designFile(taskKey, iteration),
+        designJsonFile: designJsonFile(taskKey, iteration),
+        planFile: planFile(taskKey, iteration),
+        planJsonFile: planJsonFile(taskKey, iteration),
+        qaFile: qaFile(taskKey, iteration),
+        qaJsonFile: qaJsonFile(taskKey, iteration),
+    };
+}
+function requiredPlanningPaths(bundle, options) {
+    const required = [
+        bundle.designFile,
+        bundle.designJsonFile,
+        bundle.planFile,
+        bundle.planJsonFile,
+    ];
+    if (options.requireQa) {
+        required.push(bundle.qaFile, bundle.qaJsonFile);
+    }
+    return required;
+}
+export function findLatestCompletedPlanningIteration(taskKey, options) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, options);
+    if (latestKnownIteration === null) {
+        return null;
+    }
+    for (let iteration = latestKnownIteration; iteration >= 1; iteration -= 1) {
+        const bundle = planningBundlePaths(taskKey, iteration);
+        const requiredPaths = requiredPlanningPaths(bundle, options);
+        if (requiredPaths.every((candidate) => existsSync(candidate))) {
+            return iteration;
+        }
+    }
+    return null;
+}
+export function resolveLatestCompletedPlanningIteration(taskKey, options) {
+    const resolvedIteration = findLatestCompletedPlanningIteration(taskKey, options);
+    if (resolvedIteration !== null) {
+        return resolvedIteration;
+    }
+    const fallbackIteration = maxPlanningIteration(taskKey, options) ?? 1;
+    const fallbackBundle = planningBundlePaths(taskKey, fallbackIteration);
+    const requiredPaths = requiredPlanningPaths(fallbackBundle, options);
+    const missing = requiredPaths.filter((candidate) => !existsSync(candidate));
+    throw new TaskRunnerError(`${options.missingMessage}\nMissing files: ${missing.join(", ")}`);
+}
+export function inspectLatestPlanningBundle(taskKey) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, { requireQa: true });
+    if (latestKnownIteration === null) {
+        return {
+            status: "missing",
+            planningIteration: null,
+            missingFiles: [],
+            bundle: null,
+            errorMessage: "Implement mode requires planning artifacts from the planning phase, but none were found.",
+        };
+    }
+    const bundle = planningBundlePaths(taskKey, latestKnownIteration);
+    const missingFiles = requiredPlanningPaths(bundle, { requireQa: true }).filter((candidate) => !existsSync(candidate));
+    if (missingFiles.length > 0) {
+        return {
+            status: "incomplete",
+            planningIteration: latestKnownIteration,
+            missingFiles,
+            bundle,
+            errorMessage: `Implement mode requires a complete planning bundle for iteration ${latestKnownIteration}.` +
+                `\nMissing files: ${missingFiles.join(", ")}`,
+        };
+    }
+    try {
+        validateStructuredArtifacts([
+            { path: bundle.designJsonFile, schemaId: "implementation-design/v1" },
+            { path: bundle.planJsonFile, schemaId: "implementation-plan/v1" },
+            { path: bundle.qaJsonFile, schemaId: "qa-plan/v1" },
+        ], `Implement mode requires a valid structured planning bundle for iteration ${latestKnownIteration}.`);
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            planningIteration: latestKnownIteration,
+            missingFiles: [],
+            bundle,
+            errorMessage: error.message,
+        };
+    }
+    return {
+        status: "valid",
+        planningIteration: latestKnownIteration,
+        missingFiles: [],
+        bundle,
+    };
+}
+export function resolveLatestPlanningBundle(taskKey) {
+    const inspection = inspectLatestPlanningBundle(taskKey);
+    if (inspection.status !== "valid") {
+        throw new TaskRunnerError(inspection.errorMessage);
+    }
+    return {
+        planningIteration: inspection.planningIteration,
+        ...inspection.bundle,
+    };
+}

package/dist/runtime/ready-to-merge.js

@@ -1,4 +1,5 @@
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
 import { readyToMergeFile } from "../artifacts.js";
 export function clearReadyToMergeFile(taskKey) {
     const filePath = readyToMergeFile(taskKey);
@@ -8,3 +9,23 @@ export function clearReadyToMergeFile(taskKey) {
     rmSync(filePath);
     return true;
 }
+export function writeReadyToMergeFile(taskKey, options = {}) {
+    const filePath = readyToMergeFile(taskKey);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const summary = options.summary?.trim();
+    const lines = options.mdLang === "ru"
+        ? [
+            "# Готово к слиянию",
+            "",
+            "Блокирующих замечаний не найдено по текущему порогу severity.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ]
+        : [
+            "# Ready to Merge",
+            "",
+            "No blocking findings were detected at the configured severity threshold.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ];
+    writeFileSync(filePath, `${lines.join("\n")}\n`, "utf8");
+    return filePath;
+}

package/dist/runtime/review-input-contract.js

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, instantTaskInputJsonFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, requireArtifacts, taskContextJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
+const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
+function resolveOptionalPromptFile(filePath) {
+    if (!existsSync(filePath)) {
+        return {
+            present: false,
+            path: null,
+            promptValue: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    return {
+        present: true,
+        path: filePath,
+        promptValue: filePath,
+    };
+}
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
+export function inspectReviewInputContract(taskKey) {
+    let planningIteration;
+    try {
+        planningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+            requireQa: false,
+            missingMessage: "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+        });
+    }
+    catch (error) {
+        if (error instanceof TaskRunnerError) {
+            return { status: "missing-planning" };
+        }
+        throw error;
+    }
+    const contract = {
+        planningIteration,
+        designFile: designFile(taskKey, planningIteration),
+        designJsonFile: designJsonFile(taskKey, planningIteration),
+        planFile: planFile(taskKey, planningIteration),
+        planJsonFile: planJsonFile(taskKey, planningIteration),
+        hasTaskContextJsonFile: false,
+        taskContextJsonFilePath: null,
+        taskContextJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasJiraTaskFile: false,
+        jiraTaskFilePath: null,
+        jiraTaskFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasTaskInputJsonFile: false,
+        taskInputJsonFilePath: null,
+        taskInputJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+    };
+    requireArtifacts([contract.designFile, contract.designJsonFile, contract.planFile, contract.planJsonFile], "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    validateStructuredArtifacts([
+        { path: contract.designJsonFile, schemaId: "implementation-design/v1" },
+        { path: contract.planJsonFile, schemaId: "implementation-plan/v1" },
+    ], "Structured review requires valid design and plan structured artifacts.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Structured review task-context structured artifact is invalid.");
+    const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Structured review instant-task input structured artifact is invalid.");
+    if (!taskContext.present && !jiraTask.present && !taskInput.present) {
+        return {
+            status: "missing-task-context",
+            planningIteration,
+        };
+    }
+    contract.hasTaskContextJsonFile = taskContext.present;
+    contract.taskContextJsonFilePath = taskContext.path;
+    contract.taskContextJsonFile = taskContext.promptValue;
+    contract.hasJiraTaskFile = jiraTask.present;
+    contract.jiraTaskFilePath = jiraTask.path;
+    contract.jiraTaskFile = jiraTask.promptValue;
+    contract.hasTaskInputJsonFile = taskInput.present;
+    contract.taskInputJsonFilePath = taskInput.path;
+    contract.taskInputJsonFile = taskInput.promptValue;
+    return {
+        status: "ready",
+        contract,
+    };
+}
+export function resolveReviewInputContract(taskKey) {
+    const inspection = inspectReviewInputContract(taskKey);
+    if (inspection.status === "ready") {
+        return inspection.contract;
+    }
+    if (inspection.status === "missing-planning") {
+        throw new TaskRunnerError("Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    }
+    throw new TaskRunnerError(`Structured review requires a normalized task-context artifact, or legacy Jira/instant-task context, in scope '${taskKey}'.`);
+}
+export { OPTIONAL_INPUT_NOT_PROVIDED };

package/dist/structured-artifact-schema-registry.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "./errors.js";
 export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
+    "artifact-manifest/v1",
     "bug-analysis/v1",
     "bug-fix-design/v1",
     "bug-fix-plan/v1",
@@ -18,9 +19,17 @@ export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
     "review-assessment/v1",
     "review-findings/v1",
     "review-fix-report/v1",
+    "task-context/v1",
     "task-summary/v1",
     "user-input/v1",
 ];
+export const ARTIFACT_PAYLOAD_SCHEMA_IDS = [
+    ...STRUCTURED_ARTIFACT_SCHEMA_IDS,
+    "helper-json/v1",
+    "markdown/v1",
+    "opaque-file/v1",
+    "plain-text/v1",
+];
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const SCHEMA_REGISTRY_PATH = path.join(MODULE_DIR, "structured-artifact-schemas.json");
 function isRecord(value) {

package/dist/structured-artifact-schemas.json

@@ -612,7 +612,7 @@
         "items": {
           "type": "object",
           "properties": {
-            "severity": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["blocker", "critical", "high", "medium", "low", "info"] },
             "title": { "type": "string", "nonEmpty": true },
             "description": { "type": "string", "nonEmpty": true }
           },
@@ -660,6 +660,145 @@
     },
     "required": ["summary", "completed_actions", "validation_steps"]
   },
+  "helper-json/v1": {
+    "type": "json"
+  },
+  "markdown/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "opaque-file/v1": {
+    "type": "bytes"
+  },
+  "plain-text/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "artifact-manifest/v1": {
+    "type": "object",
+    "properties": {
+      "artifact_id": { "type": "string", "nonEmpty": true },
+      "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+      "scope": { "type": "string", "nonEmpty": true },
+      "run_id": { "type": "string", "nonEmpty": true },
+      "flow_id": { "type": "string", "nonEmpty": true },
+      "phase_id": { "type": "string", "nonEmpty": true },
+      "step_id": { "type": "string", "nonEmpty": true },
+      "kind": { "type": "string", "enum": ["artifact", "file"] },
+      "version": { "type": "number" },
+      "payload_family": { "type": "string", "enum": ["structured-json", "markdown", "plain-text", "helper-json", "opaque-file"] },
+      "schema_id": { "type": "string", "nonEmpty": true },
+      "schema_version": { "type": "number" },
+      "created_at": { "type": "string", "nonEmpty": true },
+      "producer": {
+        "type": "object",
+        "properties": {
+          "node": { "type": "string", "nonEmpty": true },
+          "executor": { "type": "string", "nonEmpty": true },
+          "model": { "type": "string", "nonEmpty": true },
+          "summary": { "type": "string", "nonEmpty": true }
+        },
+        "required": ["node"]
+      },
+      "inputs": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "source": { "type": "string", "enum": ["manifest", "external-path"] },
+            "path": { "type": "string", "nonEmpty": true },
+            "artifact_id": { "type": "string", "nonEmpty": true },
+            "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+            "schema_id": { "type": "string", "nonEmpty": true },
+            "schema_version": { "type": "number" }
+          },
+          "required": ["source", "path"]
+        }
+      },
+      "content_hash": { "type": "string", "nonEmpty": true, "pattern": "^sha256:[a-f0-9]{64}$" },
+      "status": { "type": "string", "enum": ["ready", "superseded", "stale"] },
+      "payload_path": { "type": "string", "nonEmpty": true },
+      "manifest_path": { "type": "string", "nonEmpty": true },
+      "publication_key": { "type": "string", "nonEmpty": true },
+      "supersedes": { "type": "string", "nonEmpty": true },
+      "status_reason": { "type": "string", "nonEmpty": true },
+      "diagnostics": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "code": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["info", "warning", "error"] },
+            "message": { "type": "string", "nonEmpty": true }
+          },
+          "required": ["code", "severity", "message"]
+        }
+      }
+    },
+    "required": [
+      "artifact_id",
+      "logical_key",
+      "scope",
+      "run_id",
+      "flow_id",
+      "phase_id",
+      "step_id",
+      "kind",
+      "version",
+      "payload_family",
+      "schema_id",
+      "schema_version",
+      "created_at",
+      "producer",
+      "inputs",
+      "content_hash",
+      "status",
+      "payload_path",
+      "manifest_path",
+      "publication_key"
+    ]
+  },
+  "task-context/v1": {
+    "type": "object",
+    "properties": {
+      "source_type": {
+        "type": "string",
+        "nonEmpty": true,
+        "enum": ["jira", "manual"]
+      },
+      "title": { "type": "string", "nonEmpty": true },
+      "summary": { "type": "string", "nonEmpty": true },
+      "problem": { "type": "string", "nonEmpty": true },
+      "goal": { "type": "string", "nonEmpty": true },
+      "acceptance_criteria": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "constraints": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "references": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "notes": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      }
+    },
+    "required": [
+      "source_type",
+      "title",
+      "summary",
+      "problem",
+      "goal",
+      "acceptance_criteria",
+      "constraints",
+      "references",
+      "notes"
+    ]
+  },
   "task-summary/v1": {
     "type": "object",
     "properties": {

package/dist/structured-artifacts.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { TaskRunnerError } from "./errors.js";
-import { STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
-export { STRUCTURED_ARTIFACT_SCHEMA_IDS };
+import { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
+export { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS };
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -14,9 +14,16 @@ function schemaLabel(node) {
             if (node.enum && node.enum.length > 0) {
                 return `one of: ${node.enum.join(", ")}`;
             }
+            if (node.pattern) {
+                return "a string with the expected format";
+            }
             return node.nonEmpty ? "a non-empty string" : "a string";
         case "boolean":
             return "a boolean";
+        case "bytes":
+            return "a binary file";
+        case "json":
+            return "valid JSON";
         case "number":
             return "a number";
         case "null":
@@ -49,9 +56,24 @@ function validateNode(value, schema, currentPath) {
             if (schema.enum && !schema.enum.includes(value)) {
                 return [`${currentPath} must be ${schemaLabel(schema)}`];
             }
+            if (schema.pattern) {
+                try {
+                    const pattern = new RegExp(schema.pattern);
+                    if (!pattern.test(value)) {
+                        return [`${currentPath} must be ${schemaLabel(schema)}`];
+                    }
+                }
+                catch {
+                    return [`${currentPath} uses an invalid schema pattern`];
+                }
+            }
             return [];
         case "boolean":
             return typeof value === "boolean" ? [] : [`${currentPath} must be a boolean`];
+        case "bytes":
+            return value instanceof Uint8Array ? [] : [`${currentPath} must be a binary file`];
+        case "json":
+            return validateJsonValue(value, currentPath);
         case "number":
             return typeof value === "number" && !Number.isNaN(value) ? [] : [`${currentPath} must be a number`];
         case "null":
@@ -85,6 +107,28 @@ function validateNode(value, schema, currentPath) {
         }
     }
 }
+function validateJsonValue(value, currentPath) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => validateJsonValue(item, `${currentPath}[${index}]`));
+    }
+    if (!isRecord(value)) {
+        return [`${currentPath} must be valid JSON`];
+    }
+    return Object.entries(value).flatMap(([key, candidate]) => validateJsonValue(candidate, `${currentPath}.${key}`));
+}
+function validateArtifactPayloadValue(value, schemaId, label = "$") {
+    const schema = getStructuredArtifactSchema(schemaId);
+    const issues = validateNode(value, schema, label);
+    if (issues.length > 0) {
+        throw new TaskRunnerError(`Structured artifact ${label} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    }
+}
 export function validateStructuredArtifact(path, schemaId) {
     if (!existsSync(path)) {
         throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
@@ -96,11 +140,38 @@ export function validateStructuredArtifact(path, schemaId) {
     catch (error) {
         throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
     }
-    const schema = getStructuredArtifactSchema(schemaId);
-    const issues = validateNode(parsed, schema, path);
-    if (issues.length > 0) {
-        throw new TaskRunnerError(`Structured artifact ${path} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    validateArtifactPayloadValue(parsed, schemaId, path);
+}
+export function validateStructuredArtifactValue(value, schemaId, label = "$") {
+    validateArtifactPayloadValue(value, schemaId, label);
+}
+export function isArtifactPayloadSchemaId(schemaId) {
+    return ARTIFACT_PAYLOAD_SCHEMA_IDS.includes(schemaId);
+}
+export function validateArtifactPayload(path, schemaId) {
+    if (!existsSync(path)) {
+        throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
+    }
+    if (schemaId === "markdown/v1" || schemaId === "plain-text/v1") {
+        validateArtifactPayloadValue(readFileSync(path, "utf8"), schemaId, path);
+        return;
+    }
+    if (schemaId === "helper-json/v1") {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
+        }
+        validateArtifactPayloadValue(parsed, schemaId, path);
+        return;
+    }
+    if (schemaId === "opaque-file/v1") {
+        validateArtifactPayloadValue(readFileSync(path), schemaId, path);
+        return;
     }
+    validateStructuredArtifact(path, schemaId);
 }
 export function validateStructuredArtifacts(items, message) {
     try {

package/dist/user-input.js

@@ -19,6 +19,69 @@ export function defaultValueForField(field) {
 export function buildInitialUserInputValues(fields) {
     return Object.fromEntries(fields.map((field) => [field.id, defaultValueForField(field)]));
 }
+export function applyInitialUserInputValues(fields, initialValues) {
+    if (!initialValues) {
+        return fields;
+    }
+    return fields.map((field) => {
+        const initialValue = initialValues[field.id];
+        if (initialValue === undefined) {
+            return field;
+        }
+        if (field.type === "boolean" && typeof initialValue === "boolean") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "text" && typeof initialValue === "string") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "single-select" && typeof initialValue === "string") {
+            return { ...field, default: initialValue };
+        }
+        if (field.type === "multi-select"
+            && Array.isArray(initialValue)
+            && initialValue.every((item) => typeof item === "string")) {
+            return { ...field, default: [...initialValue] };
+        }
+        return field;
+    });
+}
+function defaultSelectValue(field) {
+    if (field.type === "single-select") {
+        return field.default ?? field.options[0]?.value ?? "";
+    }
+    return [...(field.default ?? [])];
+}
+export function resolveFieldOptions(field, values) {
+    return field.optionsFromValues?.(values) ?? field.options;
+}
+export function resolveFieldDefinition(field, values) {
+    if (field.type !== "single-select" && field.type !== "multi-select") {
+        return field;
+    }
+    return {
+        ...field,
+        options: resolveFieldOptions(field, values),
+    };
+}
+export function normalizeUserInputFieldValue(field, values) {
+    if (field.type !== "single-select" && field.type !== "multi-select") {
+        return;
+    }
+    const allowedValues = new Set(resolveFieldOptions(field, values).map((option) => option.value));
+    if (field.type === "single-select") {
+        const currentValue = typeof values[field.id] === "string" ? String(values[field.id]) : "";
+        if (!allowedValues.has(currentValue)) {
+            const fallback = defaultSelectValue(resolveFieldDefinition(field, values));
+            values[field.id] = typeof fallback === "string" ? fallback : "";
+        }
+        return;
+    }
+    const currentValue = values[field.id];
+    const currentValues = Array.isArray(currentValue)
+        ? currentValue.filter((item) => typeof item === "string")
+        : [];
+    values[field.id] = currentValues.filter((item) => typeof item === "string" && allowedValues.has(item));
+}
 export function validateUserInputValues(form, values) {
     for (const field of form.fields) {
         const value = values[field.id];
@@ -38,24 +101,26 @@ export function validateUserInputValues(form, values) {
             continue;
         }
         if (field.type === "single-select") {
+            const options = resolveFieldOptions(field, values);
             if (typeof value !== "string") {
                 throw new TaskRunnerError(`Field '${field.label}' must be a string.`);
             }
             if (field.required && normalizeText(value).length === 0) {
                 throw new TaskRunnerError(`Field '${field.label}' is required.`);
             }
-            if (value && !field.options.some((option) => option.value === value)) {
+            if (value && !options.some((option) => option.value === value)) {
                 throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${value}'.`);
             }
             continue;
         }
+        const options = resolveFieldOptions(field, values);
         if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
             throw new TaskRunnerError(`Field '${field.label}' must be a string array.`);
         }
         if (field.required && value.length === 0) {
             throw new TaskRunnerError(`Field '${field.label}' requires at least one selected option.`);
         }
-        const allowed = new Set(field.options.map((option) => option.value));
+        const allowed = new Set(options.map((option) => option.value));
         for (const item of value) {
             if (!allowed.has(item)) {
                 throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${item}'.`);
@@ -113,7 +178,9 @@ export async function requestUserInputInTerminal(form) {
             process.stdout.write(`${form.description.trim()}\n`);
         }
         const values = buildInitialUserInputValues(form.fields);
-        for (const field of form.fields) {
+        for (const rawField of form.fields) {
+            normalizeUserInputFieldValue(rawField, values);
+            const field = resolveFieldDefinition(rawField, values);
             if (field.type === "boolean") {
                 while (true) {
                     const current = values[field.id];