intentdna 1.5.7 → 1.5.9

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "DNA template compilation + runtime enforcement",
-      "version": "1.5.7",
+      "version": "1.5.9",
       "source": "./"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "intentdna",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "description": "Declarative policy layer for AI agent governance"
 }

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

@@ -0,0 +1,10 @@
+/**
+ * dna templates deploy — copy local src/templates/*.dna.yaml to global intentdna install
+ */
+export interface TemplatesDeployOptions {
+    /** Override local templates dir (for testing) */
+    localDir?: string;
+    /** Override global target dir (for testing) */
+    globalDir?: string;
+}
+export declare function runTemplatesDeploy(opts?: TemplatesDeployOptions): Promise<number>;

package/dist/cli/commands/templates.js

@@ -0,0 +1,85 @@
+/**
+ * dna templates deploy — copy local src/templates/*.dna.yaml to global intentdna install
+ */
+import { readdirSync, copyFileSync, existsSync, readFileSync, mkdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { execSync } from "node:child_process";
+/**
+ * Resolve the global intentdna templates directory.
+ * Strategy: npm root -g + /intentdna/dist/templates
+ */
+function resolveGlobalTemplatesDir() {
+    let globalRoot;
+    try {
+        globalRoot = execSync("npm root -g", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        throw new Error("Failed to resolve npm global root. Is npm installed?");
+    }
+    const globalPkg = join(globalRoot, "intentdna");
+    if (!existsSync(globalPkg)) {
+        throw new Error("intentdna not installed globally, run: npm install -g intentdna");
+    }
+    // Templates live in dist/templates after build, and src/templates in source
+    const distTemplates = join(globalPkg, "dist", "templates");
+    const srcTemplates = join(globalPkg, "src", "templates");
+    if (existsSync(distTemplates))
+        return distTemplates;
+    if (existsSync(srcTemplates))
+        return srcTemplates;
+    // Create dist/templates if neither exists (fresh install edge case)
+    mkdirSync(distTemplates, { recursive: true });
+    return distTemplates;
+}
+/**
+ * Verify we're in the intentdna project root.
+ */
+function verifyProjectRoot(cwd) {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) {
+        throw new Error("must run from intentdna project root (no package.json found)");
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg.name !== "intentdna") {
+        throw new Error("must run from intentdna project root (package.json name is not 'intentdna')");
+    }
+    return cwd;
+}
+export async function runTemplatesDeploy(opts = {}) {
+    try {
+        const cwd = process.cwd();
+        const projectRoot = verifyProjectRoot(cwd);
+        const localDir = opts.localDir ?? resolve(projectRoot, "src", "templates");
+        const globalDir = opts.globalDir ?? resolveGlobalTemplatesDir();
+        if (!existsSync(localDir)) {
+            process.stderr.write(`Error: local templates dir not found: ${localDir}\n`);
+            return 1;
+        }
+        const files = readdirSync(localDir).filter((f) => f.endsWith(".dna.yaml"));
+        if (files.length === 0) {
+            process.stderr.write("No *.dna.yaml files found in local templates dir\n");
+            return 1;
+        }
+        let copied = 0;
+        for (const file of files) {
+            const src = join(localDir, file);
+            const dst = join(globalDir, file);
+            try {
+                copyFileSync(src, dst);
+                copied++;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`Error copying ${file}: ${msg}\n`);
+                return 1;
+            }
+        }
+        process.stderr.write(`Copied ${copied} templates to ${globalDir}\n`);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: ${msg}\n`);
+        return 1;
+    }
+}

package/dist/cli/index.js

@@ -30,6 +30,7 @@ Commands:
   evolve        Generate epigenetic markers from outcomes
   epigenetic    Record outcomes, view markers and summaries
   feedback      Analyze trace data, suggest template optimizations (--days <N>, --json, --evolve)
+  templates     Template management (deploy to global install)
 
 Options:
   --help, -h    Show help for a command
@@ -428,6 +429,17 @@ async function main() {
             process.exit(code);
             break;
         }
+        case "templates": {
+            const subcommand = rest[0] ?? "";
+            if (subcommand !== "deploy") {
+                process.stderr.write(`Usage: dna templates deploy\n\nCopy local src/templates/*.dna.yaml to global intentdna install.\n`);
+                process.exit(subcommand ? 2 : 0);
+            }
+            const { runTemplatesDeploy } = await import("./commands/templates.js");
+            const code = await runTemplatesDeploy();
+            process.exit(code);
+            break;
+        }
         default:
             process.stderr.write(`Unknown command: ${command}\n\n`);
             process.stderr.write(HELP);

package/dist/compiler/activate.d.ts

@@ -20,6 +20,7 @@ export interface ActivatedGene {
     codons: Codon[];
     tags: string[];
     expression_level: number;
+    role?: "constraint" | "workflow_hint";
 }
 /**
  * Activate a cascaded DNA for a given context and role.

package/dist/compiler/activate.js

@@ -74,6 +74,7 @@ export function activateDNA(cascaded, contextName = null, activeRole = null) {
             codons: [...gene.codons],
             tags: [...(gene.tags ?? [])],
             expression_level: 1.0,
+            role: gene.role,
         };
     }
     // Apply context modifiers if a context is active

package/dist/compiler/compile.js

@@ -55,6 +55,14 @@ function geneToDirectives(name, gene) {
     if (weights.length > 0) {
         parts.push(`Trade-offs: ${weights.join("; ")}.`);
     }
+    // For workflow_hint genes, threshold codons become prompt directives instead of gates
+    if (gene.role === "workflow_hint") {
+        for (const codon of gene.codons) {
+            if (codon.type === "threshold") {
+                parts.push(`Condition: ${codon.condition}.`);
+            }
+        }
+    }
     if (parts.length > 1) {
         directives.push({
             priority,
@@ -153,9 +161,11 @@ export function compileDNA(activated, cascaded) {
     const injections = [];
     for (const [name, gene] of Object.entries(activated.genes)) {
         directives.push(...geneToDirectives(name, gene));
-        toolFilters.push(...geneToToolFilters(name, gene));
-        gates.push(...geneToGates(name, gene));
-        validators.push(...geneToValidators(name, gene));
+        if (gene.role !== "workflow_hint") {
+            toolFilters.push(...geneToToolFilters(name, gene));
+            gates.push(...geneToGates(name, gene));
+            validators.push(...geneToValidators(name, gene));
+        }
     }
     // Compile role constraints
     let roleToolPermissions;

package/dist/schema/types.d.ts

@@ -37,6 +37,7 @@ export interface Gene {
     description: string;
     codons: Codon[];
     tags?: string[];
+    role?: "constraint" | "workflow_hint";
 }
 export type ModifierAction = "amplify" | "suppress" | "activate" | "deactivate";
 export interface GeneModifier {

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

@@ -0,0 +1,152 @@
+version: "0.1.0"
+id: template_code_cleanup
+name: Code Cleanup (Regression-Safe)
+type: project
+namespace: cc
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  test_between_passes:
+    description: Tests must pass between each cleanup pass
+    codons:
+      - type: threshold
+        condition: "tests_passing == true"
+        action: block
+      - type: attract
+        target: run_tests_after_each_pass
+
+  no_behavior_change:
+    description: Cleanup must not change observable behavior
+    codons:
+      - type: threshold
+        condition: "behavior_changed == false"
+        action: block
+      - type: repel
+        target: modify_public_api
+      - type: attract
+        target: same_inputs_same_outputs
+
+  smell_focused:
+    description: Clean by smell type in order - dead code, duplication, naming
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: categorize_before_cleaning
+      - type: attract
+        target: one_smell_type_per_pass
+
+  minimal_cleanup:
+    description: Each pass focuses on one type of issue
+    codons:
+      - type: attract
+        target: single_concern_per_pass
+      - type: repel
+        target: mixed_cleanup_types
+      - type: threshold
+        condition: "files_changed_per_pass <= 10"
+        action: escalate
+
+contexts: {}
+
+roles:
+  analyzer:
+    description: Analyzes code for cleanup opportunities. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Classify code smells by type (dead code, duplication, naming, complexity)
+      - Prioritize by impact and risk
+      - Do NOT suggest behavioral changes
+      - Output a categorized cleanup plan
+
+  cleaner:
+    description: Executes cleanup changes. Can modify code.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**"]
+    instructions:
+      - Follow the analyzer's cleanup plan
+      - One smell type per pass
+      - Run tests after each file change
+      - Revert if tests fail
+      - Do not change public APIs or observable behavior
+      - Commit after each successful pass
+
+  reviewer:
+    description: Reviews cleanup changes for correctness. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Review git diff for each cleanup pass
+      - Verify no behavioral changes
+      - Check test coverage unchanged
+      - "Verdict: APPROVE or REQUEST_CHANGES"
+
+workflows:
+  cleanup:
+    name: Code Cleanup
+    description: "Regression-safe code cleanup: analyze, classify, clean by smell type, verify"
+    steps:
+      - id: lock_behavior
+        role: analyzer
+        description: "Assess current test coverage and establish behavior baseline."
+        prompt: |
+          Run existing tests to establish baseline.
+          Record: total tests, passing, failing.
+          If test coverage is insufficient, warn before proceeding.
+          Output: baseline test results + coverage assessment.
+
+      - id: classify
+        role: analyzer
+        depends_on: [lock_behavior]
+        description: "Scan codebase and categorize code smells."
+        prompt: |
+          Scan the codebase for code smells. Categorize:
+          1. Dead code (unused imports, unreachable branches, commented-out code)
+          2. Duplication (copy-paste patterns, similar functions)
+          3. Naming (unclear names, inconsistent conventions)
+          4. Complexity (long functions, deep nesting)
+
+          Prioritize: dead code first (safest), then duplication, then naming.
+          Output: categorized cleanup plan with file paths and line numbers.
+
+      - id: clean
+        role: cleaner
+        depends_on: [classify]
+        description: "Execute cleanup one smell type at a time."
+        prompt: |
+          Follow the cleanup plan. Rules:
+          - One smell type per pass (start with dead code)
+          - Run tests after each file change
+          - If tests fail: revert immediately, report the issue
+          - Maximum 10 files per pass
+          - Commit after each successful pass: "cleanup($TYPE): description"
+          - Do NOT change any public API signatures
+          - Do NOT rename exported symbols
+          - Do NOT modify test files (unless removing dead test helpers)
+
+      - id: verify
+        role: reviewer
+        depends_on: [clean]
+        description: "Verify cleanup preserved behavior."
+        prompt: |
+          Review all cleanup changes (git diff from baseline):
+          1. Any behavioral changes? (API signatures, return values, side effects)
+          2. Test count unchanged or increased?
+          3. All tests still passing?
+          4. No unintended file modifications?
+
+          Verdict: APPROVE (cleanup complete) or REQUEST_CHANGES (list issues)

package/dist/templates/flutter-rewrite.dna.yaml

@@ -168,7 +168,12 @@ roles:
       - Never suggest code changes
       - "If round > 1: review previous round's git diff first, judge if direction is correct"
       - "If previous fix produced 0 red→green transitions: warn 'no progress'"
-      - "Categorize by severity: CRITICAL (compile errors) > HIGH (logic failures) > LOW (widget/style)"
+      - "Categorize by severity and type:"
+      - "  CRITICAL: compile errors, import failures — blocks everything"
+      - "  HIGH-INFRA: mock incomplete causing test hang — blocks behavior verification, fix mock infrastructure first"
+      - "  HIGH-LOGIC: logic test failures (state/notifier) — behavior inconsistency"
+      - "  MEDIUM: widget test failures (rendering/navigation)"
+      - "hung tests ≠ failed tests. hung = mock infrastructure problem (needs mock fix), failed = behavior inconsistency (needs v2 code fix)"
 
   surgeon:
     description: Fixes breakpoints and builds missing layers by understanding v1 intent and rewriting in v2 style.
@@ -248,8 +253,9 @@ workflows:
           Scenario 2 (re-run/incremental):
           - Read the incremental diff from behavior doc
           - Update existing tests incrementally — do NOT rewrite all tests (preserves rescue progress)
-          - Run `flutter test {{test_path}}/$ARGUMENTS/` with NO timeout — record baseline
-          - Append baseline to behavior doc
+          - Run `flutter test {{test_path}}/$ARGUMENTS/ --timeout 30s` — per-test safety net (hung tests marked fail, continues to next)
+          - Classify results: passed / failed (behavior mismatch) / hung (timed out = mock infrastructure issue, NOT behavior failure)
+          - Append baseline to behavior doc with hung/failed distinction
           - Git commit: "behavior-lock($ARGUMENTS): N tests (X green, Y red from behavior change)"
 
           BANNED patterns:
@@ -273,6 +279,13 @@ workflows:
     description: "Fix v2 module $ARGUMENTS — investigate, fix, review, verify, report. Max 10 rounds with convergence protection."
     max_rounds: 10
     convergence_rule: "2 consecutive rounds with 0 test progress (green count not increasing) → STOP. Output blocked items + analysis."
+    round_budget: "Max 5 files per round. Each round must produce at least 1 test transition (red/skip/hung → green), otherwise counted as no progress."
+    priority_order: |
+      Phase 1: Fix CRITICAL (compile errors) — unblocks everything
+      Phase 2: Fix HIGH-INFRA (mock infrastructure, make hung tests runnable) — unblocks behavior verification
+      Phase 3: Fix HIGH-LOGIC (logic tests, red → green) — behavior alignment
+      Phase 4: Fix MEDIUM (widget tests, red → green) — UI alignment
+      Complete each phase before moving to the next.
     steps:
       - id: investigate
         role: investigator
@@ -282,10 +295,13 @@ workflows:
           - If round > 1: review previous round's git diff first
           - If previous round had 0 test progress (no red→green or skip→green): warn "no progress" and consider changing approach
 
-          Run tests in {{test_path}}/$ARGUMENTS/. Categorize all non-passing tests by severity:
-          CRITICAL: compile errors, import failures — fix first
-          HIGH: logic test failures (state/notifier/service) — fix second
-          LOW: widget test failures (rendering/navigation) — fix after logic is done
+          Run tests in {{test_path}}/$ARGUMENTS/ --timeout 30s. Categorize all non-passing tests by severity:
+          CRITICAL: compile errors, import failures — blocks everything, fix first
+          HIGH-INFRA: mock incomplete causing test hang (timed out) — blocks behavior verification, fix mock infrastructure
+          HIGH-LOGIC: logic test failures (state/notifier/service) — behavior inconsistency, fix after infra
+          MEDIUM: widget test failures (rendering/navigation) — fix after logic
+
+          IMPORTANT: hung ≠ failed. A test that times out (hung) = mock infrastructure problem, NOT a v2 behavior issue. Classify separately.
 
           Pick highest severity batch. Trace: what does v1 do vs what does v2 do? Find the breakpoints.
           Report findings and the plan for this round.
@@ -348,7 +364,7 @@ workflows:
         description: "Independent test verification + regression check."
         prompt: |
           Run tests independently (do not trust surgeon's reported results):
-          1. `flutter test {{test_path}}/$ARGUMENTS/` (no timeout)
+          1. `flutter test {{test_path}}/$ARGUMENTS/ --timeout 30s` (per-test safety net; hung = mock infra issue)
           2. `flutter analyze` (compilation check)
           3. Check for regressions in core module tests if applicable
 

package/dist/templates/persistent-executor.dna.yaml

@@ -0,0 +1,144 @@
+version: "0.1.0"
+id: template_persistent_executor
+name: Persistent Executor (PRD-Driven)
+type: project
+namespace: pe
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  prd_driven:
+    description: Every task must trace back to explicit acceptance criteria
+    codons:
+      - type: threshold
+        condition: "acceptance_criteria_defined == true"
+        action: block
+      - type: attract
+        target: reference_acceptance_criteria
+      - type: repel
+        target: work_without_spec
+
+  verify_before_done:
+    description: Never claim completion without passing acceptance criteria
+    codons:
+      - type: threshold
+        condition: "all_criteria_verified == true"
+        action: block
+      - type: attract
+        target: run_verification_before_reporting
+      - type: repel
+        target: claim_done_without_evidence
+
+  no_partial_completion:
+    description: Either fully complete a story or explicitly report what remains
+    codons:
+      - type: threshold
+        condition: "story_fully_complete == true"
+        action: escalate
+      - type: repel
+        target: silent_partial_delivery
+
+  small_increments:
+    description: One story per commit, verifiable increments
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: one_story_one_commit
+      - type: repel
+        target: batch_multiple_stories
+      - type: attract
+        target: each_commit_passes_tests
+
+contexts: {}
+
+roles:
+  executor:
+    description: Implements stories from the PRD. Can modify code.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**", "test/**"]
+    instructions:
+      - Pick the highest priority incomplete story
+      - Read acceptance criteria before starting
+      - Implement in small verifiable steps
+      - Run tests after each change
+      - Commit after each story completion
+      - "Commit message: feat($STORY): what was implemented"
+      - Do not move to next story until current one is verified
+
+  verifier:
+    description: Independently verifies story completion. Read-only + can run tests.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read the acceptance criteria for the completed story
+      - Run tests independently (do not trust executor's output)
+      - Check each criterion individually
+      - "Mark each: VERIFIED / PARTIAL / MISSING"
+      - "Verdict: PASS (all verified) or FAIL (list what's missing)"
+      - On FAIL the executor must fix before proceeding
+
+workflows:
+  persistent-execution:
+    name: Persistent Execution
+    description: "PRD-driven story execution: pick, implement, verify, repeat until all done"
+    steps:
+      - id: pick_story
+        role: executor
+        description: "Select next story from PRD by priority."
+        prompt: |
+          Read the PRD or task list.
+          Select the highest priority incomplete story.
+          Confirm: acceptance criteria are clear and testable.
+          If criteria are vague, ask for clarification before starting.
+          Output: story ID, title, acceptance criteria.
+
+      - id: implement
+        role: executor
+        depends_on: [pick_story]
+        description: "Implement the selected story."
+        prompt: |
+          Implement the story. Rules:
+          - Read acceptance criteria carefully
+          - Small steps: change → test → verify
+          - Maximum scope: what the story requires, nothing more
+          - Run tests after each meaningful change
+          - If stuck for 3 attempts on the same issue: STOP and report blocker
+          - Commit when story implementation is complete
+          - Do not start the next story
+
+      - id: verify
+        role: verifier
+        depends_on: [implement]
+        description: "Independent verification of story completion."
+        prompt: |
+          Verify the completed story independently:
+          1. Read acceptance criteria
+          2. Run all relevant tests (do not trust executor's results)
+          3. Check each criterion: VERIFIED / PARTIAL / MISSING
+          4. Run full test suite for regression check
+
+          PASS: All criteria verified → story complete, ready for next
+          FAIL: List what's missing → executor must fix
+
+      - id: report
+        role: verifier
+        depends_on: [verify]
+        description: "Report progress and determine next action."
+        prompt: |
+          Summary:
+          - Story: [ID] [title]
+          - Criteria: N/M verified
+          - Tests: X passing, Y failing
+          - Verdict: COMPLETE or NEEDS_FIX
+
+          If COMPLETE: "Story done. Pick next story to continue."
+          If NEEDS_FIX: "Story incomplete. Issues: [list]. Fix before proceeding."