intentdna 1.9.0 → 1.9.3

package/dist/runtime/canonical-runtime-composition.d.ts

@@ -0,0 +1,22 @@
+import { ArtifactStore } from "./artifact-store.js";
+import { CanonicalRunService, type CanonicalRunServiceOptions } from "./canonical-run-service.js";
+import { DurablePlanStore } from "./plan-store.js";
+import { ImmutableCanonicalResultStore } from "./result-store.js";
+import { DurableRunStore } from "./run-store.js";
+export interface CanonicalRuntimeStores {
+    readonly root_directory: string;
+    readonly plan_store: DurablePlanStore;
+    readonly run_store: DurableRunStore;
+    readonly artifact_store: ArtifactStore;
+    readonly result_store: ImmutableCanonicalResultStore;
+}
+export interface CanonicalRuntimeComposition extends CanonicalRuntimeStores {
+    readonly service: CanonicalRunService;
+}
+export interface CreateCanonicalRuntimeCompositionOptions extends Omit<CanonicalRunServiceOptions, "plan_store" | "run_store" | "artifact_store" | "result_store" | "handoff_root_directory"> {
+    readonly project_directory: string;
+    readonly run_store?: DurableRunStore;
+}
+export declare function canonicalRuntimeRoot(projectDirectory: string): string;
+export declare function createCanonicalRuntimeStores(projectDirectory: string, runStore?: DurableRunStore): CanonicalRuntimeStores;
+export declare function createCanonicalRuntimeComposition(options: CreateCanonicalRuntimeCompositionOptions): CanonicalRuntimeComposition;

package/dist/runtime/canonical-runtime-composition.js

@@ -0,0 +1,34 @@
+import { join, resolve } from "node:path";
+import { ArtifactStore } from "./artifact-store.js";
+import { CanonicalRunService, } from "./canonical-run-service.js";
+import { DurablePlanStore } from "./plan-store.js";
+import { ImmutableCanonicalResultStore } from "./result-store.js";
+import { DurableRunStore } from "./run-store.js";
+export function canonicalRuntimeRoot(projectDirectory) {
+    return join(resolve(projectDirectory), ".dna", "runtime");
+}
+export function createCanonicalRuntimeStores(projectDirectory, runStore) {
+    const rootDirectory = canonicalRuntimeRoot(projectDirectory);
+    return {
+        root_directory: rootDirectory,
+        plan_store: new DurablePlanStore({ root_directory: rootDirectory }),
+        run_store: runStore ?? new DurableRunStore({ root_directory: rootDirectory }),
+        artifact_store: new ArtifactStore({ root_directory: rootDirectory }),
+        result_store: new ImmutableCanonicalResultStore({ root_directory: rootDirectory }),
+    };
+}
+export function createCanonicalRuntimeComposition(options) {
+    const { project_directory, run_store, ...serviceOptions } = options;
+    const stores = createCanonicalRuntimeStores(project_directory, run_store);
+    return {
+        ...stores,
+        service: new CanonicalRunService({
+            ...serviceOptions,
+            plan_store: stores.plan_store,
+            run_store: stores.run_store,
+            artifact_store: stores.artifact_store,
+            result_store: stores.result_store,
+            handoff_root_directory: join(stores.root_directory, "handoffs"),
+        }),
+    };
+}

package/dist/runtime/canonical-runtime-projection.d.ts

@@ -0,0 +1,3 @@
+import type { CanonicalRuntimeProjection } from "./canonical-target-compiler.js";
+import { type CompiledIRFile } from "./plugin-adapter.js";
+export declare function durableCanonicalRuntimeProjection(projection: CanonicalRuntimeProjection): CompiledIRFile;

package/dist/runtime/canonical-runtime-projection.js

@@ -0,0 +1,4 @@
+import { createCompiledIR, } from "./plugin-adapter.js";
+export function durableCanonicalRuntimeProjection(projection) {
+    return JSON.parse(JSON.stringify(createCompiledIR(projection.constraint_ir, { ...projection.roles }, projection.workflow_manifest)));
+}

package/dist/runtime/canonical-target-compiler.d.ts

@@ -0,0 +1,46 @@
+import type { ConstraintIR, IntentDNA, RoleDef, WorkflowPlan } from "../schema/types.js";
+import { type ExecutableRunPlanPayload, type Sha256Digest } from "./executable-run-plan.js";
+import { type WorkflowRuntimeManifest } from "./workflow-runtime-manifest.js";
+export declare const CANONICAL_TARGET_COMPILER_NAME = "intentdna";
+export declare const CANONICAL_TARGET_COMPILER_VERSION = "1";
+export interface CanonicalTarget {
+    readonly kind: "workflow" | "controller";
+    readonly key: string;
+}
+export interface CanonicalDnaSource {
+    readonly dna: IntentDNA;
+    readonly source_id: string;
+    readonly relative_ref: string;
+    readonly content_digest: Sha256Digest;
+    readonly snapshot_bytes: Uint8Array;
+}
+export interface CompileCanonicalTargetRequest {
+    readonly dna_sources: readonly (IntentDNA | CanonicalDnaSource)[];
+    readonly target: CanonicalTarget;
+    readonly context?: string | null;
+    readonly attempt_policy?: {
+        readonly timeout_ms: number | null;
+        readonly cancellation_grace_ms: number;
+    };
+}
+export interface CanonicalRuntimeProjection {
+    readonly roles: Readonly<Record<string, RoleDef>>;
+    readonly constraint_ir: ConstraintIR;
+    readonly workflow_manifest: WorkflowRuntimeManifest;
+    readonly workflow_plan: WorkflowPlan;
+    readonly workflow_asset: string | null;
+}
+export interface CanonicalTargetCompilation {
+    readonly plan: ExecutableRunPlanPayload;
+    readonly projection: CanonicalRuntimeProjection;
+}
+export type CanonicalTargetCompilerErrorCode = "invalid_sources" | "invalid_target" | "target_not_found" | "unsupported_target_kind" | "controller_compilation_failed" | "workflow_compilation_failed" | "workflow_adaptation_failed";
+export declare class CanonicalTargetCompilerError extends Error {
+    readonly code: CanonicalTargetCompilerErrorCode;
+    constructor(code: CanonicalTargetCompilerErrorCode, message: string, options?: ErrorOptions);
+}
+export declare class CanonicalTargetCompiler {
+    compile(request: CompileCanonicalTargetRequest): ExecutableRunPlanPayload;
+    compileCascade(request: CompileCanonicalTargetRequest): CanonicalTargetCompilation;
+}
+export declare function compileCanonicalTarget(request: CompileCanonicalTargetRequest): ExecutableRunPlanPayload;

package/dist/runtime/canonical-target-compiler.js

@@ -0,0 +1,514 @@
+import { createHash } from "node:crypto";
+import { TextDecoder } from "node:util";
+import { cascadeDNA } from "../compiler/cascade.js";
+import { activateDNA } from "../compiler/activate.js";
+import { compileDNA } from "../compiler/compile.js";
+import { attachProvenance } from "../compiler/provenance.js";
+import { compileWorkflow } from "../compiler/workflow.js";
+import { compileControllerPlan, ControllerPlanCompilerError, } from "../compiler/controller.js";
+import { validateDNA } from "../schema/validate.js";
+import { parseYAML } from "../schema/yaml-parser.js";
+import { canonicalizeJson } from "./canonical-json.js";
+import { createWorkflowRuntimeManifest, } from "./workflow-runtime-manifest.js";
+import { defaultResolvedVariableScopes, indexWorkflowVariableScopes, resolvedVariablesForNamespace, } from "./workflow-variable-scopes.js";
+import { adaptWorkflowPlanToExecutableRunPlan, } from "./workflow-plan-adapter.js";
+export const CANONICAL_TARGET_COMPILER_NAME = "intentdna";
+export const CANONICAL_TARGET_COMPILER_VERSION = "1";
+export class CanonicalTargetCompilerError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "CanonicalTargetCompilerError";
+        this.code = code;
+    }
+}
+function digestBytes(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function hasStableArtifactIdentity(artifact) {
+    return artifact.artifact_id !== undefined
+        || artifact.name !== undefined
+        || artifact.path !== undefined
+        || artifact.type === "git_commit";
+}
+function authoredArtifactIdentity(artifact) {
+    return artifact.artifact_id
+        ?? artifact.name
+        ?? artifact.path
+        ?? (artifact.type === "git_commit" ? "git_commit" : null);
+}
+function containsRuntimeIdentityTemplate(value) {
+    return value.includes("$ARGUMENTS") || /\{\{[^}]+\}\}/u.test(value);
+}
+function controllerArtifactId(stepId, direction, index) {
+    return `${stepId}-${direction}-${index}`;
+}
+function canonicalControllerHandoffIdentities(plan) {
+    const outputIds = new Map();
+    const stepsWithOutputs = plan.steps.map((step) => {
+        if (step.handoff === null)
+            return step;
+        const produces = (step.handoff.produces ?? []).flatMap((artifact, index) => {
+            const identity = authoredArtifactIdentity(artifact);
+            if (identity === null)
+                return artifact.required === false ? [] : [artifact];
+            if (!containsRuntimeIdentityTemplate(identity))
+                return [artifact];
+            const artifactId = controllerArtifactId(step.id, "output", index);
+            outputIds.set(`${step.id}\u0000${identity}`, artifactId);
+            return [{ ...artifact, artifact_id: artifactId }];
+        });
+        return { ...step, handoff: { ...step.handoff, produces } };
+    });
+    return {
+        ...plan,
+        steps: stepsWithOutputs.map((step) => {
+            if (step.handoff === null)
+                return step;
+            const consumes = (step.handoff.consumes ?? []).map((artifact, index) => {
+                const identity = authoredArtifactIdentity(artifact);
+                if (identity === null || !containsRuntimeIdentityTemplate(identity))
+                    return artifact;
+                const sourceArtifactId = artifact.from === undefined
+                    ? undefined
+                    : outputIds.get(`${artifact.from}\u0000${identity}`);
+                return {
+                    ...artifact,
+                    artifact_id: sourceArtifactId
+                        ?? controllerArtifactId(step.id, "input", index),
+                };
+            });
+            return { ...step, handoff: { ...step.handoff, consumes } };
+        }),
+    };
+}
+function logicalSourceRef(dna, index) {
+    const segment = dna.id.replace(/[^A-Za-z0-9._-]/gu, "_") || `source-${index}`;
+    return `sources/${segment}.dna.json`;
+}
+function isCanonicalDnaSource(source) {
+    return Object.prototype.hasOwnProperty.call(source, "dna");
+}
+function normalizeSources(sources) {
+    if (sources.length === 0) {
+        throw new CanonicalTargetCompilerError("invalid_sources", "dna_sources must contain at least one source");
+    }
+    return sources.map((source, index) => {
+        try {
+            const candidate = isCanonicalDnaSource(source)
+                ? source
+                : (() => {
+                    const bytes = Buffer.from(canonicalizeJson(source), "utf8");
+                    return {
+                        dna: source,
+                        source_id: source.id,
+                        relative_ref: logicalSourceRef(source, index),
+                        content_digest: digestBytes(bytes),
+                        snapshot_bytes: bytes,
+                    };
+                })();
+            if (!(candidate.snapshot_bytes instanceof Uint8Array)) {
+                throw new TypeError("snapshot_bytes must be a Uint8Array");
+            }
+            const snapshotBytes = Uint8Array.from(candidate.snapshot_bytes);
+            const actualDigest = digestBytes(snapshotBytes);
+            if (candidate.content_digest !== actualDigest) {
+                throw new TypeError(`content_digest does not match snapshot bytes (${actualDigest})`);
+            }
+            const raw = new TextDecoder("utf-8", { fatal: true }).decode(snapshotBytes);
+            let snapshotDna;
+            try {
+                snapshotDna = JSON.parse(raw);
+            }
+            catch {
+                snapshotDna = parseYAML(raw);
+            }
+            const validation = validateDNA(snapshotDna);
+            if (!validation.valid) {
+                throw new TypeError(validation.errors
+                    .map((error) => `${error.path}: ${error.message}`)
+                    .join("; "));
+            }
+            if (candidate.source_id !== snapshotDna.id || candidate.source_id !== candidate.dna.id) {
+                throw new TypeError("source_id must match the snapshot DNA id");
+            }
+            if (canonicalizeJson(candidate.dna) !== canonicalizeJson(snapshotDna)) {
+                throw new TypeError("parsed DNA must match snapshot bytes");
+            }
+            return {
+                ...candidate,
+                dna: snapshotDna,
+                content_digest: actualDigest,
+                snapshot_bytes: snapshotBytes,
+            };
+        }
+        catch (error) {
+            throw new CanonicalTargetCompilerError("invalid_sources", `DNA source at index ${index} is not bound to a valid immutable snapshot`, { cause: error });
+        }
+    });
+}
+function collectTemplateInputNames(value, names) {
+    if (typeof value === "string") {
+        for (const match of value.matchAll(/\{\{(\w+)\}\}/gu))
+            names.add(match[1]);
+        if (/(^|[^\\])\$ARGUMENTS/u.test(value))
+            names.add("ARGUMENTS");
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectTemplateInputNames(item, names);
+        return;
+    }
+    if (value !== null && typeof value === "object") {
+        for (const item of Object.values(value)) {
+            collectTemplateInputNames(item, names);
+        }
+    }
+}
+function variableDefinition(name, value) {
+    if (value === undefined) {
+        return {
+            name,
+            type: "string",
+            required: true,
+            sensitive: false,
+            description: `Runtime value for template input '${name}'`,
+        };
+    }
+    return {
+        name,
+        type: typeof value === "string"
+            ? "string"
+            : value.runtime_type ?? "string",
+        required: false,
+        sensitive: false,
+        description: typeof value === "string"
+            ? `Runtime value for declared input '${name}'`
+            : value.description,
+        default_value: typeof value === "string" ? value : value.default,
+    };
+}
+function inputContract(dnas, targetKey, workflow, roles) {
+    const variableIndex = indexWorkflowVariableScopes([...dnas]);
+    const namespace = variableIndex.workflowNamespaces.get(targetKey) ?? "";
+    const declared = {
+        ...(namespace ? variableIndex.rawByNamespace.get("") : {}),
+        ...(variableIndex.rawByNamespace.get(namespace) ?? {}),
+    };
+    const names = new Set(Object.keys(declared));
+    collectTemplateInputNames(workflow, names);
+    for (const roleName of new Set(workflow.steps.map((step) => step.role))) {
+        const role = roles[roleName];
+        if (role)
+            collectTemplateInputNames(role, names);
+    }
+    return {
+        inputs: [...names]
+            .sort()
+            .map((name) => variableDefinition(name, declared[name])),
+        allow_unknown_inputs: false,
+    };
+}
+function sourceProvenance(sources) {
+    return {
+        compiler: {
+            name: CANONICAL_TARGET_COMPILER_NAME,
+            version: CANONICAL_TARGET_COMPILER_VERSION,
+        },
+        sources: sources.map((source) => ({
+            source_id: source.source_id,
+            relative_ref: source.relative_ref,
+            content_digest: source.content_digest,
+        })),
+    };
+}
+function canonicalCompletion(completion) {
+    return JSON.parse(canonicalizeJson(completion));
+}
+function canonicalRuntimeWorkflowPlan(workflow, plan) {
+    const definitions = new Map(workflow.steps.map((step) => [step.id, step]));
+    const steps = plan.steps.map((step) => {
+        const definition = definitions.get(step.id);
+        const runtime = definition?.canonical_runtime;
+        if (definition === undefined || runtime === undefined)
+            return step;
+        const sourceByArtifactId = runtime.handoff_sources ?? {};
+        const authoredConsumes = step.handoff?.consumes ?? [];
+        for (const [artifactId, sourceStepId] of Object.entries(sourceByArtifactId)) {
+            const matches = authoredConsumes.filter((artifact) => artifact.artifact_id === artifactId);
+            if (matches.length !== 1) {
+                throw new Error(`step '${step.id}' canonical source '${artifactId}' must identify one consumed artifact`);
+            }
+            if (matches[0].from !== undefined && matches[0].from !== sourceStepId) {
+                throw new Error(`step '${step.id}' canonical source '${artifactId}' conflicts with authored source '${matches[0].from}'`);
+            }
+        }
+        const canonicalConsumes = authoredConsumes.map((artifact) => {
+            const sourceStepId = artifact.artifact_id === undefined
+                ? undefined
+                : sourceByArtifactId[artifact.artifact_id];
+            return sourceStepId === undefined ? artifact : { ...artifact, from: sourceStepId };
+        });
+        let prompt = step.prompt;
+        const pathBindings = {};
+        for (const artifactId of runtime.prompt_handoff_bindings ?? []) {
+            const matches = canonicalConsumes.filter((artifact) => (artifact.artifact_id === artifactId));
+            if (matches.length !== 1 || !matches[0].from || !matches[0].path) {
+                throw new Error(`step '${step.id}' canonical binding '${artifactId}' must identify one path handoff with a source step`);
+            }
+            if (prompt === null || !prompt.includes(matches[0].path)) {
+                throw new Error(`step '${step.id}' canonical binding '${artifactId}' is not referenced by the authored prompt`);
+            }
+            const replacement = `{{handoff.${step.id}:${artifactId}.materialized_path}}`;
+            prompt = prompt.replaceAll(matches[0].path, replacement);
+            pathBindings[matches[0].path] = replacement;
+        }
+        if (runtime.prompt_suffix !== undefined) {
+            prompt = `${prompt ?? step.description}\n\n${runtime.prompt_suffix}`;
+        }
+        const canonicalOutputs = runtime.outputs ?? [];
+        return {
+            ...step,
+            prompt,
+            handoff: step.handoff === null
+                ? (canonicalOutputs.length === 0 ? null : { produces: canonicalOutputs })
+                : {
+                    ...step.handoff,
+                    consumes: canonicalConsumes,
+                    produces: [...(step.handoff.produces ?? []), ...canonicalOutputs],
+                },
+            completion: runtime.completion === undefined
+                ? step.completion
+                : runtime.completion.map(canonicalCompletion),
+            canonical_handoff_path_bindings: pathBindings,
+            canonical_requires_attested_independent_submit: runtime.require_attested_independent_submit === true,
+        };
+    });
+    return { ...plan, steps };
+}
+function compilerProvenance(sources) {
+    return sources.map((source) => ({
+        source_id: source.source_id,
+        source_ref: source.relative_ref,
+        resolved_path: source.relative_ref,
+        fingerprint: source.content_digest,
+        type: source.dna.type,
+        cascade_priority: source.dna.cascade.priority,
+        version: source.dna.version,
+        trust: "input",
+        genes: Object.keys(source.dna.genes ?? {}).sort(),
+    }));
+}
+export class CanonicalTargetCompiler {
+    compile(request) {
+        return this.compileCascade(request).plan;
+    }
+    compileCascade(request) {
+        if (request.target.kind !== "workflow"
+            && request.target.kind !== "controller") {
+            throw new CanonicalTargetCompilerError("invalid_target", `target kind must be 'workflow' or 'controller', received '${String(request.target.kind)}'`);
+        }
+        if (!request.target.key.trim()) {
+            throw new CanonicalTargetCompilerError("invalid_target", "target key must be non-empty");
+        }
+        const sources = normalizeSources(request.dna_sources);
+        const dnas = sources.map((source) => source.dna);
+        const cascaded = cascadeDNA(dnas);
+        const activated = activateDNA(cascaded, request.context ?? null, null);
+        const constraintIr = attachProvenance(compileDNA(activated, cascaded), compilerProvenance(sources));
+        if (request.target.kind === "controller") {
+            const controller = cascaded.controllers[request.target.key];
+            if (!controller) {
+                throw new CanonicalTargetCompilerError("target_not_found", `controller '${request.target.key}' not found; available: ${Object.keys(cascaded.controllers).sort().join(", ") || "(none)"}`);
+            }
+            if (!controller.runtime_program) {
+                throw new CanonicalTargetCompilerError("controller_compilation_failed", `controller '${request.target.key}' has no typed runtime_program`);
+            }
+            const diagnosisKey = controller.diagnosis_workflow;
+            const fixKey = controller.fix_workflow;
+            if (!diagnosisKey || !fixKey) {
+                throw new CanonicalTargetCompilerError("controller_compilation_failed", `controller '${request.target.key}' must reference diagnosis_workflow and fix_workflow`);
+            }
+            const compileComponent = (workflowKey) => {
+                const definition = cascaded.workflows[workflowKey];
+                if (!definition) {
+                    throw new CanonicalTargetCompilerError("controller_compilation_failed", `controller '${request.target.key}' references missing workflow '${workflowKey}'`);
+                }
+                const result = compileWorkflow(definition, {
+                    workflow_key: workflowKey,
+                    roles: cascaded.roles,
+                });
+                if (!result.ok || !result.plan) {
+                    throw new CanonicalTargetCompilerError("workflow_compilation_failed", `workflow '${workflowKey}' compilation failed:\n${result.errors
+                        .map((error) => `  ${error.path}: ${error.message}`)
+                        .join("\n")}`);
+                }
+                const workflowPlan = canonicalRuntimeWorkflowPlan(definition, result.plan);
+                const controllerPlan = canonicalControllerHandoffIdentities({
+                    ...workflowPlan,
+                    steps: workflowPlan.steps.map((step) => ({
+                        ...step,
+                        handoff: step.handoff === null
+                            ? null
+                            : {
+                                ...step.handoff,
+                                produces: step.handoff.produces?.filter((artifact) => (artifact.required !== false || hasStableArtifactIdentity(artifact))),
+                            },
+                        blocked_items_path: undefined,
+                        handoff_to: undefined,
+                        max_handoffs: undefined,
+                        on_handoff_exhausted: undefined,
+                        on_fail: step.on_fail === "retry_with_feedback"
+                            ? step.on_fail
+                            : undefined,
+                    })),
+                });
+                return {
+                    definition,
+                    workflow_plan: workflowPlan,
+                    executable_plan: adaptWorkflowPlanToExecutableRunPlan(controllerPlan, {
+                        roles: cascaded.roles,
+                        target_key: workflowKey,
+                        input_contract: inputContract(dnas, workflowKey, definition, cascaded.roles),
+                        source_provenance: sourceProvenance(sources),
+                        global_constraints: constraintIr.prompt_directives.map((directive) => directive.text),
+                        timeout_ms: request.attempt_policy?.timeout_ms,
+                        cancellation_grace_ms: request.attempt_policy?.cancellation_grace_ms,
+                    }),
+                };
+            };
+            try {
+                const diagnosis = compileComponent(diagnosisKey);
+                const fix = compileComponent(fixKey);
+                const plan = compileControllerPlan({
+                    controller_key: request.target.key,
+                    controller,
+                    diagnosis_plan: diagnosis.executable_plan,
+                    fix_plan: fix.executable_plan,
+                    source_provenance: sourceProvenance(sources),
+                });
+                if (!constraintIr.compiled_ir_hash) {
+                    throw new Error("compiled IR hash is required for runtime projection");
+                }
+                const variableIndex = indexWorkflowVariableScopes(dnas);
+                const defaultVariables = defaultResolvedVariableScopes(variableIndex);
+                const runtimePlans = Object.entries(cascaded.workflows).map(([workflowKey, definition]) => {
+                    const result = compileWorkflow(definition, {
+                        workflow_key: workflowKey,
+                        roles: cascaded.roles,
+                    });
+                    if (!result.ok || !result.plan) {
+                        throw new CanonicalTargetCompilerError("workflow_compilation_failed", `workflow '${workflowKey}' compilation failed:\n${result.errors
+                            .map((error) => `  ${error.path}: ${error.message}`)
+                            .join("\n")}`);
+                    }
+                    const runtimePlan = canonicalRuntimeWorkflowPlan(definition, result.plan);
+                    const namespace = variableIndex.workflowNamespaces.get(workflowKey) ?? "";
+                    return {
+                        plan: runtimePlan,
+                        resolvedVariables: resolvedVariablesForNamespace(defaultVariables, namespace),
+                        runtimeInputRefs: inputContract(dnas, workflowKey, definition, cascaded.roles).inputs.map((input) => input.name),
+                        workflowAsset: variableIndex.workflowAssets.get(workflowKey),
+                        additionalRuntimeValues: constraintIr.verifier_specs?.filter((spec) => spec.workflow_name === workflowKey) ?? [],
+                    };
+                });
+                return {
+                    plan,
+                    projection: {
+                        roles: cascaded.roles,
+                        constraint_ir: constraintIr,
+                        workflow_manifest: createWorkflowRuntimeManifest({
+                            plans: runtimePlans,
+                            compiledAt: constraintIr.compiled_at,
+                            compiledIrHash: constraintIr.compiled_ir_hash,
+                            sourceDnaIds: constraintIr.source_dna_ids,
+                        }),
+                        workflow_plan: fix.workflow_plan,
+                        workflow_asset: variableIndex.workflowAssets.get(fixKey) ?? null,
+                    },
+                };
+            }
+            catch (error) {
+                if (error instanceof CanonicalTargetCompilerError)
+                    throw error;
+                throw new CanonicalTargetCompilerError("controller_compilation_failed", `controller '${request.target.key}' could not be adapted to an executable plan`, { cause: error instanceof ControllerPlanCompilerError ? error : error });
+            }
+        }
+        const workflow = cascaded.workflows[request.target.key];
+        if (!workflow) {
+            throw new CanonicalTargetCompilerError("target_not_found", `workflow '${request.target.key}' not found; available: ${Object.keys(cascaded.workflows).sort().join(", ") || "(none)"}`);
+        }
+        const compiled = compileWorkflow(workflow, {
+            workflow_key: request.target.key,
+            roles: cascaded.roles,
+        });
+        if (!compiled.ok || !compiled.plan) {
+            throw new CanonicalTargetCompilerError("workflow_compilation_failed", `workflow '${request.target.key}' compilation failed:\n${compiled.errors
+                .map((error) => `  ${error.path}: ${error.message}`)
+                .join("\n")}`);
+        }
+        try {
+            const canonicalPlan = canonicalRuntimeWorkflowPlan(workflow, compiled.plan);
+            const plan = adaptWorkflowPlanToExecutableRunPlan(canonicalPlan, {
+                roles: cascaded.roles,
+                target_key: request.target.key,
+                input_contract: inputContract(dnas, request.target.key, workflow, cascaded.roles),
+                source_provenance: sourceProvenance(sources),
+                global_constraints: constraintIr.prompt_directives.map((directive) => directive.text),
+                timeout_ms: request.attempt_policy?.timeout_ms,
+                cancellation_grace_ms: request.attempt_policy?.cancellation_grace_ms,
+            });
+            if (!constraintIr.compiled_ir_hash) {
+                throw new Error("compiled IR hash is required for runtime projection");
+            }
+            const variableIndex = indexWorkflowVariableScopes(dnas);
+            const defaultVariables = defaultResolvedVariableScopes(variableIndex);
+            const runtimePlans = Object.entries(cascaded.workflows).map(([workflowKey, definition]) => {
+                const result = workflowKey === request.target.key
+                    ? compiled
+                    : compileWorkflow(definition, {
+                        workflow_key: workflowKey,
+                        roles: cascaded.roles,
+                    });
+                if (!result.ok || !result.plan) {
+                    throw new CanonicalTargetCompilerError("workflow_compilation_failed", `workflow '${workflowKey}' compilation failed:\n${result.errors
+                        .map((error) => `  ${error.path}: ${error.message}`)
+                        .join("\n")}`);
+                }
+                const runtimePlan = canonicalRuntimeWorkflowPlan(definition, result.plan);
+                const namespace = variableIndex.workflowNamespaces.get(workflowKey) ?? "";
+                return {
+                    plan: runtimePlan,
+                    resolvedVariables: resolvedVariablesForNamespace(defaultVariables, namespace),
+                    runtimeInputRefs: inputContract(dnas, workflowKey, definition, cascaded.roles).inputs.map((input) => input.name),
+                    workflowAsset: variableIndex.workflowAssets.get(workflowKey),
+                    additionalRuntimeValues: constraintIr.verifier_specs?.filter((spec) => spec.workflow_name === workflowKey) ?? [],
+                };
+            });
+            return {
+                plan,
+                projection: {
+                    roles: cascaded.roles,
+                    constraint_ir: constraintIr,
+                    workflow_manifest: createWorkflowRuntimeManifest({
+                        plans: runtimePlans,
+                        compiledAt: constraintIr.compiled_at,
+                        compiledIrHash: constraintIr.compiled_ir_hash,
+                        sourceDnaIds: constraintIr.source_dna_ids,
+                    }),
+                    workflow_plan: canonicalPlan,
+                    workflow_asset: variableIndex.workflowAssets.get(request.target.key) ?? null,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof CanonicalTargetCompilerError)
+                throw error;
+            throw new CanonicalTargetCompilerError("workflow_adaptation_failed", `workflow '${request.target.key}' could not be adapted to an executable plan`, { cause: error });
+        }
+    }
+}
+export function compileCanonicalTarget(request) {
+    return new CanonicalTargetCompiler().compile(request);
+}

package/dist/runtime/claude-agent-identity.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalClaudeAgentName(role: string, workerSessionId: string): string;
+export declare function legacyClaudeAgentName(role: string): string;

package/dist/runtime/claude-agent-identity.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+export function canonicalClaudeAgentName(role, workerSessionId) {
+    if (role.length === 0)
+        throw new TypeError("role must not be empty");
+    if (workerSessionId.length === 0) {
+        throw new TypeError("workerSessionId must not be empty");
+    }
+    const identity = createHash("sha256")
+        .update(role, "utf8")
+        .update("\0", "utf8")
+        .update(workerSessionId, "utf8")
+        .digest("hex")
+        .slice(0, 32);
+    return `dna-attempt-${identity}`;
+}
+export function legacyClaudeAgentName(role) {
+    return `dna-${role
+        .replace(/([a-z0-9])([A-Z])/gu, "$1-$2")
+        .replace(/[_\s]+/gu, "-")
+        .toLowerCase()}`;
+}