intentdna 1.9.0 → 1.9.3

package/dist/schema/validators/controllers.js

@@ -1,3 +1,4 @@
+import { CONTROLLER_RUNTIME_PROGRAM_SCHEMA_VERSION, } from "../types.js";
 import { CONTROLLER_ROLE_KEYS, getControllerKindMetadata, isSupportedControllerKind } from "../controller-registry.js";
 function isSafeControllerArtifactPath(path) {
     return path.startsWith(".dna/") &&
@@ -14,46 +15,6 @@ function isSafeGeneratedIdentifier(value) {
 function isSafeGeneratedDisplayName(value) {
     return /^[A-Za-z0-9][A-Za-z0-9 _-]*$/.test(value) && !value.includes("..");
 }
-function validateStringList(value, path, errors) {
-    if (!Array.isArray(value)) {
-        errors.push({ path, message: "must be an array of non-empty strings" });
-        return;
-    }
-    value.forEach((item, index) => {
-        if (typeof item !== "string" || item.trim() === "") {
-            errors.push({ path: `${path}.${index}`, message: "must be a non-empty string" });
-        }
-    });
-}
-function validateControllerPolicy(policy, path, errors) {
-    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
-        errors.push({ path, message: "policy must be an object" });
-        return;
-    }
-    const record = policy;
-    const listFields = [
-        "diagnosis_reuse_criteria",
-        "progress_provenance_checks",
-        "verdict_branches",
-        "verdict_mapping",
-        "stop_report",
-        "constraints",
-    ];
-    const allowedFields = new Set([...listFields, "progress_provenance_failure"]);
-    for (const field of Object.keys(record)) {
-        if (!allowedFields.has(field)) {
-            errors.push({ path: `${path}.${field}`, message: "unknown controller policy field" });
-        }
-    }
-    for (const field of listFields) {
-        if (record[field] !== undefined)
-            validateStringList(record[field], `${path}.${field}`, errors);
-    }
-    if (record.progress_provenance_failure !== undefined &&
-        (typeof record.progress_provenance_failure !== "string" || record.progress_provenance_failure.trim() === "")) {
-        errors.push({ path: `${path}.progress_provenance_failure`, message: "must be a non-empty string" });
-    }
-}
 function validateControllerWorkflowRoles(workflow, roleEntries, path, errors) {
     if (!workflow)
         return;
@@ -69,6 +30,120 @@ function validateControllerWorkflowRoles(workflow, roleEntries, path, errors) {
         }
     }
 }
+function validateRuntimeDecision(decision, workflow, path, errors) {
+    if (!decision || typeof decision !== "object" || Array.isArray(decision)) {
+        errors.push({ path, message: "must be a typed controller decision" });
+        return;
+    }
+    for (const field of ["step_id", "output_name", "schema_ref", "json_pointer"]) {
+        if (typeof decision[field] !== "string" || decision[field].trim() === "") {
+            errors.push({ path: `${path}.${field}`, message: "must be a non-empty string" });
+        }
+    }
+    if (decision.json_pointer && !decision.json_pointer.startsWith("/")) {
+        errors.push({ path: `${path}.json_pointer`, message: "must be an RFC 6901 JSON pointer" });
+    }
+    const step = workflow?.steps.find((candidate) => candidate.id === decision.step_id);
+    if (workflow && !step) {
+        errors.push({ path: `${path}.step_id`, message: `references unknown workflow step '${decision.step_id}'` });
+        return;
+    }
+    const output = [
+        ...(step?.handoff?.produces ?? []),
+        ...(step?.canonical_runtime?.outputs ?? []),
+    ].find((candidate) => ((candidate.artifact_id ?? candidate.name ?? candidate.path) === decision.output_name));
+    if (step && (!output || output.type !== "state")) {
+        errors.push({ path: `${path}.output_name`, message: "must reference one structured state output produced by the decision step" });
+    }
+    else if (output && output.schema_ref !== decision.schema_ref) {
+        errors.push({ path: `${path}.schema_ref`, message: "must match the structured state output schema_ref" });
+    }
+}
+function validateRuntimeProgram(controller, diagnosisWorkflow, fixWorkflow, path, errors) {
+    const program = controller.runtime_program;
+    if (program === undefined)
+        return;
+    if (typeof program !== "object" || program === null || Array.isArray(program)) {
+        errors.push({ path, message: "runtime_program must be an object" });
+        return;
+    }
+    if (program.schema_version !== CONTROLLER_RUNTIME_PROGRAM_SCHEMA_VERSION) {
+        errors.push({ path: `${path}.schema_version`, message: `must equal '${CONTROLLER_RUNTIME_PROGRAM_SCHEMA_VERSION}'` });
+    }
+    const validateStep = (workflow, stepId, stepPath) => {
+        if (typeof stepId !== "string" || stepId.trim() === "") {
+            errors.push({ path: stepPath, message: "must be a non-empty string" });
+        }
+        else if (workflow && !workflow.steps.some((step) => step.id === stepId)) {
+            errors.push({ path: stepPath, message: `references unknown workflow step '${stepId}'` });
+        }
+    };
+    validateStep(diagnosisWorkflow, program.diagnosis?.analyzer_step_id, `${path}.diagnosis.analyzer_step_id`);
+    validateStep(diagnosisWorkflow, program.diagnosis?.reviewer_step_id, `${path}.diagnosis.reviewer_step_id`);
+    validateRuntimeDecision(program.diagnosis?.decision, diagnosisWorkflow, `${path}.diagnosis.decision`, errors);
+    validateStep(fixWorkflow, program.fix?.surgeon_step_id, `${path}.fix.surgeon_step_id`);
+    validateStep(fixWorkflow, program.fix?.reviewer_step_id, `${path}.fix.reviewer_step_id`);
+    validateStep(fixWorkflow, program.fix?.verifier_step_id, `${path}.fix.verifier_step_id`);
+    validateRuntimeDecision(program.fix?.decision, fixWorkflow, `${path}.fix.decision`, errors);
+    const verdictFields = [
+        [program.diagnosis?.approved_value, `${path}.diagnosis.approved_value`],
+        [program.diagnosis?.request_changes_value, `${path}.diagnosis.request_changes_value`],
+        [program.fix?.pass_value, `${path}.fix.pass_value`],
+        [program.fix?.continue_value, `${path}.fix.continue_value`],
+        [program.fix?.request_changes_value, `${path}.fix.request_changes_value`],
+        [program.fix?.blocked_value, `${path}.fix.blocked_value`],
+        [program.fix?.diagnosis_contract_invalid_value, `${path}.fix.diagnosis_contract_invalid_value`],
+        [program.fix?.provenance_invalid_value, `${path}.fix.provenance_invalid_value`],
+    ];
+    for (const [value, valuePath] of verdictFields) {
+        if (typeof value !== "string" || value.trim() === "") {
+            errors.push({ path: valuePath, message: "must be a non-empty string" });
+        }
+    }
+    if (program.reuse !== undefined) {
+        const validateIdentifier = (value, valuePath) => {
+            if (typeof value !== "string" || !isSafeGeneratedIdentifier(value)) {
+                errors.push({ path: valuePath, message: "must be a safe non-empty identifier" });
+            }
+        };
+        const reuse = program.reuse;
+        validateIdentifier(reuse.mode_input, `${path}.reuse.mode_input`);
+        for (const field of [
+            "diagnosis_spec_reference_input",
+            "diagnosis_spec_digest_input",
+            "diagnosis_contract_reference_input",
+            "diagnosis_contract_digest_input",
+        ]) {
+            validateIdentifier(reuse.legacy?.[field], `${path}.reuse.legacy.${field}`);
+        }
+        for (const field of [
+            "source_plan_input",
+            "diagnosis_result_input",
+            "review_result_input",
+        ]) {
+            validateIdentifier(reuse.canonical?.[field], `${path}.reuse.canonical.${field}`);
+        }
+        const approval = reuse.canonical?.approval_reuse;
+        if (approval?.enabled !== true) {
+            errors.push({ path: `${path}.reuse.canonical.approval_reuse.enabled`, message: "must be true when canonical approval reuse is declared" });
+        }
+        validateIdentifier(approval?.policy_id, `${path}.reuse.canonical.approval_reuse.policy_id`);
+        if (approval?.require_exact_artifact_ids !== true) {
+            errors.push({ path: `${path}.reuse.canonical.approval_reuse.require_exact_artifact_ids`, message: "must be true" });
+        }
+        if (approval?.require_exact_artifact_digests !== true) {
+            errors.push({ path: `${path}.reuse.canonical.approval_reuse.require_exact_artifact_digests`, message: "must be true" });
+        }
+        for (const field of [
+            "diagnosis_spec",
+            "diagnosis_contract",
+            "diagnosis_review",
+            "diagnosis_review_verdict",
+        ]) {
+            validateIdentifier(reuse.outputs?.[field], `${path}.reuse.outputs.${field}`);
+        }
+    }
+}
 export function validateController(controller, roleNames, workflows, path) {
     const errors = [];
     if (!controller.name) {
@@ -168,7 +243,17 @@ export function validateController(controller, roleNames, workflows, path) {
         errors.push({ path: `${path}.stop_format`, message: "stop_format must be 'configured_stop_report' or legacy 'zh_three_part'" });
     }
     if (controller.policy !== undefined) {
-        validateControllerPolicy(controller.policy, `${path}.policy`, errors);
+        errors.push({
+            path: `${path}.policy`,
+            message: "legacy string policy is unsupported; use runtime_program",
+        });
+    }
+    if (kindMetadata?.kind === "fix_loop" && controller.runtime_program === undefined) {
+        errors.push({
+            path: `${path}.runtime_program`,
+            message: "fix_loop controller requires a typed runtime_program",
+        });
     }
+    validateRuntimeProgram(controller, diagnosisWorkflow, fixWorkflow, `${path}.runtime_program`, errors);
     return errors;
 }

package/dist/schema/workflow-authoring-contract.js

@@ -26,6 +26,7 @@ const STEP_FIELDS = {
     run_if: { required: false, type: "string" },
     prompt: { required: false, type: "string" },
     completion: { required: false, type: "CompletionCheck[]" },
+    canonical_runtime: { required: false, type: "CanonicalRuntimeStepDef" },
     checkpoints: { required: false, type: "StepCheckpoint[]" },
     handoff: { required: false, type: "StepHandoff" },
     isolation: { required: false, type: "WorkflowIsolation", allowed_values: WORKFLOW_ISOLATION_VALUES },
@@ -63,6 +64,7 @@ const HANDOFF_FIELDS = {
     path: { required: false, type: "string" },
     name: { required: false, type: "string" },
     artifact_id: { required: false, type: "string" },
+    schema_ref: { required: false, type: "string" },
     from: { required: false, type: "string" },
     required: { required: false, type: "boolean", notes: "Defaults to true." },
     description: { required: true, type: "string" },

package/dist/schema/yaml-parser.js

@@ -9,7 +9,7 @@
  * Zero external dependencies.
  */
 export function parseYAML(input) {
-    const lines = input.split("\n");
+    const lines = input.replace(/\r\n?/g, "\n").split("\n");
     const result = parseBlock(lines, 0, 0);
     return result.value;
 }

package/dist/templates/flutter-rewrite-new.dna.yaml

@@ -55,6 +55,7 @@ variables:
   test_command:
     description: "Command that verifies the target module"
     default: "flutter test"
+    runtime_type: trusted_verifier_command
   target_scope:
     description: "Allowed write scope for the rewrite step"
     default: "v2/**"