intentdna 1.7.5 → 1.8.1

package/dist/schema/types.d.ts

@@ -96,7 +96,8 @@ export interface VerifierCommandPolicy {
     allow_builtin_asserts?: string[];
 }
 /** Handoff artifact type — what kind of artifact is passed between steps */
-export type HandoffType = "file" | "directory" | "test_result" | "git_commit" | "summary" | "state";
+export declare const HANDOFF_TYPE_VALUES: readonly ["file", "directory", "test_result", "git_commit", "summary", "state"];
+export type HandoffType = typeof HANDOFF_TYPE_VALUES[number];
 /** A single artifact consumed or produced by a workflow step */
 export interface HandoffArtifact {
     type: HandoffType;
@@ -142,14 +143,18 @@ export interface StepHandoff {
 export interface TransitionDef {
     from: string;
     to: string;
-    condition: "pass" | "fail" | "always" | "error";
+    condition: TransitionCondition;
 }
+export declare const TRANSITION_CONDITION_VALUES: readonly ["pass", "fail", "always", "error"];
+export type TransitionCondition = typeof TRANSITION_CONDITION_VALUES[number];
 /** Retry policy for the workflow */
 export interface RetryPolicy {
     max_retries: number;
     retry_from?: string;
-    backoff?: "none" | "linear" | "exponential";
+    backoff?: RetryBackoff;
 }
+export declare const RETRY_BACKOFF_VALUES: readonly ["none", "linear", "exponential"];
+export type RetryBackoff = typeof RETRY_BACKOFF_VALUES[number];
 /** Predefined checkpoint assertion types — compiler knows how to translate each to shell */
 export type CheckpointAssertType = "clean_working_tree" | "no_test_regression" | "lint_passing" | "build_passing";
 /** Step checkpoint — condition that must be met before transitioning to next step */
@@ -157,8 +162,18 @@ export interface StepCheckpoint {
     assert: CheckpointAssertType | string;
     command?: string;
     message: string;
-    action?: "block" | "warn";
-}
+    action?: CheckpointAction;
+}
+export declare const CHECKPOINT_ACTION_VALUES: readonly ["block", "warn"];
+export type CheckpointAction = typeof CHECKPOINT_ACTION_VALUES[number];
+export declare const WORKFLOW_ISOLATION_VALUES: readonly ["none", "worktree", "auto"];
+export type WorkflowIsolation = typeof WORKFLOW_ISOLATION_VALUES[number];
+export declare const WORKFLOW_STEP_FAILURE_VALUES: readonly ["retry_with_feedback", "handoff", "skip"];
+export type WorkflowStepFailureAction = typeof WORKFLOW_STEP_FAILURE_VALUES[number];
+export declare const WORKFLOW_HANDOFF_EXHAUSTED_VALUES: readonly ["skip", "stop"];
+export type WorkflowHandoffExhaustedAction = typeof WORKFLOW_HANDOFF_EXHAUSTED_VALUES[number];
+export declare const WORKFLOW_MERGE_STRATEGY_VALUES: readonly ["escalate"];
+export type WorkflowMergeStrategy = typeof WORKFLOW_MERGE_STRATEGY_VALUES[number];
 /** Completion check for a workflow step */
 export interface CompletionCheck {
     file_exists?: string;
@@ -181,17 +196,17 @@ export interface WorkflowStepDef {
     completion?: CompletionCheck[];
     checkpoints?: StepCheckpoint[];
     handoff?: StepHandoff;
-    isolation?: "none" | "worktree" | "auto";
+    isolation?: WorkflowIsolation;
     enforce?: {
         read_only?: boolean;
         relax_after_iteration?: number;
         additional_write_paths?: string[];
     };
     max_attempts?: number;
-    on_fail?: "retry_with_feedback" | "handoff" | "skip";
+    on_fail?: WorkflowStepFailureAction;
     handoff_to?: string;
     max_handoffs?: number;
-    on_handoff_exhausted?: "skip" | "stop";
+    on_handoff_exhausted?: WorkflowHandoffExhaustedAction;
     blocked_items_path?: string;
 }
 /** Top-level workflow definition */
@@ -204,10 +219,10 @@ export interface WorkflowDef {
     max_rounds?: number;
     produces?: HandoffArtifact[];
     consumes?: HandoffArtifact[];
-    default_isolation?: "none" | "worktree" | "auto";
-    merge_strategy?: "escalate";
+    default_isolation?: WorkflowIsolation;
+    merge_strategy?: WorkflowMergeStrategy;
 }
-export type ControllerKind = "fix_loop" | "flutter_rewrite_fix_loop";
+export type ControllerKind = "fix_loop" | "flutter_rewrite_fix_loop" | "sequential";
 export interface ControllerPolicyDef {
     diagnosis_reuse_criteria?: string[];
     progress_provenance_checks?: string[];
@@ -223,18 +238,13 @@ export interface ControllerDef {
     kind: ControllerKind;
     max_rounds: number;
     progress_artifact_path: string;
-    diagnosis_workflow: string;
-    fix_workflow: string;
-    diagnosis_artifact_path: string;
-    diagnosis_review_artifact_path: string;
-    review_artifact_path: string;
-    roles: {
-        analyzer: string;
-        analysis_reviewer: string;
-        surgeon: string;
-        fix_reviewer: string;
-        test_runner: string;
-    };
+    workflow?: string;
+    diagnosis_workflow?: string;
+    fix_workflow?: string;
+    diagnosis_artifact_path?: string;
+    diagnosis_review_artifact_path?: string;
+    review_artifact_path?: string;
+    roles: Record<string, string>;
     stop_format: "configured_stop_report" | "zh_three_part";
     policy?: ControllerPolicyDef;
 }
@@ -479,6 +489,7 @@ export interface StepEnforceRule {
 export interface WorkflowIR {
     workflow_name: string;
     namespace: string;
+    step_ids?: string[];
     step_checkpoints: StepCheckpointIR[];
     active_roles: string[];
     handoff_chain: HandoffChainEntry[];
@@ -502,6 +513,7 @@ export interface CompletedArtifactEntry {
 /** Runtime workflow state written to .dna/state/workflow.json */
 export interface WorkflowState {
     active: boolean;
+    workflow_asset?: string;
     workflow: string;
     current_step: string;
     current_role: string;

package/dist/schema/types.js

@@ -7,4 +7,13 @@
  *   Layer 3: Regulatory Regions (context-dependent expression)
  *   Layer 4: Epigenetic Markers (experience-driven modulation)
  */
-export {};
+// ── Workflow System ─────────────────────────────────────────
+/** Handoff artifact type — what kind of artifact is passed between steps */
+export const HANDOFF_TYPE_VALUES = ["file", "directory", "test_result", "git_commit", "summary", "state"];
+export const TRANSITION_CONDITION_VALUES = ["pass", "fail", "always", "error"];
+export const RETRY_BACKOFF_VALUES = ["none", "linear", "exponential"];
+export const CHECKPOINT_ACTION_VALUES = ["block", "warn"];
+export const WORKFLOW_ISOLATION_VALUES = ["none", "worktree", "auto"];
+export const WORKFLOW_STEP_FAILURE_VALUES = ["retry_with_feedback", "handoff", "skip"];
+export const WORKFLOW_HANDOFF_EXHAUSTED_VALUES = ["skip", "stop"];
+export const WORKFLOW_MERGE_STRATEGY_VALUES = ["escalate"];

package/dist/schema/validate.js

@@ -8,6 +8,7 @@
  *   - No circular inheritance
  */
 import { isAbsolute } from "node:path";
+import { CHECKPOINT_ACTION_VALUES, HANDOFF_TYPE_VALUES, RETRY_BACKOFF_VALUES, TRANSITION_CONDITION_VALUES, WORKFLOW_HANDOFF_EXHAUSTED_VALUES, WORKFLOW_ISOLATION_VALUES, WORKFLOW_MERGE_STRATEGY_VALUES, WORKFLOW_STEP_FAILURE_VALUES, } from "./types.js";
 import { validateController } from "./validators/controllers.js";
 const SAFE_GENERATED_IDENTIFIER = /^[A-Za-z0-9_-]+$/;
 const SAFE_GENERATED_DISPLAY_NAME = /^[A-Za-z0-9][A-Za-z0-9 _-]*$/;
@@ -503,25 +504,22 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
         }
         // on_fail: must be a valid enum value
         if (step.on_fail !== undefined) {
-            const validOnFail = ["retry_with_feedback", "handoff", "skip"];
-            if (!validOnFail.includes(step.on_fail)) {
-                errors.push({ path: `${stepPath}.on_fail`, message: `must be one of: ${validOnFail.join(", ")}` });
+            if (!WORKFLOW_STEP_FAILURE_VALUES.includes(step.on_fail)) {
+                errors.push({ path: `${stepPath}.on_fail`, message: `must be one of: ${WORKFLOW_STEP_FAILURE_VALUES.join(", ")}` });
             }
         }
         // on_handoff_exhausted: must be a valid enum value
         if (step.on_handoff_exhausted !== undefined) {
-            const validExhausted = ["skip", "stop"];
-            if (!validExhausted.includes(step.on_handoff_exhausted)) {
-                errors.push({ path: `${stepPath}.on_handoff_exhausted`, message: `must be one of: ${validExhausted.join(", ")}` });
+            if (!WORKFLOW_HANDOFF_EXHAUSTED_VALUES.includes(step.on_handoff_exhausted)) {
+                errors.push({ path: `${stepPath}.on_handoff_exhausted`, message: `must be one of: ${WORKFLOW_HANDOFF_EXHAUSTED_VALUES.join(", ")}` });
             }
         }
         // isolation: must be a valid enum value
         if (step.isolation !== undefined) {
-            const validIsolation = ["none", "worktree", "auto"];
-            if (!validIsolation.includes(step.isolation)) {
+            if (!WORKFLOW_ISOLATION_VALUES.includes(step.isolation)) {
                 errors.push({
                     path: `${stepPath}.isolation`,
-                    message: `must be one of: ${validIsolation.join(", ")}`,
+                    message: `must be one of: ${WORKFLOW_ISOLATION_VALUES.join(", ")}`,
                 });
             }
         }
@@ -540,6 +538,12 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
             for (let j = 0; j < artifacts.length; j++) {
                 const artifact = artifacts[j];
                 const artifactPath = `${stepPath}.handoff.${direction}[${j}]`;
+                if (!HANDOFF_TYPE_VALUES.includes(artifact.type)) {
+                    errors.push({ path: `${artifactPath}.type`, message: `must be one of: ${HANDOFF_TYPE_VALUES.join(", ")}` });
+                }
+                if (!artifact.description) {
+                    errors.push({ path: `${artifactPath}.description`, message: "handoff artifact requires 'description'" });
+                }
                 if (artifact.required !== false && artifact.type !== "git_commit" && !artifact.path && !artifact.name && !artifact.artifact_id) {
                     errors.push({ path: artifactPath, message: "required handoff artifacts must define path, name, or artifact_id" });
                 }
@@ -567,7 +571,7 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
                     if (!cp.message) {
                         errors.push({ path: `${cpPath}.message`, message: "checkpoint requires 'message'" });
                     }
-                    if (cp.action && cp.action !== "block" && cp.action !== "warn") {
+                    if (cp.action && !CHECKPOINT_ACTION_VALUES.includes(cp.action)) {
                         errors.push({ path: `${cpPath}.action`, message: "checkpoint action must be 'block' or 'warn'" });
                     }
                 }
@@ -607,26 +611,23 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
     }
     // Validate default_isolation
     if (workflow.default_isolation !== undefined) {
-        const validIsolation = ["none", "worktree", "auto"];
-        if (!validIsolation.includes(workflow.default_isolation)) {
+        if (!WORKFLOW_ISOLATION_VALUES.includes(workflow.default_isolation)) {
             errors.push({
                 path: `${path}.default_isolation`,
-                message: `must be one of: ${validIsolation.join(", ")}`,
+                message: `must be one of: ${WORKFLOW_ISOLATION_VALUES.join(", ")}`,
             });
         }
     }
     // Validate merge_strategy
     if (workflow.merge_strategy !== undefined) {
-        const validStrategies = ["escalate"];
-        if (!validStrategies.includes(workflow.merge_strategy)) {
+        if (!WORKFLOW_MERGE_STRATEGY_VALUES.includes(workflow.merge_strategy)) {
             errors.push({
                 path: `${path}.merge_strategy`,
-                message: `must be one of: ${validStrategies.join(", ")}`,
+                message: `must be one of: ${WORKFLOW_MERGE_STRATEGY_VALUES.join(", ")}`,
             });
         }
     }
     // Validate transitions
-    const validConditions = ["pass", "fail", "always", "error"];
     for (let i = 0; i < (workflow.transitions?.length ?? 0); i++) {
         const t = workflow.transitions[i];
         const tPath = `${path}.transitions[${i}]`;
@@ -642,10 +643,10 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
         else if (!stepIds.has(t.to)) {
             errors.push({ path: `${tPath}.to`, message: `transition references unknown step '${t.to}'` });
         }
-        if (!t.condition || !validConditions.includes(t.condition)) {
+        if (!t.condition || !TRANSITION_CONDITION_VALUES.includes(t.condition)) {
             errors.push({
                 path: `${tPath}.condition`,
-                message: `transition condition must be one of: ${validConditions.join(", ")}`,
+                message: `transition condition must be one of: ${TRANSITION_CONDITION_VALUES.join(", ")}`,
             });
         }
     }
@@ -665,11 +666,10 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
                 message: `retry_from references unknown step '${rp.retry_from}'`,
             });
         }
-        const validBackoff = ["none", "linear", "exponential"];
-        if (rp.backoff && !validBackoff.includes(rp.backoff)) {
+        if (rp.backoff && !RETRY_BACKOFF_VALUES.includes(rp.backoff)) {
             errors.push({
                 path: `${rpPath}.backoff`,
-                message: `backoff must be one of: ${validBackoff.join(", ")}`,
+                message: `backoff must be one of: ${RETRY_BACKOFF_VALUES.join(", ")}`,
             });
         }
     }

package/dist/schema/validators/controllers.js

@@ -54,12 +54,11 @@ function validateControllerPolicy(policy, path, errors) {
         errors.push({ path: `${path}.progress_provenance_failure`, message: "must be a non-empty string" });
     }
 }
-function validateControllerWorkflowRoles(workflow, requiredRoleKeys, roleMap, path, errors) {
+function validateControllerWorkflowRoles(workflow, roleEntries, path, errors) {
     if (!workflow)
         return;
     const workflowRoles = new Set(workflow.steps.map((step) => step.role));
-    for (const roleKey of requiredRoleKeys) {
-        const roleName = roleMap[roleKey];
+    for (const [roleKey, roleName] of roleEntries) {
         if (typeof roleName !== "string" || !roleName)
             continue;
         if (!workflowRoles.has(roleName)) {
@@ -91,32 +90,40 @@ export function validateController(controller, roleNames, workflows, path) {
     if (!Number.isInteger(controller.max_rounds) || controller.max_rounds < 1 || controller.max_rounds > 20) {
         errors.push({ path: `${path}.max_rounds`, message: "max_rounds must be an integer in 1..20" });
     }
-    const requiredStringFields = [
-        "progress_artifact_path",
-        "diagnosis_workflow",
-        "fix_workflow",
-        "diagnosis_artifact_path",
-        "diagnosis_review_artifact_path",
-        "review_artifact_path",
-    ];
+    const requiredStringFields = kindMetadata?.kind === "sequential"
+        ? ["progress_artifact_path", "workflow"]
+        : [
+            "progress_artifact_path",
+            "diagnosis_workflow",
+            "fix_workflow",
+            "diagnosis_artifact_path",
+            "diagnosis_review_artifact_path",
+            "review_artifact_path",
+        ];
     for (const field of requiredStringFields) {
         if (typeof controller[field] !== "string" || !controller[field]) {
             errors.push({ path: `${path}.${field}`, message: "must be a non-empty string" });
         }
     }
-    const artifactPathFields = [
-        "progress_artifact_path",
-        "diagnosis_artifact_path",
-        "diagnosis_review_artifact_path",
-        "review_artifact_path",
-    ];
+    const artifactPathFields = kindMetadata?.kind === "sequential"
+        ? ["progress_artifact_path"]
+        : [
+            "progress_artifact_path",
+            "diagnosis_artifact_path",
+            "diagnosis_review_artifact_path",
+            "review_artifact_path",
+        ];
     for (const field of artifactPathFields) {
         if (typeof controller[field] === "string" && !isSafeControllerArtifactPath(controller[field])) {
             errors.push({ path: `${path}.${field}`, message: "must be a relative .dna/ artifact template containing $ARGUMENTS without glob, brace, absolute, or parent traversal syntax" });
         }
     }
+    const workflow = controller.workflow ? workflows[controller.workflow] : undefined;
     const diagnosisWorkflow = controller.diagnosis_workflow ? workflows[controller.diagnosis_workflow] : undefined;
     const fixWorkflow = controller.fix_workflow ? workflows[controller.fix_workflow] : undefined;
+    if (controller.workflow && !workflow) {
+        errors.push({ path: `${path}.workflow`, message: `references unknown workflow '${controller.workflow}'` });
+    }
     if (controller.diagnosis_workflow && !diagnosisWorkflow) {
         errors.push({ path: `${path}.diagnosis_workflow`, message: `references unknown workflow '${controller.diagnosis_workflow}'` });
     }
@@ -128,8 +135,14 @@ export function validateController(controller, roleNames, workflows, path) {
     if (!roleMap || typeof roleMap !== "object") {
         errors.push({ path: `${path}.roles`, message: "controller requires roles" });
     }
+    else if (kindMetadata?.kind === "sequential" && Object.keys(roleMap).length === 0) {
+        errors.push({ path: `${path}.roles`, message: "sequential controller requires at least one workflow role" });
+    }
     else {
-        for (const roleKey of requiredRoles) {
+        const roleKeysToValidate = kindMetadata?.kind === "sequential"
+            ? Object.keys(roleMap)
+            : requiredRoles;
+        for (const roleKey of roleKeysToValidate) {
             const roleName = roleMap[roleKey];
             if (typeof roleName !== "string" || !roleName) {
                 errors.push({ path: `${path}.roles.${roleKey}`, message: "must be a non-empty role name" });
@@ -143,8 +156,13 @@ export function validateController(controller, roleNames, workflows, path) {
         }
     }
     if (roleMap && typeof roleMap === "object") {
-        validateControllerWorkflowRoles(diagnosisWorkflow, kindMetadata?.diagnosisRoleKeys ?? ["analyzer", "analysis_reviewer"], roleMap, `${path}.diagnosis_workflow`, errors);
-        validateControllerWorkflowRoles(fixWorkflow, kindMetadata?.fixRoleKeys ?? ["surgeon", "fix_reviewer", "test_runner"], roleMap, `${path}.fix_workflow`, errors);
+        if (kindMetadata?.kind === "sequential") {
+            validateControllerWorkflowRoles(workflow, Object.entries(roleMap), `${path}.workflow`, errors);
+        }
+        else {
+            validateControllerWorkflowRoles(diagnosisWorkflow, (kindMetadata?.diagnosisRoleKeys ?? ["analyzer", "analysis_reviewer"]).map((roleKey) => [roleKey, roleMap[roleKey]]), `${path}.diagnosis_workflow`, errors);
+            validateControllerWorkflowRoles(fixWorkflow, (kindMetadata?.fixRoleKeys ?? ["surgeon", "fix_reviewer", "test_runner"]).map((roleKey) => [roleKey, roleMap[roleKey]]), `${path}.fix_workflow`, errors);
+        }
     }
     if (controller.stop_format !== "configured_stop_report" && controller.stop_format !== "zh_three_part") {
         errors.push({ path: `${path}.stop_format`, message: "stop_format must be 'configured_stop_report' or legacy 'zh_three_part'" });

package/dist/schema/workflow-authoring-contract.d.ts

@@ -0,0 +1,29 @@
+export interface AuthoringFieldConstraint {
+    name: string;
+    required: boolean;
+    type: string;
+    allowed_values?: readonly string[];
+    notes?: string;
+}
+export declare const WORKFLOW_AUTHORING_SCHEMA: {
+    readonly source: "src/schema/workflow-authoring-contract.ts; field maps are exhaustive against src/schema/types.ts";
+    readonly workflow: readonly AuthoringFieldConstraint[];
+    readonly step: readonly AuthoringFieldConstraint[];
+    readonly role: readonly AuthoringFieldConstraint[];
+    readonly tool_permissions: readonly AuthoringFieldConstraint[];
+    readonly scope: readonly AuthoringFieldConstraint[];
+    readonly handoff_artifact: {
+        readonly fields: readonly AuthoringFieldConstraint[];
+        readonly type_values: readonly ["file", "directory", "test_result", "git_commit", "summary", "state"];
+        readonly required_fields: string[];
+        readonly optional_fields: string[];
+    };
+    readonly checkpoint: {
+        readonly fields: readonly AuthoringFieldConstraint[];
+        readonly required_fields: string[];
+        readonly optional_fields: string[];
+        readonly action_values: readonly ["block", "warn"];
+    };
+    readonly transition: readonly AuthoringFieldConstraint[];
+    readonly retry_policy: readonly AuthoringFieldConstraint[];
+};

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

@@ -0,0 +1,109 @@
+import { CHECKPOINT_ACTION_VALUES, HANDOFF_TYPE_VALUES, RETRY_BACKOFF_VALUES, TRANSITION_CONDITION_VALUES, WORKFLOW_HANDOFF_EXHAUSTED_VALUES, WORKFLOW_ISOLATION_VALUES, WORKFLOW_MERGE_STRATEGY_VALUES, WORKFLOW_STEP_FAILURE_VALUES, } from "./types.js";
+function fieldsFrom(definitions) {
+    return Object.entries(definitions).map(([name, definition]) => ({
+        name,
+        ...definition,
+    }));
+}
+const WORKFLOW_FIELDS = {
+    name: { required: true, type: "string", notes: "Human-readable workflow name." },
+    description: { required: false, type: "string" },
+    steps: { required: true, type: "WorkflowStepDef[]", notes: "At least one step; ids must be unique within the workflow." },
+    transitions: { required: false, type: "TransitionDef[]" },
+    retry_policy: { required: false, type: "RetryPolicy" },
+    max_rounds: { required: false, type: "number", notes: "Alias for retry rounds when retry_policy is omitted." },
+    produces: { required: false, type: "HandoffArtifact[]" },
+    consumes: { required: false, type: "HandoffArtifact[]" },
+    default_isolation: { required: false, type: "WorkflowIsolation", allowed_values: WORKFLOW_ISOLATION_VALUES },
+    merge_strategy: { required: false, type: "WorkflowMergeStrategy", allowed_values: WORKFLOW_MERGE_STRATEGY_VALUES },
+};
+const STEP_FIELDS = {
+    id: { required: true, type: "string", notes: "Stable safe identifier, unique within the workflow." },
+    role: { required: true, type: "string", notes: "Must reference a declared role in the same asset." },
+    description: { required: false, type: "string" },
+    depends_on: { required: false, type: "string[]" },
+    optional: { required: false, type: "boolean" },
+    run_if: { required: false, type: "string" },
+    prompt: { required: false, type: "string" },
+    completion: { required: false, type: "CompletionCheck[]" },
+    checkpoints: { required: false, type: "StepCheckpoint[]" },
+    handoff: { required: false, type: "StepHandoff" },
+    isolation: { required: false, type: "WorkflowIsolation", allowed_values: WORKFLOW_ISOLATION_VALUES },
+    enforce: { required: false, type: "step-level enforcement object" },
+    max_attempts: { required: false, type: "number" },
+    on_fail: { required: false, type: "WorkflowStepFailureAction", allowed_values: WORKFLOW_STEP_FAILURE_VALUES },
+    handoff_to: { required: false, type: "string" },
+    max_handoffs: { required: false, type: "number" },
+    on_handoff_exhausted: { required: false, type: "WorkflowHandoffExhaustedAction", allowed_values: WORKFLOW_HANDOFF_EXHAUSTED_VALUES },
+    blocked_items_path: { required: false, type: "string" },
+};
+const ROLE_FIELDS = {
+    description: { required: true, type: "string" },
+    tool_permissions: { required: false, type: "ToolPermissions" },
+    scope: { required: false, type: "ScopeDef" },
+    output_schema: { required: false, type: "string|OutputSchema" },
+    model: { required: false, type: "string", notes: "Harness hint only; use human for an explicit user-owned gate or interactive for a main-session external-agent step." },
+    activates_genes: { required: false, type: "string[]" },
+    suppresses_genes: { required: false, type: "string[]" },
+    post_checks: { required: false, type: "string[]" },
+    instructions: { required: false, type: "string[]" },
+    success_criteria: { required: false, type: "string[]" },
+    failure_modes: { required: false, type: "string[]" },
+};
+const TOOL_PERMISSION_FIELDS = {
+    allow: { required: false, type: "string[]" },
+    deny: { required: false, type: "string[]" },
+};
+const SCOPE_FIELDS = {
+    read: { required: false, type: "string[]" },
+    write: { required: false, type: "string[]" },
+};
+const HANDOFF_FIELDS = {
+    type: { required: true, type: "HandoffType", allowed_values: HANDOFF_TYPE_VALUES },
+    path: { required: false, type: "string" },
+    name: { required: false, type: "string" },
+    artifact_id: { required: false, type: "string" },
+    from: { required: false, type: "string" },
+    required: { required: false, type: "boolean", notes: "Defaults to true." },
+    description: { required: true, type: "string" },
+};
+const CHECKPOINT_FIELDS = {
+    assert: { required: true, type: "string" },
+    command: { required: false, type: "string", notes: "Required for custom assertions that are not built-ins." },
+    message: { required: true, type: "string" },
+    action: { required: false, type: "CheckpointAction", allowed_values: CHECKPOINT_ACTION_VALUES, notes: "Defaults to block." },
+};
+const TRANSITION_FIELDS = {
+    from: { required: true, type: "string" },
+    to: { required: true, type: "string" },
+    condition: { required: true, type: "TransitionCondition", allowed_values: TRANSITION_CONDITION_VALUES },
+};
+const RETRY_POLICY_FIELDS = {
+    max_retries: { required: true, type: "number", notes: "Must be zero or greater." },
+    retry_from: { required: false, type: "string", notes: "Must reference an existing step when present." },
+    backoff: { required: false, type: "RetryBackoff", allowed_values: RETRY_BACKOFF_VALUES },
+};
+const handoffFields = fieldsFrom(HANDOFF_FIELDS);
+const checkpointFields = fieldsFrom(CHECKPOINT_FIELDS);
+export const WORKFLOW_AUTHORING_SCHEMA = {
+    source: "src/schema/workflow-authoring-contract.ts; field maps are exhaustive against src/schema/types.ts",
+    workflow: fieldsFrom(WORKFLOW_FIELDS),
+    step: fieldsFrom(STEP_FIELDS),
+    role: fieldsFrom(ROLE_FIELDS),
+    tool_permissions: fieldsFrom(TOOL_PERMISSION_FIELDS),
+    scope: fieldsFrom(SCOPE_FIELDS),
+    handoff_artifact: {
+        fields: handoffFields,
+        type_values: HANDOFF_TYPE_VALUES,
+        required_fields: handoffFields.filter((field) => field.required).map((field) => field.name),
+        optional_fields: handoffFields.filter((field) => !field.required).map((field) => field.name),
+    },
+    checkpoint: {
+        fields: checkpointFields,
+        required_fields: checkpointFields.filter((field) => field.required).map((field) => field.name),
+        optional_fields: checkpointFields.filter((field) => !field.required).map((field) => field.name),
+        action_values: CHECKPOINT_ACTION_VALUES,
+    },
+    transition: fieldsFrom(TRANSITION_FIELDS),
+    retry_policy: fieldsFrom(RETRY_POLICY_FIELDS),
+};

package/dist/schema/yaml-parser.js

@@ -224,6 +224,24 @@ function parseScalar(s) {
     // Inline empty object: {}
     if (s === "{}")
         return {};
+    // Inline object: { key: value, other: "quoted" }
+    if (s.startsWith("{") && s.endsWith("}")) {
+        const inner = s.slice(1, -1).trim();
+        if (inner === "")
+            return {};
+        const result = {};
+        for (const entry of splitInlineArray(inner)) {
+            const colonIdx = findKeyColon(entry);
+            if (colonIdx <= 0)
+                return s;
+            const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+            const value = entry.slice(colonIdx + 1).trim();
+            if (!key)
+                return s;
+            result[key] = parseScalar(value);
+        }
+        return result;
+    }
     // Quoted string
     if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
         return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");

package/dist/templates/api-backend.dna.yaml

@@ -5,6 +5,25 @@
 version: "0.1.0"
 id: template_api_backend
 name: API Backend Standards
+purpose: Provide a backend API baseline for security, quality, database safety, and reviewable implementation.
+maturity: draft
+fit:
+  - Node.js, Python, or service API projects that need a local governance baseline.
+  - Teams starting from API standards before authoring a richer workflow asset.
+not_for:
+  - Replacing endpoint-specific design, tests, or threat modeling.
+  - Online execution, cloud deployment, or database mutation by the template itself.
+inputs:
+  - API task scope
+  - endpoint and data model context
+  - security and database constraints
+outputs:
+  - backend development guardrails
+  - API quality review notes
+  - database safety reminders
+lineage:
+  source: built-in backend standards template
+  reference: src/templates/api-backend.dna.yaml
 type: project
 namespace: be
 

package/dist/templates/brainstorming-first.dna.yaml

@@ -6,6 +6,25 @@
 version: "0.1.0"
 id: template_brainstorming_first
 name: Brainstorming First
+purpose: Force design, Socratic refinement, and task decomposition before implementation starts.
+maturity: draft
+fit:
+  - Early-stage tasks where requirements, tradeoffs, or implementation chunks are unclear.
+  - Planning work that should produce small verifiable steps before coding.
+not_for:
+  - Already approved implementation slices with clear acceptance criteria.
+  - Letting brainstorming replace tests, review, or delivery evidence.
+inputs:
+  - raw idea or task request
+  - known constraints and open questions
+  - desired outcome or decision point
+outputs:
+  - refined requirements
+  - decomposed task plan
+  - implementation readiness notes
+lineage:
+  source: brainstorming and writing-plans workflow shape
+  reference: src/templates/brainstorming-first.dna.yaml
 type: project
 namespace: bs
 

package/dist/templates/code-cleanup.dna.yaml

@@ -1,6 +1,25 @@
 version: "0.1.0"
 id: template_code_cleanup
 name: Code Cleanup (Regression-Safe)
+purpose: Clean code in small behavior-preserving passes with tests between each smell-focused edit.
+maturity: reviewed
+fit:
+  - Refactors or cleanup where existing behavior must stay stable.
+  - Reducing dead code, duplication, naming issues, or local complexity under test coverage.
+not_for:
+  - Mixing feature work into cleanup.
+  - Large unverified rewrites or cleanup without regression checks.
+inputs:
+  - cleanup scope
+  - current tests or behavior evidence
+  - identified smell category
+outputs:
+  - scoped cleanup diff
+  - regression verification evidence
+  - remaining cleanup risk notes
+lineage:
+  source: built-in regression-safe cleanup workflow
+  reference: docs/archive/fix-notes/refactoring-workflow-principles.md
 type: project
 namespace: cc
 

package/dist/templates/code-review-pipeline.dna.yaml

@@ -5,6 +5,24 @@
 version: "0.1.0"
 id: template_code_review_pipeline
 name: Code Review Pipeline
+purpose: Run structured implementation review with actionable findings, tests, and follow-up fixes before merge or adoption.
+maturity: reviewed
+fit:
+  - Pull request or patch review that needs explicit PASS/FAIL evidence.
+  - Separating reviewer feedback from implementation fixes.
+not_for:
+  - Rubber-stamp approval.
+  - Replacing targeted tests or security checks with prose.
+inputs:
+  - changed files
+  - task specification
+  - test results
+outputs:
+  - review findings with code references
+  - required fixes
+  - re-review verdict
+lineage:
+  source: requesting-code-review and receiving-code-review workflow shape
 type: project
 namespace: crp