intentdna 1.7.4 → 1.8.0

package/dist/workflow/draft.js

@@ -0,0 +1,800 @@
+const EXAMPLES = [
+    {
+        id: "dev_pipeline",
+        label: "Development Pipeline",
+        summary: "Plan, implement, verify, and review a scoped engineering change.",
+        workflow: {
+            name: "draft-dev-pipeline",
+            description: "Draft engineering workflow.",
+            steps: [
+                {
+                    id: "plan",
+                    role: "planner",
+                    description: "Clarify task boundaries, assumptions, and acceptance criteria.",
+                    prompt: "Plan {{task_id}} with constraints, risks, and verification shape.",
+                    handoff: {
+                        produces: [{ type: "summary", name: "implementation_plan", description: "Plan summary and acceptance criteria." }],
+                    },
+                },
+                {
+                    id: "implement",
+                    role: "executor",
+                    description: "Implement the approved scoped change.",
+                    depends_on: ["plan"],
+                    prompt: "Implement {{task_id}} according to the approved plan. Keep edits scoped.",
+                    handoff: {
+                        consumes: [{ type: "summary", name: "implementation_plan", from: "plan", description: "Approved plan." }],
+                        produces: [{ type: "git_commit", description: "Implementation commit candidate." }],
+                    },
+                },
+                {
+                    id: "verify",
+                    role: "test-engineer",
+                    description: "Run build, tests, and targeted validation.",
+                    depends_on: ["implement"],
+                    prompt: "Verify {{task_id}} with build, tests, and focused manual checks where needed.",
+                    handoff: {
+                        consumes: [{ type: "git_commit", from: "implement", description: "Implementation commit candidate." }],
+                        produces: [{ type: "test_result", path: "reports/{{task_id}}-verification.txt", description: "Verification result." }],
+                    },
+                },
+                {
+                    id: "review",
+                    role: "reviewer",
+                    description: "Review the change against acceptance criteria and evidence.",
+                    depends_on: ["verify"],
+                    prompt: "Review {{task_id}} for regressions, missing tests, and boundary violations.",
+                },
+            ],
+            retry_policy: {
+                max_retries: 1,
+                retry_from: "implement",
+                backoff: "none",
+            },
+        },
+    },
+    {
+        id: "evidence_review",
+        label: "Evidence Review",
+        summary: "Collect, classify, and summarize runtime or workflow evidence before human review.",
+        workflow: {
+            name: "draft-evidence-review",
+            description: "Draft evidence review workflow.",
+            steps: [
+                {
+                    id: "collect",
+                    role: "explore",
+                    description: "Collect local evidence from read-only sources.",
+                    prompt: "Collect evidence for {{task_id}} without mutating project state.",
+                    handoff: {
+                        produces: [{ type: "summary", name: "evidence_index", description: "Evidence source index." }],
+                    },
+                },
+                {
+                    id: "classify",
+                    role: "quality-reviewer",
+                    description: "Classify evidence authority, gaps, and unsupported claims.",
+                    depends_on: ["collect"],
+                    prompt: "Classify evidence authority for {{task_id}} without upgrading weak evidence.",
+                    handoff: {
+                        consumes: [{ type: "summary", name: "evidence_index", from: "collect", description: "Evidence source index." }],
+                        produces: [{ type: "summary", name: "authority_review", description: "Authority review." }],
+                    },
+                },
+                {
+                    id: "human-review",
+                    role: "reviewer",
+                    description: "Prepare a human-readable review and open questions.",
+                    depends_on: ["classify"],
+                    prompt: "Prepare the review for {{task_id}} with unknown and unsupported fields visible.",
+                },
+            ],
+        },
+    },
+    {
+        id: "rewrite_governance",
+        label: "Rewrite Governance",
+        summary: "Lock intent and boundaries, rewrite safely, prove logic equivalence, and review evidence.",
+        workflow: {
+            name: "draft-rewrite-governance",
+            description: "Draft behavior-preserving rewrite workflow.",
+            steps: [
+                {
+                    id: "intent-lock",
+                    role: "planner",
+                    description: "Record the exact rewrite intent and non-goals.",
+                    prompt: "Lock the rewrite intent for {{task_id}}. Record non-goals and forbidden improvements.",
+                    handoff: {
+                        produces: [{ type: "summary", name: "intent_lock", description: "Intent, non-goals, and success definition." }],
+                    },
+                },
+                {
+                    id: "boundary-freeze",
+                    role: "architect",
+                    description: "Freeze read/write boundaries and allowed behavior deltas.",
+                    depends_on: ["intent-lock"],
+                    prompt: "Define source truth, write scope, allowed changes, and escalation rules for {{task_id}}.",
+                    handoff: {
+                        consumes: [{ type: "summary", name: "intent_lock", from: "intent-lock", description: "Intent lock." }],
+                        produces: [{ type: "summary", name: "boundary_contract", description: "Read/write boundaries and allowed deltas." }],
+                    },
+                },
+                {
+                    id: "baseline",
+                    role: "test-engineer",
+                    description: "Capture current behavior and verification baseline.",
+                    depends_on: ["boundary-freeze"],
+                    prompt: "Capture baseline behavior and tests for {{task_id}} before rewrite work starts.",
+                    handoff: {
+                        produces: [{ type: "test_result", name: "baseline_result", description: "Baseline behavior and verification evidence." }],
+                    },
+                },
+                {
+                    id: "rewrite",
+                    role: "executor",
+                    description: "Apply the smallest behavior-preserving rewrite.",
+                    depends_on: ["baseline"],
+                    prompt: "Rewrite {{task_id}} inside the approved boundary. Preserve behavior before improving structure.",
+                    handoff: {
+                        consumes: [
+                            { type: "summary", name: "boundary_contract", from: "boundary-freeze", description: "Boundary contract." },
+                            { type: "test_result", name: "baseline_result", from: "baseline", description: "Baseline evidence." },
+                        ],
+                        produces: [{ type: "git_commit", description: "Rewrite candidate." }],
+                    },
+                },
+                {
+                    id: "equivalence",
+                    role: "verifier",
+                    description: "Verify logic equivalence against the baseline.",
+                    depends_on: ["rewrite"],
+                    prompt: "Check logic equivalence for {{task_id}}. Escalate any behavior delta.",
+                    handoff: {
+                        consumes: [{ type: "git_commit", from: "rewrite", description: "Rewrite candidate." }],
+                        produces: [{ type: "test_result", name: "equivalence_result", description: "Equivalence verification result." }],
+                    },
+                },
+                {
+                    id: "review",
+                    role: "reviewer",
+                    description: "Review boundaries, equivalence evidence, and remaining risk.",
+                    depends_on: ["equivalence"],
+                    prompt: "Review {{task_id}} against intent lock, boundary contract, and equivalence evidence.",
+                },
+            ],
+            retry_policy: {
+                max_retries: 2,
+                retry_from: "rewrite",
+                backoff: "none",
+            },
+        },
+    },
+];
+const SAFE_FLOW = [
+    "describe workflow in natural language",
+    "choose example shape",
+    "generate draft only",
+    "review YAML preview",
+    "human approval",
+    "manual DNA config edit",
+    "dna validate",
+    "dna sync",
+];
+const FORBIDDEN = [
+    "write DNA config automatically",
+    "run dna sync automatically",
+    "edit runtime artifacts directly",
+    "treat draft YAML as policy truth",
+    "bypass human review",
+];
+const EDITABLE_OPERATIONS = ["insert_step", "add_verifier", "tighten_boundary", "split_step", "replace_role"];
+function slug(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return normalized || "workflow-draft";
+}
+function cloneWorkflow(workflow) {
+    return JSON.parse(JSON.stringify(workflow));
+}
+function uniqueStepId(steps, base) {
+    const existing = new Set(steps.map((step) => step.id));
+    let candidate = slug(base);
+    if (!candidate)
+        candidate = "new-step";
+    let suffix = 2;
+    while (existing.has(candidate)) {
+        candidate = `${slug(base)}-${suffix}`;
+        suffix++;
+    }
+    return candidate;
+}
+function selectedStepIndex(steps, targetStep) {
+    if (targetStep) {
+        const found = steps.findIndex((step) => step.id === targetStep);
+        if (found >= 0)
+            return found;
+    }
+    return Math.max(0, steps.length - 1);
+}
+function formatScalar(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value))
+        return value;
+    return JSON.stringify(value);
+}
+function formatYamlKey(value) {
+    if (/^[A-Za-z0-9_-]+$/.test(value))
+        return value;
+    return JSON.stringify(value);
+}
+function isYamlRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function appendMultilineString(lines, value, indent) {
+    const nested = " ".repeat(indent + 2);
+    for (const line of value.split("\n"))
+        lines.push(`${nested}${line}`);
+}
+function appendYamlPair(lines, key, value, indent) {
+    const prefix = " ".repeat(indent);
+    const yamlKey = formatYamlKey(key);
+    if (typeof value === "string") {
+        if (value.includes("\n")) {
+            lines.push(`${prefix}${yamlKey}: |`);
+            appendMultilineString(lines, value.endsWith("\n") ? value.slice(0, -1) : value, indent);
+        }
+        else {
+            lines.push(`${prefix}${yamlKey}: ${formatScalar(value)}`);
+        }
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        lines.push(`${prefix}${yamlKey}: ${String(value)}`);
+        return;
+    }
+    if (value === null || value === undefined) {
+        lines.push(`${prefix}${yamlKey}: null`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            lines.push(`${prefix}${yamlKey}: []`);
+            return;
+        }
+        lines.push(`${prefix}${yamlKey}:`);
+        appendYamlArray(lines, value, indent + 2);
+        return;
+    }
+    if (isYamlRecord(value)) {
+        const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+        if (entries.length === 0) {
+            lines.push(`${prefix}${yamlKey}: {}`);
+            return;
+        }
+        lines.push(`${prefix}${yamlKey}:`);
+        for (const [childKey, childValue] of entries)
+            appendYamlPair(lines, childKey, childValue, indent + 2);
+        return;
+    }
+    lines.push(`${prefix}${yamlKey}: ${formatScalar(String(value))}`);
+}
+function appendYamlArray(lines, values, indent) {
+    const prefix = " ".repeat(indent);
+    for (const value of values) {
+        if (typeof value === "string") {
+            if (value.includes("\n")) {
+                lines.push(`${prefix}- |`);
+                appendMultilineString(lines, value.endsWith("\n") ? value.slice(0, -1) : value, indent);
+            }
+            else {
+                lines.push(`${prefix}- ${formatScalar(value)}`);
+            }
+            continue;
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            lines.push(`${prefix}- ${String(value)}`);
+            continue;
+        }
+        if (value === null || value === undefined) {
+            lines.push(`${prefix}- null`);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            lines.push(`${prefix}- items:`);
+            appendYamlArray(lines, value, indent + 2);
+            continue;
+        }
+        if (isYamlRecord(value)) {
+            const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+            if (entries.length === 0) {
+                lines.push(`${prefix}- {}`);
+                continue;
+            }
+            const [[firstKey, firstValue], ...rest] = entries;
+            appendYamlArrayObjectFirstPair(lines, firstKey, firstValue, indent);
+            for (const [childKey, childValue] of rest)
+                appendYamlPair(lines, childKey, childValue, indent + 2);
+            continue;
+        }
+        lines.push(`${prefix}- ${formatScalar(String(value))}`);
+    }
+}
+function appendYamlArrayObjectFirstPair(lines, key, value, indent) {
+    const prefix = " ".repeat(indent);
+    const yamlKey = formatYamlKey(key);
+    if (typeof value === "string" && !value.includes("\n")) {
+        lines.push(`${prefix}- ${yamlKey}: ${formatScalar(value)}`);
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        lines.push(`${prefix}- ${yamlKey}: ${String(value)}`);
+        return;
+    }
+    if (value === null || value === undefined) {
+        lines.push(`${prefix}- ${yamlKey}: null`);
+        return;
+    }
+    lines.push(`${prefix}- ${yamlKey}:`);
+    if (typeof value === "string") {
+        appendMultilineString(lines, value.endsWith("\n") ? value.slice(0, -1) : value, indent);
+    }
+    else if (Array.isArray(value)) {
+        appendYamlArray(lines, value, indent + 2);
+    }
+    else if (isYamlRecord(value)) {
+        for (const [childKey, childValue] of Object.entries(value))
+            appendYamlPair(lines, childKey, childValue, indent + 2);
+    }
+    else {
+        lines.push(`${" ".repeat(indent + 2)}${formatScalar(String(value))}`);
+    }
+}
+function namespaceFromName(name) {
+    const parts = slug(name).split("-").filter(Boolean);
+    const candidate = parts.map((part) => part[0]).join("").slice(0, 8);
+    return candidate || "wf";
+}
+function formatHandoffArtifact(artifact, indent) {
+    const lines = [`${indent}- type: ${artifact.type}`];
+    if (artifact.path)
+        lines.push(`${indent}  path: ${formatScalar(artifact.path)}`);
+    if (artifact.name)
+        lines.push(`${indent}  name: ${formatScalar(artifact.name)}`);
+    if (artifact.from)
+        lines.push(`${indent}  from: ${formatScalar(artifact.from)}`);
+    if (artifact.required === false)
+        lines.push(`${indent}  required: false`);
+    lines.push(`${indent}  description: ${formatScalar(artifact.description)}`);
+    return lines;
+}
+function formatEvidenceLinks(evidence) {
+    if (!evidence || evidence.length === 0)
+        return [];
+    const lines = ["evidence:"];
+    for (const link of evidence) {
+        lines.push(`  - label: ${formatScalar(link.label)}`);
+        lines.push(`    kind: ${link.kind}`);
+        lines.push(`    path: ${formatScalar(link.path)}`);
+        if (link.description)
+            lines.push(`    description: ${formatScalar(link.description)}`);
+    }
+    return lines;
+}
+function formatTemplateContext(context, fallbackWorkflow) {
+    const lines = [];
+    const extraSections = context?.extraSections ?? {};
+    for (const [key, value] of Object.entries(extraSections)) {
+        appendYamlPair(lines, key, value, 0);
+    }
+    if (context?.roles && Object.keys(context.roles).length > 0)
+        appendYamlPair(lines, "roles", context.roles, 0);
+    if (context?.controllers && Object.keys(context.controllers).length > 0)
+        appendYamlPair(lines, "controllers", context.controllers, 0);
+    if (context?.workflows && Object.keys(context.workflows).length > 0) {
+        appendYamlPair(lines, "workflows", context.workflows, 0);
+    }
+    else {
+        lines.push(workflowDraftToYaml(fallbackWorkflow).trimEnd());
+    }
+    return lines;
+}
+export function workflowDraftToYaml(workflow) {
+    const lines = ["workflow:", `  name: ${formatScalar(workflow.name)}`];
+    if (workflow.description)
+        lines.push(`  description: ${formatScalar(workflow.description)}`);
+    lines.push("  steps:");
+    for (const step of workflow.steps) {
+        lines.push(`    - id: ${formatScalar(step.id)}`);
+        lines.push(`      role: ${formatScalar(step.role)}`);
+        if (step.description)
+            lines.push(`      description: ${formatScalar(step.description)}`);
+        if (step.depends_on && step.depends_on.length > 0)
+            lines.push(`      depends_on: [${step.depends_on.map(formatScalar).join(", ")}]`);
+        if (step.prompt)
+            lines.push(`      prompt: ${formatScalar(step.prompt)}`);
+        if (step.checkpoints && step.checkpoints.length > 0) {
+            lines.push("      checkpoints:");
+            for (const checkpoint of step.checkpoints) {
+                lines.push(`        - assert: ${formatScalar(checkpoint.assert)}`);
+                lines.push(`          message: ${formatScalar(checkpoint.message)}`);
+                if (checkpoint.action)
+                    lines.push(`          action: ${checkpoint.action}`);
+            }
+        }
+        if (step.handoff?.consumes?.length || step.handoff?.produces?.length) {
+            lines.push("      handoff:");
+            if (step.handoff.consumes?.length) {
+                lines.push("        consumes:");
+                step.handoff.consumes.forEach((artifact) => lines.push(...formatHandoffArtifact(artifact, "          ")));
+            }
+            if (step.handoff.produces?.length) {
+                lines.push("        produces:");
+                step.handoff.produces.forEach((artifact) => lines.push(...formatHandoffArtifact(artifact, "          ")));
+            }
+        }
+    }
+    if (workflow.retry_policy) {
+        lines.push("  retry_policy:");
+        lines.push(`    max_retries: ${workflow.retry_policy.max_retries}`);
+        if (workflow.retry_policy.retry_from)
+            lines.push(`    retry_from: ${formatScalar(workflow.retry_policy.retry_from)}`);
+        if (workflow.retry_policy.backoff)
+            lines.push(`    backoff: ${workflow.retry_policy.backoff}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function workflowDraftToTemplateYaml(params) {
+    const templateName = slug(params.templateName);
+    const namespace = namespaceFromName(templateName);
+    const header = [
+        "# Generated by dna workflow draft --save-template as an example-clone scaffold.",
+        "# This file's structure was not derived from the goal; use dna workflow authoring-packet for true workflow authoring.",
+        "# Review this file before running dna init, dna sync, or using it as policy truth.",
+        "version: \"0.1.0\"",
+        `id: template_${templateName.replaceAll("-", "_")}`,
+        `name: ${formatScalar(params.workflow.name)}`,
+        `purpose: ${formatScalar(params.workflow.description ?? `Draft workflow asset for ${params.workflow.name}`)}`,
+        "maturity: draft",
+        "fit:",
+        "  - Reviewable workflow asset draft created from a human-described working method.",
+        "not_for:",
+        "  - Runtime policy truth before human review, validation, and explicit adoption.",
+        "inputs:",
+        "  - Natural-language workflow description",
+        "  - Human review notes",
+        "outputs:",
+        "  - C1 workflow asset YAML",
+        "  - Reviewable workflow steps, roles, and handoffs",
+        "type: project",
+        `namespace: ${namespace}`,
+        "lineage:",
+        "  source: dna workflow draft --save-template",
+        "  generation_mode: example_clone_scaffold",
+        "cascade:",
+        "  inherits: [\"species:default\"]",
+        "  priority: 100",
+        "x_intentdna:",
+        "  asset_status: draft",
+        "  human_review_required: true",
+    ];
+    if (params.generatedAt)
+        header.push(`  generated_at: ${formatScalar(params.generatedAt)}`);
+    if (params.lineage?.generatedFrom)
+        header.push(`  generated_from: ${formatScalar(params.lineage.generatedFrom)}`);
+    if (params.lineage?.sourceAsset)
+        header.push(`  source_asset: ${formatScalar(params.lineage.sourceAsset)}`);
+    if (params.lineage?.sourceCandidate)
+        header.push(`  source_candidate: ${formatScalar(params.lineage.sourceCandidate)}`);
+    if (params.lineage?.sourceSuggestion)
+        header.push(`  source_suggestion: ${formatScalar(params.lineage.sourceSuggestion)}`);
+    if (params.lineage?.sourceEvidence)
+        header.push(`  source_evidence: ${formatScalar(params.lineage.sourceEvidence)}`);
+    const evidence = formatEvidenceLinks(params.evidence);
+    const evidenceBlock = evidence.length > 0 ? `${evidence.join("\n")}\n\n` : "";
+    return `${header.join("\n")}\n\n${evidenceBlock}${formatTemplateContext(params.templateContext, params.workflow).join("\n")}\n`;
+}
+export function workflowDraftExamples() {
+    return EXAMPLES.map((example) => ({
+        ...example,
+        workflow: cloneWorkflow(example.workflow),
+    }));
+}
+function inferDependencies(steps) {
+    const hasExplicit = steps.some((step) => step.depends_on && step.depends_on.length > 0);
+    if (hasExplicit)
+        return steps.map((step) => ({ ...step, depends_on: [...(step.depends_on ?? [])] }));
+    return steps.map((step, index) => index === 0 ? { ...step, depends_on: [] } : { ...step, depends_on: [steps[index - 1].id] });
+}
+function validateWorkflow(workflow) {
+    const messages = [];
+    if (!workflow.name.trim())
+        messages.push({ severity: "error", path: "workflow.name", message: "Workflow name is required." });
+    if (!Array.isArray(workflow.steps) || workflow.steps.length === 0) {
+        messages.push({ severity: "error", path: "workflow.steps", message: "Workflow must have at least one step." });
+        return { ok: false, messages, preview: { step_count: 0, parallel_groups: [], retry_max: 0, write_path: "draft_only" } };
+    }
+    const resolvedSteps = inferDependencies(workflow.steps);
+    const stepIds = new Set();
+    for (const [index, step] of resolvedSteps.entries()) {
+        const basePath = `workflow.steps.${index}`;
+        if (!step.id.trim())
+            messages.push({ severity: "error", path: `${basePath}.id`, message: "Step id is required." });
+        if (stepIds.has(step.id))
+            messages.push({ severity: "error", path: `${basePath}.id`, message: `Duplicate step id: ${step.id}.` });
+        stepIds.add(step.id);
+        if (!step.role.trim())
+            messages.push({ severity: "error", path: `${basePath}.role`, message: "Step role is required." });
+    }
+    for (const [index, step] of resolvedSteps.entries()) {
+        for (const dep of step.depends_on ?? []) {
+            if (dep === step.id)
+                messages.push({ severity: "error", path: `workflow.steps.${index}.depends_on`, message: `Step ${step.id} cannot depend on itself.` });
+            if (!stepIds.has(dep))
+                messages.push({ severity: "error", path: `workflow.steps.${index}.depends_on`, message: `Step ${step.id} depends on missing step ${dep}.` });
+        }
+    }
+    const inDegree = new Map();
+    const dependents = new Map();
+    resolvedSteps.forEach((step) => {
+        inDegree.set(step.id, step.depends_on?.length ?? 0);
+        dependents.set(step.id, []);
+    });
+    resolvedSteps.forEach((step) => {
+        (step.depends_on ?? []).forEach((dep) => dependents.get(dep)?.push(step.id));
+    });
+    const groups = [];
+    let queue = [...resolvedSteps.filter((step) => (inDegree.get(step.id) ?? 0) === 0).map((step) => step.id)];
+    const sorted = [];
+    while (queue.length > 0) {
+        groups.push([...queue]);
+        const next = [];
+        for (const id of queue) {
+            sorted.push(id);
+            for (const dependent of dependents.get(id) ?? []) {
+                const nextDegree = (inDegree.get(dependent) ?? 0) - 1;
+                inDegree.set(dependent, nextDegree);
+                if (nextDegree === 0)
+                    next.push(dependent);
+            }
+        }
+        queue = next;
+    }
+    if (sorted.length < resolvedSteps.length) {
+        const cycleIds = resolvedSteps.map((step) => step.id).filter((id) => !sorted.includes(id));
+        messages.push({ severity: "error", path: "workflow.steps", message: `Cycle detected involving steps: ${cycleIds.join(", ")}.` });
+    }
+    if (workflow.retry_policy?.retry_from && !stepIds.has(workflow.retry_policy.retry_from)) {
+        messages.push({ severity: "error", path: "workflow.retry_policy.retry_from", message: "retry_from must reference an existing step." });
+    }
+    if (workflow.retry_policy && workflow.retry_policy.max_retries < 0) {
+        messages.push({ severity: "error", path: "workflow.retry_policy.max_retries", message: "max_retries must be >= 0." });
+    }
+    if (messages.length === 0) {
+        messages.push({
+            severity: "info",
+            path: "workflow",
+            message: "Draft matches workflow preview rules. Human approval and dna validate/sync are still required before runtime use.",
+        });
+    }
+    return {
+        ok: messages.every((message) => message.severity !== "error"),
+        messages,
+        preview: {
+            step_count: workflow.steps.length,
+            parallel_groups: groups,
+            retry_max: workflow.retry_policy?.max_retries ?? 0,
+            write_path: "draft_only",
+        },
+    };
+}
+export function buildWorkflowDesignPacket(params) {
+    const templateName = params.templateName ?? "<name>";
+    return {
+        workflow: params.workflow.name,
+        goal: params.goal,
+        stepCount: params.workflow.steps.length,
+        editableOperations: [...EDITABLE_OPERATIONS],
+        reviewCommands: [
+            `dna workflow edit-plan "<change>" --from-template ${templateName}`,
+            `dna assets inspect ${templateName} --evidence`,
+            `dna assets diff ${templateName} ${templateName}-v2`,
+            `dna assets adoption ${templateName}-v2`,
+        ],
+        adoptionCommands: [
+            `dna org bind --asset ${templateName}-v2 --status active --sync-target codex`,
+            "dna org review",
+            "dna sync --codex",
+        ],
+        mutationBoundary: "Drafting and editing are review-only. They do not configure, adopt, sync, or mutate runtime policy until a human explicitly runs the follow-up commands.",
+        userPrompt: "Describe workflow edits in natural language; use explicit operation, target step, or role options only when you need to override inference.",
+    };
+}
+function templateNameFromSource(source) {
+    if (!source)
+        return undefined;
+    const parts = source.split(":");
+    if ((parts[0] === "template" || parts[0] === "suggestions") && parts[1])
+        return parts[1];
+    return source;
+}
+export function createWorkflowDraft(input, generatedAt = new Date().toISOString()) {
+    const example = EXAMPLES.find((candidate) => candidate.id === input.exampleId) ?? EXAMPLES[0];
+    const workflow = cloneWorkflow(example.workflow);
+    const taskId = slug(input.goal);
+    workflow.name = `${workflow.name}-${taskId}`.slice(0, 96);
+    workflow.description = `${example.summary} User-supplied scaffold label: ${input.goal || "draft workflow"}`;
+    if (input.strictness === "high") {
+        workflow.retry_policy = {
+            max_retries: Math.max(workflow.retry_policy?.max_retries ?? 0, 2),
+            retry_from: workflow.retry_policy?.retry_from ?? workflow.steps[1]?.id ?? workflow.steps[0]?.id,
+            backoff: "none",
+        };
+        workflow.steps = workflow.steps.map((step) => ({
+            ...step,
+            checkpoints: step.checkpoints ?? [{
+                    assert: "validation_evidence_present",
+                    message: "Draft preview requires explicit validation evidence before handoff.",
+                    action: "warn",
+                }],
+        }));
+    }
+    const validation = validateWorkflow(workflow);
+    return {
+        mode: "draft_only",
+        generated_at: generatedAt,
+        input,
+        scaffold: {
+            kind: "example_clone_scaffold",
+            source_example: example.id,
+            positioning: "This draft is a quick scaffold cloned from a built-in example. Its structure is not derived from the goal; use dna workflow authoring-packet for true agent-authored workflow creation.",
+            deprecated_primary_creation_path: "dna workflow authoring-packet",
+        },
+        workflow,
+        design_packet: buildWorkflowDesignPacket({ workflow, goal: input.goal }),
+        yaml: workflowDraftToYaml(workflow),
+        validation,
+        safe_flow: [...SAFE_FLOW],
+        forbidden: [...FORBIDDEN],
+    };
+}
+export function createWorkflowEditPlanFromWorkflow(baseWorkflow, input, generatedAt = new Date().toISOString()) {
+    const baseWorkflowClone = cloneWorkflow(baseWorkflow);
+    const proposed = cloneWorkflow(baseWorkflow);
+    const index = selectedStepIndex(proposed.steps, input.targetStep);
+    const target = proposed.steps[index]?.id ?? "workflow";
+    const role = input.role?.trim() || "verifier";
+    const operations = [];
+    if (input.operation === "insert_step") {
+        const previous = proposed.steps[index];
+        const newId = uniqueStepId(proposed.steps, input.instruction || "inserted-step");
+        const newStep = {
+            id: newId,
+            role,
+            description: input.instruction || "Inserted workflow step.",
+            depends_on: previous ? [previous.id] : [],
+            prompt: `Handle: ${input.instruction || "inserted workflow step"} for {{task_id}}.`,
+            handoff: {
+                produces: [{ type: "summary", name: `${newId}_summary`, description: "Inserted step summary." }],
+            },
+        };
+        proposed.steps.splice(index + 1, 0, newStep);
+        const next = proposed.steps[index + 2];
+        if (next)
+            next.depends_on = [...new Set([...(next.depends_on ?? []).filter((dep) => dep !== previous?.id), newId])];
+        operations.push({
+            operation: input.operation,
+            target,
+            summary: `Insert ${newId} after ${target}.`,
+            human_review_required: true,
+        });
+    }
+    if (input.operation === "add_verifier") {
+        const previous = proposed.steps[index];
+        const newId = uniqueStepId(proposed.steps, "verify-evidence");
+        proposed.steps.splice(index + 1, 0, {
+            id: newId,
+            role: role || "verifier",
+            description: input.instruction || "Verify evidence before handoff.",
+            depends_on: previous ? [previous.id] : [],
+            prompt: `Verify evidence for {{task_id}}: ${input.instruction || "check required artifacts and tests"}.`,
+            checkpoints: [{
+                    assert: "verification_evidence_present",
+                    message: "Verifier must produce explicit evidence before downstream review.",
+                    action: "block",
+                }],
+            handoff: {
+                produces: [{ type: "test_result", name: "verification_result", description: "Verification evidence." }],
+            },
+        });
+        const next = proposed.steps[index + 2];
+        if (next)
+            next.depends_on = [...new Set([...(next.depends_on ?? []).filter((dep) => dep !== previous?.id), newId])];
+        operations.push({
+            operation: input.operation,
+            target,
+            summary: `Add verifier step after ${target}.`,
+            human_review_required: true,
+        });
+    }
+    if (input.operation === "tighten_boundary") {
+        const step = proposed.steps[index];
+        step.checkpoints = [
+            ...(step.checkpoints ?? []),
+            {
+                assert: "boundary_contract_satisfied",
+                message: input.instruction || "Boundary contract must be satisfied before this step can complete.",
+                action: "block",
+            },
+        ];
+        operations.push({
+            operation: input.operation,
+            target,
+            summary: `Add blocking boundary checkpoint to ${target}.`,
+            human_review_required: true,
+        });
+    }
+    if (input.operation === "split_step") {
+        const step = proposed.steps[index];
+        const firstId = uniqueStepId(proposed.steps, `${step.id}-prepare`);
+        const secondId = uniqueStepId([...proposed.steps, { ...step, id: firstId }], `${step.id}-execute`);
+        const originalDeps = step.depends_on ?? [];
+        proposed.steps.splice(index, 1, {
+            ...step,
+            id: firstId,
+            description: `Prepare: ${step.description ?? input.instruction}`,
+            depends_on: originalDeps,
+        }, {
+            ...step,
+            id: secondId,
+            description: `Execute: ${input.instruction || step.description || "split step execution"}`,
+            depends_on: [firstId],
+        });
+        for (const candidate of proposed.steps) {
+            if (candidate.depends_on?.includes(step.id)) {
+                candidate.depends_on = candidate.depends_on.map((dep) => dep === step.id ? secondId : dep);
+            }
+        }
+        operations.push({
+            operation: input.operation,
+            target,
+            summary: `Split ${target} into ${firstId} and ${secondId}.`,
+            human_review_required: true,
+        });
+    }
+    if (input.operation === "replace_role") {
+        const step = proposed.steps[index];
+        const oldRole = step.role;
+        step.role = role;
+        step.description = `${step.description ?? step.id} Role changed from ${oldRole} to ${role}. ${input.instruction}`.trim();
+        operations.push({
+            operation: input.operation,
+            target,
+            summary: `Replace role on ${target}: ${oldRole} -> ${role}.`,
+            human_review_required: true,
+        });
+    }
+    const validation = validateWorkflow(proposed);
+    return {
+        mode: "edit_plan_only",
+        generated_at: generatedAt,
+        input,
+        base_workflow: baseWorkflowClone,
+        proposed_workflow: proposed,
+        design_packet: buildWorkflowDesignPacket({ workflow: proposed, goal: input.goal, templateName: templateNameFromSource(input.source) }),
+        operations,
+        yaml: workflowDraftToYaml(proposed),
+        validation,
+        safe_flow: [
+            "generate edit plan only",
+            "review operation summary",
+            "review YAML preview",
+            "human approval",
+            "manual DNA config edit",
+            "dna validate",
+            "dna sync",
+        ],
+        forbidden: [...FORBIDDEN],
+    };
+}
+export function createWorkflowEditPlan(input, generatedAt = new Date().toISOString()) {
+    const baseDraft = createWorkflowDraft(input, generatedAt);
+    return createWorkflowEditPlanFromWorkflow(baseDraft.workflow, input, generatedAt);
+}