intentdna 1.5.20 → 1.6.0

package/dist/hooks/enforce.js

@@ -58,7 +58,7 @@ export function enforcePreToolUse(ir, input, state, roles) {
     }
     // Layer 6: Handoff — check consumed artifacts are available
     if (state?.workflowState && ir.workflows_ir) {
-        const result = enforceHandoffConsumes(ir, state.workflowState, state.existingArtifactPaths);
+        const result = enforceHandoffConsumes(ir, state.workflowState, state.artifactFacts ?? []);
         if (result)
             return { output: result, trace: { matched_rule: "handoff", step_id: state.workflowState.current_step } };
     }
@@ -283,20 +283,18 @@ export function enforceStop(ir, input, workflowState) {
             }
         }
     }
+    const handoffResult = enforceHandoffProduces(ir, {
+        current_step: workflowState.current_step,
+        workflow: workflowState.workflow,
+        artifact_facts: workflowState.artifact_facts ?? [],
+    });
+    if (handoffResult)
+        return handoffResult;
     if (workflowCheckpoints.length === 0) {
         return null;
     }
     const blocking = workflowCheckpoints.flatMap(cp => cp.checkpoints.filter(c => (c.action ?? "block") === "block"));
     if (blocking.length === 0) {
-        if (workflowState.workflow) {
-            const handoffResult = enforceHandoffProduces(ir, {
-                current_step: workflowState.current_step,
-                workflow: workflowState.workflow,
-                completed_artifacts: workflowState.completed_artifacts,
-            });
-            if (handoffResult)
-                return handoffResult;
-        }
         return null;
     }
     const messages = blocking.map(c => c.message);
@@ -359,26 +357,23 @@ function getStepAdditionalPaths(ir, state) {
  * artifacts have been produced by a preceding step.
  * Returns block output if a required artifact is missing, null if all satisfied.
  */
-function enforceHandoffConsumes(ir, wfState, existingPaths) {
+function enforceHandoffConsumes(ir, wfState, artifactFacts) {
     const activeWf = ir.workflows_ir?.find(w => w.workflow_name === wfState.workflow);
-    if (!activeWf || activeWf.handoff_chain.length === 0)
+    if (!activeWf || (activeWf.handoff_chain?.length ?? 0) === 0)
         return null;
     const currentEntry = activeWf.handoff_chain.find(h => h.step_id === wfState.current_step);
     if (!currentEntry?.consumes || currentEntry.consumes.length === 0)
         return null;
-    const completedStepIds = new Set((wfState.completed_artifacts ?? []).map(a => a.step_id));
-    // For each consumed artifact, find the producing step and check it completed
     for (const consumed of currentEntry.consumes) {
-        // Find which step produces this artifact
-        const producer = activeWf.handoff_chain.find(h => h.produces?.some(p => p.type === consumed.type && ((p.path && consumed.path && p.path === consumed.path) ||
-            (consumed.from && h.step_id === consumed.from))));
-        if (producer && !completedStepIds.has(producer.step_id)) {
-            // Re-run fallback: if the consumed artifact file exists on disk
-            // (from a prior run), treat the dependency as satisfied.
-            if (consumed.path && existingPaths?.has(consumed.path)) {
-                continue;
-            }
-            return blockOutput(`[Intent DNA] Step '${wfState.current_step}' requires artifact from step '${producer.step_id}' (${consumed.description}). Run step '${producer.step_id}' first.`);
+        if (consumed.required === false)
+            continue;
+        const producerStep = consumed.from ?? findProducerStep(activeWf.handoff_chain, consumed) ?? "external";
+        const fact = artifactFacts.find(a => artifactMatches(a, consumed, producerStep, wfState.workflow));
+        if (!fact) {
+            return blockOutput(`[Intent DNA] Step '${wfState.current_step}' requires artifact '${consumed.description}' from '${producerStep}', but no verified manifest was resolved.`);
+        }
+        if (consumed.type === "git_commit" && typeof fact.metadata?.commit !== "string") {
+            return blockOutput(`[Intent DNA] Step '${wfState.current_step}' requires git_commit artifact from '${producerStep}', but no commit identity was recorded.`);
         }
     }
     return null;
@@ -390,22 +385,52 @@ function enforceHandoffConsumes(ir, wfState, existingPaths) {
  */
 export function enforceHandoffProduces(ir, wfState) {
     const activeWf = ir.workflows_ir?.find(w => w.workflow_name === wfState.workflow);
-    if (!activeWf || activeWf.handoff_chain.length === 0)
+    if (!activeWf || (activeWf.handoff_chain?.length ?? 0) === 0)
         return null;
     const currentEntry = activeWf.handoff_chain.find(h => h.step_id === wfState.current_step);
     if (!currentEntry?.produces || currentEntry.produces.length === 0)
         return null;
-    const currentArtifacts = (wfState.completed_artifacts ?? []).find(a => a.step_id === wfState.current_step);
+    const facts = wfState.artifact_facts ?? [];
     for (const produced of currentEntry.produces) {
-        if (produced.path && (!currentArtifacts || !currentArtifacts.artifacts.some(a => a.path === produced.path))) {
+        if (produced.required === false)
+            continue;
+        const fact = facts.find(a => artifactMatches(a, produced, wfState.current_step, wfState.workflow));
+        if (!fact) {
             return {
-                output: blockOutput(`[Intent DNA] Step '${wfState.current_step}' must produce artifact '${produced.description}' (path: ${produced.path}) before proceeding.`),
+                output: blockOutput(`[Intent DNA] Step '${wfState.current_step}' must produce artifact '${produced.description}' before proceeding; no verified manifest was resolved.`),
+                trace: { matched_rule: "handoff", step_id: wfState.current_step },
+            };
+        }
+        if (produced.type === "git_commit" && typeof fact.metadata?.commit !== "string") {
+            return {
+                output: blockOutput(`[Intent DNA] Step '${wfState.current_step}' must produce git_commit artifact '${produced.description}' with recorded commit identity before proceeding.`),
                 trace: { matched_rule: "handoff", step_id: wfState.current_step },
             };
         }
     }
     return null;
 }
+function findProducerStep(handoffChain, consumed) {
+    const producer = handoffChain.find(h => h.produces?.some(p => p.type === consumed.type && ((p.path && consumed.path && p.path === consumed.path) ||
+        (p.name && consumed.name && p.name === consumed.name) ||
+        (p.artifact_id && consumed.artifact_id && p.artifact_id === consumed.artifact_id))));
+    return producer?.step_id ?? null;
+}
+function artifactMatches(fact, artifact, producerStep, workflow) {
+    if (fact.workflow !== workflow)
+        return false;
+    if (fact.producer_step !== producerStep)
+        return false;
+    if (fact.type !== artifact.type)
+        return false;
+    if (artifact.path && fact.contract_path !== artifact.path && fact.path !== artifact.path)
+        return false;
+    if (artifact.name && fact.name !== artifact.name && fact.identity !== artifact.name)
+        return false;
+    if (artifact.artifact_id && fact.artifact_id !== artifact.artifact_id && fact.identity !== artifact.artifact_id)
+        return false;
+    return true;
+}
 function enforceRoleScope(rolesScopeMap, input, additionalWritePaths = []) {
     if (!input.agent_type)
         return null;
@@ -414,7 +439,7 @@ function enforceRoleScope(rolesScopeMap, input, additionalWritePaths = []) {
         const filePath = extractFilePath(input);
         if (!filePath)
             return null;
-        return checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths);
+        return checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths, true);
     }
     // Bash: extract potential write targets from command
     if (input.tool_name === "Bash") {
@@ -425,7 +450,7 @@ function enforceRoleScope(rolesScopeMap, input, additionalWritePaths = []) {
         if (writePaths.length === 0)
             return null;
         for (const p of writePaths) {
-            const result = checkPathAgainstScope(rolesScopeMap, input, p, additionalWritePaths);
+            const result = checkPathAgainstScope(rolesScopeMap, input, p, additionalWritePaths, false);
             if (result)
                 return result;
         }
@@ -434,7 +459,7 @@ function enforceRoleScope(rolesScopeMap, input, additionalWritePaths = []) {
     return null;
 }
 /** Check a single file path against role scope. Shared by Write tools and Bash. */
-function checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths = []) {
+function checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths = [], blockViolation = true) {
     const cwd = input.cwd;
     let relativePath = cwd && filePath.startsWith("/") ? relative(cwd, filePath) : filePath;
     // Normalize to resolve traversal (e.g., "src/../../test/x.ts" → "../test/x.ts")
@@ -449,10 +474,16 @@ function checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePa
             ? [...writeGlobs, ...additionalWritePaths]
             : writeGlobs;
         if (allWriteGlobs.length === 0) {
-            return allowOutput(`WARN [Intent DNA]: Role '${entry.role_name}' has no write permission (path: ${filePath}). Merge-time scope gate will filter.`);
+            const message = `Role '${entry.role_name}' has no write permission (path: ${filePath}).`;
+            return blockViolation
+                ? blockOutput(`[Intent DNA]: ${message}`)
+                : allowOutput(`WARN [Intent DNA]: ${message}`);
         }
         if (!checkWriteAllowed(relativePath, allWriteGlobs)) {
-            return allowOutput(`WARN [Intent DNA]: Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${allWriteGlobs.join(", ")}). Merge-time scope gate will filter.`);
+            const message = `Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${allWriteGlobs.join(", ")}).`;
+            return blockViolation
+                ? blockOutput(`[Intent DNA]: ${message}`)
+                : allowOutput(`WARN [Intent DNA]: ${message}`);
         }
         return null; // Role matched, write allowed
     }
@@ -540,20 +571,48 @@ function enforceOutputSchema(roles, input) {
     return null;
 }
 // ── Public Helpers ──────────────────────────────────────────
-/** Check if a file path is allowed by a list of write globs (prefix matching). */
+/** Check if a file path is allowed by a list of write globs. */
 export function checkWriteAllowed(filePath, allowedGlobs) {
+    const normalizedPath = normalize(filePath).replace(/\\/g, "/");
     for (const glob of allowedGlobs) {
-        const prefix = globToPrefix(glob);
-        if (prefix.length === 0)
-            return true; // Root glob like "*.md" — allow all
-        if (filePath.startsWith(prefix))
-            return true;
-        // Also check exact match for non-glob patterns
-        if (!glob.includes("*") && filePath === glob)
+        const normalizedGlob = normalize(glob).replace(/\\/g, "/");
+        if (normalizedGlob.includes("*")) {
+            if (globToRegExp(normalizedGlob).test(normalizedPath))
+                return true;
+            continue;
+        }
+        if (normalizedPath.startsWith(normalizedGlob))
             return true;
     }
     return false;
 }
+function globToRegExp(glob) {
+    let source = "^";
+    for (let i = 0; i < glob.length; i++) {
+        const char = glob[i];
+        if (char === "*") {
+            if (glob[i + 1] === "*") {
+                if (glob[i + 2] === "/") {
+                    source += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    source += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+            continue;
+        }
+        source += escapeRegExp(char);
+    }
+    return new RegExp(`${source}$`);
+}
+function escapeRegExp(char) {
+    return char.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+}
 /**
  * Extract directory prefix from a glob pattern.
  * "src/**\/*.ts" → "src/"
@@ -624,7 +683,9 @@ function isWriteTool(toolName) {
     return WRITE_TOOLS.has(toolName);
 }
 function extractFilePath(input) {
-    const fp = input.tool_input.file_path;
+    const fp = input.tool_name === "NotebookEdit"
+        ? input.tool_input.notebook_path
+        : input.tool_input.file_path;
     if (typeof fp === "string" && fp)
         return fp;
     return null;

package/dist/hooks/state.d.ts

@@ -9,7 +9,7 @@
  * All read operations are fail-safe (return null on error, never throw).
  * All write operations use atomic temp+rename pattern.
  */
-import type { CompletedArtifactEntry, VerifierKind, VerifierSeverity, VerifierWhen } from "../schema/types.js";
+import type { ArtifactFact, ArtifactKey, ArtifactManifest, CompletedArtifactEntry, HandoffArtifact, HandoffType, VerifierKind, VerifierSeverity, VerifierWhen } from "../schema/types.js";
 /** Workflow state written by runtime and read by hooks */
 export interface DNAWorkflowState {
     active: boolean;
@@ -19,6 +19,8 @@ export interface DNAWorkflowState {
     iteration: number;
     session_id: string;
     started_at: string;
+    inputs?: Record<string, string>;
+    resolved_variables?: Record<string, string>;
     completed_artifacts?: CompletedArtifactEntry[];
 }
 /** Audit log entry (one per line in JSON Lines format) */
@@ -48,12 +50,28 @@ export interface SurgeonAttemptState {
         lesson: string;
     }>;
 }
+export declare function safePathComponent(value: string, label: string): string;
 /**
  * Resolve state directory path.
  * With session isolation: `.dna/state/sessions/<sessionId>/`
  * Without: `.dna/state/`
  */
 export declare function resolveStateDir(projectDir: string, sessionId?: string): string;
+export declare const ARTIFACT_RESOLVER_VERSION = 1;
+export declare function isRequiredArtifact(artifact: HandoffArtifact): boolean;
+export declare function artifactIdentity(artifact: HandoffArtifact, resolvedPath?: string): string | null;
+export declare function artifactHash(key: ArtifactKey): string;
+export declare function buildArtifactKey(params: {
+    workflow: string;
+    sessionId: string;
+    producerStep: string;
+    type: HandoffType;
+    identity: string;
+}): ArtifactKey;
+export declare function artifactManifestPath(projectDir: string, key: ArtifactKey): string;
+export declare function resolveArtifactTemplate(template: string, state?: Pick<DNAWorkflowState, "inputs" | "resolved_variables">): string | null;
+export declare function writeArtifactManifest(projectDir: string, manifest: Omit<ArtifactManifest, "id" | "recorded_at" | "resolver_version">): Promise<ArtifactFact>;
+export declare function readArtifactManifest(projectDir: string, key: ArtifactKey): Promise<ArtifactFact | null>;
 /**
  * Read current workflow state. Returns null if not found or stale.
  * @deprecated Prefer `new DNAStateManager(projectDir, sessionId).readWorkflowState()`.
@@ -83,6 +101,8 @@ export declare function appendAudit(projectDir: string, entry: AuditEntry): Prom
 export declare function appendCompletedArtifact(projectDir: string, stepId: string, artifact: {
     type: string;
     path: string;
+    artifact_id?: string;
+    metadata?: Record<string, unknown>;
 }, sessionId?: string): Promise<void>;
 /** Atomic write: write to temp file then rename. */
 export declare function atomicWrite(filePath: string, data: string): Promise<void>;

package/dist/hooks/state.js

@@ -10,10 +10,27 @@
  * All write operations use atomic temp+rename pattern.
  */
 import { readFile, writeFile, rename, mkdir, appendFile, unlink, readdir, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import { join, dirname } from "node:path";
 // ── Constants ──────────────────────────────────────────────
 const WORKFLOW_FILE = "workflow.json";
 const DEFAULT_STALENESS_MS = 2 * 60 * 60 * 1000; // 2 hours
+const SAFE_PATH_COMPONENT = /^[A-Za-z0-9._-]{1,128}$/;
+const USER_ARTIFACT_PATH_ARGUMENTS = new Set(["ARGUMENTS", "arguments", "task_id"]);
+export function safePathComponent(value, label) {
+    if (value === "." || value === ".." || !SAFE_PATH_COMPONENT.test(value)) {
+        throw new Error(`Invalid ${label}`);
+    }
+    return value;
+}
+function safeUserArtifactPathArgument(value, label) {
+    try {
+        return safePathComponent(value, label);
+    }
+    catch {
+        return null;
+    }
+}
 // ── Path Resolution ────────────────────────────────────────
 /**
  * Resolve state directory path.
@@ -23,10 +40,97 @@ const DEFAULT_STALENESS_MS = 2 * 60 * 60 * 1000; // 2 hours
 export function resolveStateDir(projectDir, sessionId) {
     const base = join(projectDir, ".dna", "state");
     if (sessionId) {
-        return join(base, "sessions", sessionId);
+        return join(base, "sessions", safePathComponent(sessionId, "session_id"));
     }
     return base;
 }
+export const ARTIFACT_RESOLVER_VERSION = 1;
+export function isRequiredArtifact(artifact) {
+    return artifact.required !== false;
+}
+export function artifactIdentity(artifact, resolvedPath) {
+    return artifact.artifact_id ?? artifact.name ?? resolvedPath ?? (artifact.type === "git_commit" ? "git_commit" : null);
+}
+export function artifactHash(key) {
+    return createHash("sha256")
+        .update(JSON.stringify(key))
+        .digest("hex")
+        .slice(0, 16);
+}
+export function buildArtifactKey(params) {
+    return {
+        workflow: params.workflow,
+        session_id: params.sessionId,
+        producer_step: params.producerStep,
+        type: params.type,
+        identity: params.identity,
+    };
+}
+export function artifactManifestPath(projectDir, key) {
+    return join(resolveStateDir(projectDir, key.session_id), "handoffs", safePathComponent(key.workflow, "workflow"), safePathComponent(key.producer_step, "producer_step"), `${artifactHash(key)}.json`);
+}
+export function resolveArtifactTemplate(template, state) {
+    let resolved = template;
+    const inputs = state?.inputs ?? {};
+    const resolvedVariables = state?.resolved_variables ?? {};
+    resolved = resolved.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
+        const inputValue = inputs[name];
+        if (inputValue !== undefined) {
+            return safeUserArtifactPathArgument(inputValue, name) ?? `{{${name}}}`;
+        }
+        const resolvedValue = resolvedVariables[name];
+        if (resolvedValue === undefined)
+            return `{{${name}}}`;
+        if (USER_ARTIFACT_PATH_ARGUMENTS.has(name)) {
+            return safeUserArtifactPathArgument(resolvedValue, name) ?? `{{${name}}}`;
+        }
+        return resolvedValue;
+    });
+    const args = inputs.ARGUMENTS ?? inputs.arguments ?? inputs.task_id ?? resolvedVariables.ARGUMENTS ?? resolvedVariables.arguments ?? resolvedVariables.task_id;
+    if (resolved.includes("$ARGUMENTS")) {
+        if (args === undefined)
+            return null;
+        const safeArgs = safeUserArtifactPathArgument(args, "ARGUMENTS");
+        if (!safeArgs)
+            return null;
+        resolved = resolved.replaceAll("$ARGUMENTS", safeArgs);
+    }
+    if (/\{\{\w+\}\}/.test(resolved))
+        return null;
+    return resolved;
+}
+export async function writeArtifactManifest(projectDir, manifest) {
+    const id = artifactHash(manifest.key);
+    const full = {
+        ...manifest,
+        id,
+        recorded_at: new Date().toISOString(),
+        resolver_version: ARTIFACT_RESOLVER_VERSION,
+    };
+    const manifestPath = artifactManifestPath(projectDir, manifest.key);
+    await atomicWrite(manifestPath, JSON.stringify(full, null, 2));
+    return { ...full, manifest_path: manifestPath };
+}
+export async function readArtifactManifest(projectDir, key) {
+    const manifestPath = artifactManifestPath(projectDir, key);
+    try {
+        const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+        if (manifest.resolver_version !== ARTIFACT_RESOLVER_VERSION)
+            return null;
+        if (manifest.key.workflow !== key.workflow || manifest.key.session_id !== key.session_id ||
+            manifest.key.producer_step !== key.producer_step || manifest.key.type !== key.type ||
+            manifest.key.identity !== key.identity)
+            return null;
+        if (manifest.workflow !== key.workflow || manifest.session_id !== key.session_id ||
+            manifest.producer_step !== key.producer_step || manifest.type !== key.type ||
+            manifest.identity !== key.identity)
+            return null;
+        return { ...manifest, manifest_path: manifestPath };
+    }
+    catch {
+        return null;
+    }
+}
 // ── Workflow State ─────────────────────────────────────────
 /**
  * Read current workflow state. Returns null if not found or stale.
@@ -121,13 +225,24 @@ export async function appendCompletedArtifact(projectDir, stepId, artifact, sess
         stepEntry = { step_id: stepId, artifacts: [] };
         artifacts.push(stepEntry);
     }
-    // Dedup: don't add if same path already recorded
-    if (stepEntry.artifacts.some(a => a.path === artifact.path))
+    const verifiedAt = new Date().toISOString();
+    const existing = stepEntry.artifacts.find(a => a.type === artifact.type && a.path === artifact.path);
+    if (existing) {
+        existing.verified_at = verifiedAt;
+        if (artifact.artifact_id)
+            existing.artifact_id = artifact.artifact_id;
+        if (artifact.metadata)
+            existing.metadata = artifact.metadata;
+        state.completed_artifacts = artifacts;
+        await writeWorkflowState(projectDir, state, sessionId);
         return;
+    }
     stepEntry.artifacts.push({
         type: artifact.type,
         path: artifact.path,
-        verified_at: new Date().toISOString(),
+        verified_at: verifiedAt,
+        ...(artifact.artifact_id ? { artifact_id: artifact.artifact_id } : {}),
+        ...(artifact.metadata ? { metadata: artifact.metadata } : {}),
     });
     state.completed_artifacts = artifacts;
     await writeWorkflowState(projectDir, state, sessionId);

package/dist/mcp/tools-state.js

@@ -11,6 +11,10 @@ import { resolve } from "node:path";
 import { readWorkflowState, writeWorkflowState, readTraces, listSessions } from "../hooks/state.js";
 import { loadCompiledIR } from "../runtime/plugin-adapter.js";
 import { textResult } from "./server.js";
+function isStringRecord(value) {
+    return typeof value === "object" && value !== null &&
+        Object.values(value).every(v => typeof v === "string");
+}
 export function createStateTools(projectDir) {
     return [
         // ── dna_status ────────────────────────────────────────
@@ -95,6 +99,8 @@ export function createStateTools(projectDir) {
                     iteration: { type: "number", description: "Current iteration number" },
                     active: { type: "boolean", description: "Whether workflow is active (false to deactivate)" },
                     session_id: { type: "string", description: "Session ID for isolation" },
+                    inputs: { type: "object", description: "Workflow runtime inputs such as ARGUMENTS" },
+                    resolved_variables: { type: "object", description: "Resolved template variables for artifact paths" },
                 },
                 required: ["workflow", "current_step", "current_role"],
             },
@@ -109,6 +115,8 @@ export function createStateTools(projectDir) {
                     iteration: typeof args.iteration === "number" ? args.iteration : (existing?.iteration ?? 1),
                     session_id: sessionId ?? existing?.session_id ?? "",
                     started_at: existing?.started_at ?? new Date().toISOString(),
+                    inputs: isStringRecord(args.inputs) ? args.inputs : existing?.inputs,
+                    resolved_variables: isStringRecord(args.resolved_variables) ? args.resolved_variables : existing?.resolved_variables,
                     completed_artifacts: existing?.completed_artifacts,
                 };
                 await writeWorkflowState(projectDir, state, sessionId);

package/dist/runtime/settings-adapter.js

@@ -70,10 +70,10 @@ export function detectEnabledEvents(ir) {
     const hasStopVerifiers = ir.verifier_specs?.some((spec) => spec.when === "stop" || spec.when === "pre_handoff" || spec.when === "post_step") ?? false;
     const hasPostToolVerifiers = ir.verifier_specs?.some((spec) => spec.when === "post_tool_use") ?? false;
     const hasHandoffs = ir.workflows_ir?.some((wf) => wf.handoff_chain.length > 0) ?? false;
-    if (hasGates || hasFilters || hasRoleScope || hasCheckpoints) {
+    if (hasGates || hasFilters || hasRoleScope || hasCheckpoints || hasHandoffs) {
         events.push("preToolUse");
     }
-    if (ir.post_execution_validators.length > 0 || hasPostToolVerifiers) {
+    if (ir.post_execution_validators.length > 0 || hasPostToolVerifiers || hasHandoffs) {
         events.push("postToolUse");
     }
     if (ir.prompt_directives.some(d => d.priority === "high")) {

package/dist/runtime/skill-adapter.d.ts

@@ -6,13 +6,14 @@
  *
  * Skills are compiled views of DNA's structured definitions — not stored content.
  */
-import type { WorkflowPlan, RoleDef, ConstraintIR } from "../schema/types.js";
+import type { WorkflowPlan, WorkflowDef, RoleDef, ConstraintIR, ControllerDef } from "../schema/types.js";
 export interface SkillResult {
     name: string;
     fileName: string;
     dirName: string;
     content: string;
 }
+export declare function compileControllerToSkill(controllerKey: string, controller: ControllerDef, variables?: Record<string, string>, workflows?: Record<string, WorkflowDef>): SkillResult;
 /**
  * Compile a WorkflowPlan + roles + IR into a SKILL.md file.
  * Variables from DNA config are substituted into prompts and descriptions.