intentdna 1.7.5 → 1.8.1

package/dist/cli/commands/run.d.ts

@@ -6,6 +6,7 @@
  * via `claude -p --agent` child processes.
  */
 import type { WorkflowStep, ParallelGroup, TransitionRule } from "../../schema/types.js";
+import type { ConstraintIR } from "../../schema/types.js";
 export interface RunOptions {
     dnaFiles: string[];
     workflowName: string;
@@ -18,6 +19,7 @@ export interface RunOptions {
     permissionMode?: string;
     agentsDir?: string;
     hooksDir?: string;
+    projectDir?: string;
 }
 export interface StepResult {
     stepId: string;
@@ -30,6 +32,11 @@ interface StepExecOptions {
     maxBudget: number;
     permissionMode: string;
     logDir: string;
+    projectDir: string;
+    workflowName: string;
+    workflowAsset?: string;
+    inputs: Record<string, string>;
+    ir: Pick<ConstraintIR, "verifier_policy">;
 }
 /**
  * Replace {{var}} placeholders in a template string.
@@ -45,7 +52,7 @@ export declare function evaluateRunIf(condition: string | null, round: number):
  * Execute a single workflow step via `claude -p --agent`.
  * Returns StepResult with pass/fail status.
  */
-export declare function executeStep(step: WorkflowStep, vars: Record<string, string>, opts: StepExecOptions): Promise<StepResult>;
+export declare function executeStep(step: WorkflowStep, vars: Record<string, string>, opts: StepExecOptions, iteration?: number): Promise<StepResult>;
 /**
  * Execute a parallel group of steps.
  */

package/dist/cli/commands/run.js

@@ -7,13 +7,17 @@
  */
 import { spawn } from "node:child_process";
 import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { loadDNA, compileFromFiles, expandDNAInputFiles } from "../../compiler/index.js";
 import { cascadeDNA } from "../../compiler/cascade.js";
 import { compileWorkflow } from "../../compiler/workflow.js";
 import { compileAllRolesToAgentMD, writeAgentMDFiles, toKebabCase, } from "../../runtime/agent-md.js";
 import { createCompiledIR, writeCompiledIR } from "../../runtime/plugin-adapter.js";
+import { trustedEvidenceCaptureAttribution } from "../../governance/index.js";
+import { DNAStateManager } from "../../hooks/state-manager.js";
+import { appendEvidenceCaptureEvent, EVIDENCE_CAPTURE_SCHEMA_VERSION, } from "../../hooks/state.js";
+import { runCompletionVerifier, runCheckpointVerifier, } from "../../runtime/verifier.js";
 // ── Template & Condition Helpers ───────────────────────────
 /**
  * Replace {{var}} placeholders in a template string.
@@ -53,65 +57,75 @@ export function evaluateRunIf(condition, round) {
  * Run checkpoint assertions for a completed step.
  * Returns true if all checkpoints pass, false if any fail.
  */
-async function runCheckpoints(step) {
+async function runCompletions(step, vars, opts) {
+    if (!step.completion)
+        return true;
+    for (const completion of step.completion) {
+        const result = await runCompletionVerifier(completion, opts.ir, {
+            projectDir: opts.projectDir,
+            variables: vars,
+        });
+        if (!result.passed) {
+            logVerifierFailure("Completion failed", step.id, result);
+            return false;
+        }
+    }
+    return true;
+}
+async function runCheckpoints(step, vars, opts) {
     if (!step.checkpoints)
         return true;
-    const assertCommands = {
-        clean_working_tree: 'git status --porcelain',
-        lint_passing: 'npm run lint --silent 2>/dev/null',
-        build_passing: 'npm run build --silent 2>/dev/null',
-    };
     for (const cp of step.checkpoints) {
         const action = cp.action ?? "block";
-        let passed = false;
-        try {
-            if (cp.command) {
-                // Custom command — must exit 0
-                await spawnAsync("bash", ["-c", cp.command], "");
-                passed = true;
-            }
-            else if (cp.assert === "clean_working_tree") {
-                const output = await spawnAsync("git", ["status", "--porcelain"], "");
-                passed = output.trim() === "";
-            }
-            else if (cp.assert === "no_test_regression") {
-                // Read baselines from .dna/
-                const { readFile: rf } = await import("node:fs/promises");
-                const baseline = parseInt(await rf(".dna/test-baseline", "utf-8").catch(() => "0"), 10);
-                const current = parseInt(await rf(".dna/test-current", "utf-8").catch(() => "0"), 10);
-                passed = current <= baseline;
-            }
-            else if (assertCommands[cp.assert]) {
-                await spawnAsync("bash", ["-c", assertCommands[cp.assert]], "");
-                passed = true;
-            }
-            else {
-                log(`Unknown checkpoint assert: ${cp.assert} (step: ${step.id})`);
-                passed = false;
-            }
-        }
-        catch {
-            passed = false;
-        }
-        if (!passed) {
-            log(`Checkpoint failed: ${cp.assert} — ${cp.message} (step: ${step.id})`);
+        const result = await runCheckpointVerifier(cp, opts.ir, {
+            projectDir: opts.projectDir,
+            variables: vars,
+        });
+        if (!result.passed) {
+            logVerifierFailure(`Checkpoint failed: ${cp.assert}`, step.id, result);
             if (action === "block")
                 return false;
         }
     }
     return true;
 }
+function logVerifierFailure(prefix, stepId, result) {
+    const exitCode = result.exit_code === undefined ? "" : ` exit_code=${result.exit_code}`;
+    const target = result.target ? ` target=${result.target}` : "";
+    const message = result.message ? ` — ${result.message}` : "";
+    log(`${prefix}${target}${exitCode}${message} (step: ${stepId})`);
+}
 // ── Step Execution ─────────────────────────────────────────
+async function recordStepResultEvidence(step, opts, sessionId, status, durationMs) {
+    const result = status === "pass" ? "success" : "failure";
+    await appendEvidenceCaptureEvent(opts.projectDir, {
+        schema_version: EVIDENCE_CAPTURE_SCHEMA_VERSION,
+        event_id: `c5:${randomUUID()}`,
+        captured_at: new Date().toISOString(),
+        project_root: opts.projectDir,
+        source: "dna_cli",
+        workflow_asset: opts.workflowAsset ?? "unknown",
+        workflow_id: opts.workflowName,
+        run_id: sessionId,
+        step_id: step.id,
+        fact: "result",
+        summary: `dna run recorded ${result} for workflow step ${step.id}`,
+        result,
+        duration_ms: durationMs,
+    });
+}
 /**
  * Execute a single workflow step via `claude -p --agent`.
  * Returns StepResult with pass/fail status.
  */
-export async function executeStep(step, vars, opts) {
+export async function executeStep(step, vars, opts, iteration = 1) {
     const start = Date.now();
     const prompt = substituteTemplate(step.prompt ?? step.description, vars);
     const agentName = `${opts.agentPrefix}${toKebabCase(step.role)}`;
     const sessionId = randomUUID();
     const resultFile = join(opts.logDir, `${step.id}-result.json`);
+    const stateManager = new DNAStateManager(opts.projectDir, sessionId);
+    let stateWritten = false;
     const args = [
         "-p",
         "--agent",
@@ -128,7 +142,25 @@ export async function executeStep(step, vars, opts) {
     ];
     log(`Running step: ${step.id} (agent: ${agentName})`);
     try {
-        const output = await spawnAsync("claude", args, prompt);
+        try {
+            await stateManager.writeWorkflowState({
+                active: true,
+                workflow_asset: opts.workflowAsset,
+                workflow: opts.workflowName,
+                current_step: step.id,
+                current_role: step.role,
+                iteration,
+                session_id: sessionId,
+                started_at: new Date(start).toISOString(),
+                inputs: opts.inputs,
+                resolved_variables: vars,
+            });
+            stateWritten = true;
+        }
+        catch (error) {
+            log(`Workflow evidence state unavailable for ${step.id}; continuing fail-open: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const output = await spawnAsync("claude", args, prompt, opts.projectDir);
         await writeFile(resultFile, output, "utf-8");
         // Check for error in JSON output
         let isError = false;
@@ -140,20 +172,44 @@ export async function executeStep(step, vars, opts) {
             // Non-JSON output → treat as success
         }
         const status = isError ? "fail" : "pass";
-        // Run checkpoints if step passed and has checkpoints defined
+        if (status === "pass" && step.completion && step.completion.length > 0) {
+            const completionsPassed = await runCompletions(step, vars, opts);
+            if (!completionsPassed) {
+                const durationMs = Date.now() - start;
+                await recordStepResultEvidence(step, opts, sessionId, "fail", durationMs);
+                log(`Step ${step.id} COMPLETION_FAIL (${durationMs}ms)`);
+                return { stepId: step.id, status: "fail", durationMs, resultFile };
+            }
+        }
         if (status === "pass" && step.checkpoints && step.checkpoints.length > 0) {
-            const checkpointsPassed = await runCheckpoints(step);
+            const checkpointsPassed = await runCheckpoints(step, vars, opts);
             if (!checkpointsPassed) {
-                log(`Step ${step.id} CHECKPOINT_FAIL (${Date.now() - start}ms)`);
-                return { stepId: step.id, status: "fail", durationMs: Date.now() - start, resultFile };
+                const durationMs = Date.now() - start;
+                await recordStepResultEvidence(step, opts, sessionId, "fail", durationMs);
+                log(`Step ${step.id} CHECKPOINT_FAIL (${durationMs}ms)`);
+                return { stepId: step.id, status: "fail", durationMs, resultFile };
             }
         }
-        log(`Step ${step.id} ${status.toUpperCase()} (${Date.now() - start}ms)`);
-        return { stepId: step.id, status, durationMs: Date.now() - start, resultFile };
+        const durationMs = Date.now() - start;
+        await recordStepResultEvidence(step, opts, sessionId, status, durationMs);
+        log(`Step ${step.id} ${status.toUpperCase()} (${durationMs}ms)`);
+        return { stepId: step.id, status, durationMs, resultFile };
     }
     catch {
-        log(`Step ${step.id} FAIL (process error, ${Date.now() - start}ms)`);
-        return { stepId: step.id, status: "fail", durationMs: Date.now() - start };
+        const durationMs = Date.now() - start;
+        await recordStepResultEvidence(step, opts, sessionId, "fail", durationMs);
+        log(`Step ${step.id} FAIL (process error, ${durationMs}ms)`);
+        return { stepId: step.id, status: "fail", durationMs };
+    }
+    finally {
+        if (stateWritten) {
+            try {
+                await stateManager.clearWorkflowState();
+            }
+            catch (error) {
+                log(`Workflow evidence state cleanup failed for ${step.id}; continuing fail-open: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
     }
 }
 /**
@@ -180,13 +236,13 @@ export async function executeGroup(group, allSteps, round, vars, opts) {
         return results.filter((r) => r.status === "skipped");
     // Single step: sequential
     if (executable.length === 1) {
-        const result = await executeStep(executable[0], vars, opts);
+        const result = await executeStep(executable[0], vars, opts, round);
         const skipped = results.filter((r) => r.status === "skipped");
         return [...skipped, result];
     }
     // Multiple steps: parallel
     log(`Running ${executable.length} steps in parallel`);
-    const parallelResults = await Promise.all(executable.map((step) => executeStep(step, vars, opts)));
+    const parallelResults = await Promise.all(executable.map((step) => executeStep(step, vars, opts, round)));
     const skipped = results.filter((r) => r.status === "skipped");
     return [...skipped, ...parallelResults];
 }
@@ -205,10 +261,11 @@ export function checkRetryNeeded(stepResults, transitions) {
     return false;
 }
 // ── Spawn Helper ───────────────────────────────────────────
-function spawnAsync(command, args, stdinData) {
+function spawnAsync(command, args, stdinData, cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {
             stdio: ["pipe", "pipe", "pipe"],
+            cwd,
         });
         let stdout = "";
         let stderr = "";
@@ -255,11 +312,12 @@ export async function runRun(opts) {
     }
     const maxBudget = opts.maxBudget ?? 5;
     const permissionMode = opts.permissionMode ?? "default";
-    const agentsDir = opts.agentsDir ?? ".claude/agents";
+    const projectDir = resolve(opts.projectDir ?? process.cwd());
+    const agentsDir = opts.agentsDir ? resolve(projectDir, opts.agentsDir) : join(projectDir, ".claude", "agents");
     try {
         // ── Step 1: Load & compile DNA ───────────────────────
         log("Loading DNA files...");
-        const expandedDNAFiles = await expandDNAInputFiles(opts.dnaFiles);
+        const expandedDNAFiles = await expandDNAInputFiles(opts.dnaFiles, { cwd: projectDir });
         const dnas = await Promise.all(expandedDNAFiles.map(loadDNA));
         const cascaded = cascadeDNA(dnas);
         const ir = await compileFromFiles(expandedDNAFiles, {
@@ -283,9 +341,10 @@ export async function runRun(opts) {
         log(`Compiled workflow: ${plan.name} (${plan.steps.length} steps, ${plan.parallel_groups.length} groups)`);
         // ── Step 3: Build template variables ─────────────────
         const vars = {
+            ...(opts.vars ?? {}),
             task_id: opts.taskId,
+            ARGUMENTS: opts.taskId,
             workflow: opts.workflowName,
-            ...(opts.vars ?? {}),
         };
         // ── Dry-run mode ─────────────────────────────────────
         if (opts.dryRun) {
@@ -297,17 +356,30 @@ export async function runRun(opts) {
         await writeAgentMDFiles(agentResults, agentsDir);
         log(`Generated ${agentResults.length} agent file(s) in ${agentsDir}`);
         const hookScripts = createCompiledIR(ir, cascaded.roles);
-        await writeCompiledIR(process.cwd(), hookScripts);
+        await writeCompiledIR(projectDir, hookScripts);
         log("Synced compiled IR for dna-hook enforcement");
         // ── Step 5: Prepare log directory ────────────────────
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const logDir = opts.logDir ?? join(".intentdna", "runs", `${opts.workflowName}-${timestamp}`);
+        const logDir = opts.logDir
+            ? resolve(projectDir, opts.logDir)
+            : join(projectDir, ".intentdna", "runs", `${opts.workflowName}-${timestamp}`);
         await mkdir(logDir, { recursive: true });
+        const attribution = trustedEvidenceCaptureAttribution(ir, { workflowId: opts.workflowName });
         const execOpts = {
             agentPrefix: "dna-",
             maxBudget,
             permissionMode,
             logDir,
+            projectDir,
+            workflowName: opts.workflowName,
+            workflowAsset: attribution.workflowAsset === "unknown" ? undefined : attribution.workflowAsset,
+            inputs: {
+                ...(opts.vars ?? {}),
+                task_id: opts.taskId,
+                ARGUMENTS: opts.taskId,
+                workflow: opts.workflowName,
+            },
+            ir,
         };
         // ── Step 6: Execute workflow ──────────────────────────
         const maxRetries = plan.retry.max_retries;

package/dist/cli/commands/sync.d.ts

@@ -10,9 +10,11 @@
  *
  * Targets: claude-md, soul-md, cursorrules, system-prompt
  */
+import type { CodexHookInstallMode } from "../../runtime/codex-adapter.js";
 export type SyncMode = "auto" | "plugin" | "bin";
 export interface SyncOptions {
     files: string[];
+    action?: "run" | "status" | "doctor" | "remove-registry";
     target: string;
     inject: string;
     context?: string;
@@ -26,11 +28,16 @@ export interface SyncOptions {
     skillsDir?: string;
     settingsPath?: string;
     lockFile?: string;
+    codex?: boolean;
+    codexInstallMode?: CodexHookInstallMode;
+    codexDogfood?: boolean;
     remove: boolean;
     mode?: SyncMode;
     plugin?: boolean;
     dryRun?: boolean;
     postSummary?: boolean;
+    json?: boolean;
+    projectDir?: string;
 }
 /**
  * Detect whether intentdna is running as a Claude Code plugin or standalone binary.
@@ -54,7 +61,7 @@ export declare function cleanStaleDNAFiles(dir: string, type: "agents" | "skills
  * Auto-detect DNA config file in current directory (legacy single-config).
  * Priority: .dna/config.yaml > .dna/config.yml > .dna/config.json > .dna.yaml > .dna.yml > .dna.json
  */
-export declare function autoDetectConfigs(): Promise<string[]>;
+export declare function autoDetectConfigs(projectDir?: string): Promise<string[]>;
 /**
  * Read the current package version from package.json.
  */