intentdna 1.4.3 → 1.4.5

package/dist/runtime/workflow-runner.js

@@ -22,6 +22,13 @@ const SENTINEL_COMMENT = "# intentdna:managed -- do not edit manually";
 function sanitizeForBash(id) {
     return id.replace(/[^a-zA-Z0-9_]/g, "_");
 }
+/**
+ * Sanitize a step ID for safe use in shell paths and git branch names.
+ * Allows alphanumeric, hyphen, underscore, and dot only.
+ */
+function sanitizeForShell(id) {
+    return id.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
 /**
  * Get the agent name for a role, using toKebabCase and the configured prefix.
  */
@@ -203,7 +210,8 @@ function generateGroupExecution(group, stepMap, options, plan) {
     const lines = [];
     const isParallel = group.step_ids.length > 1;
     if (isParallel) {
-        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (parallel)`);
+        const isoLabel = group.isolation === "worktree" ? "parallel, worktree" : "parallel";
+        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (${isoLabel})`);
     }
     else {
         lines.push(`  # Group ${group.group_index}: ${group.step_ids[0]} (sequential)`);
@@ -213,8 +221,62 @@ function generateGroupExecution(group, stepMap, options, plan) {
         const varId = sanitizeForBash(id);
         lines.push(`  STEP_${varId}_STATUS=0`);
     }
-    if (isParallel) {
-        // Background jobs
+    if (isParallel && group.isolation === "worktree") {
+        // Worktree-isolated parallel execution
+        lines.push("");
+        lines.push('  MAIN_BRANCH=$(git rev-parse --abbrev-ref HEAD)');
+        // Create worktrees
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree add ".dna/worktrees/${safeId}" -b "dna-wt-${safeId}" HEAD 2>/dev/null`);
+        }
+        // Background jobs in worktree dirs
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            const agent = agentName(step.role, options.agentPrefix);
+            const prompt = escapeShellSingleQuote(step.prompt ?? step.description);
+            lines.push("");
+            lines.push(`  (cd ".dna/worktrees/${safeId}" && run_agent "${agent}" '${prompt}' "${safeId}") &`);
+            lines.push(`  PID_${varId}=$!`);
+        }
+        lines.push("");
+        // Wait for all
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            if (step.optional) {
+                lines.push(`  wait $PID_${varId} || {`);
+                lines.push(`    STEP_${varId}_STATUS=1`);
+                lines.push(`    echo "[$(date '+%H:%M:%S')] Optional step '${step.id}' failed, continuing..."`);
+                lines.push("  }");
+            }
+            else {
+                lines.push(`  wait $PID_${varId} || STEP_${varId}_STATUS=1`);
+            }
+        }
+        // Merge worktrees back (escalate on conflict)
+        lines.push("");
+        lines.push("  # Merge worktrees back to main branch");
+        for (const id of group.step_ids) {
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            lines.push(`  if [ "$STEP_${varId}_STATUS" -eq 0 ]; then`);
+            lines.push(`    merge_worktree "dna-wt-${safeId}" "${safeId}"`);
+            lines.push("  fi");
+        }
+        // Cleanup worktrees
+        lines.push("");
+        lines.push("  # Cleanup worktrees");
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree remove ".dna/worktrees/${safeId}" 2>/dev/null || true`);
+            lines.push(`  git branch -D "dna-wt-${safeId}" 2>/dev/null || true`);
+        }
+    }
+    else if (isParallel) {
+        // Standard parallel execution (no isolation)
         for (const id of group.step_ids) {
             const step = stepMap.get(id);
             const varId = sanitizeForBash(id);
@@ -248,6 +310,32 @@ function generateGroupExecution(group, stepMap, options, plan) {
     }
     return lines;
 }
+/**
+ * Check if any parallel group in the plan uses worktree isolation.
+ */
+function needsWorktreeSupport(plan) {
+    return plan.parallel_groups.some(g => g.isolation === "worktree" && g.step_ids.length > 1);
+}
+/**
+ * Generate the merge_worktree bash helper function.
+ * Only included in scripts that have worktree-isolated parallel groups.
+ */
+function generateMergeWorktreeFn() {
+    return [
+        "# Merge a worktree branch back to main (escalate on conflict)",
+        "merge_worktree() {",
+        '  local branch="$1" name="$2"',
+        '  if ! git merge --no-commit --no-ff "$branch" 2>/dev/null; then',
+        "    git merge --abort",
+        '    echo "[Intent DNA] CONFLICT: $name conflicts with current branch. Manual resolution required."',
+        '    echo "[Intent DNA] Branch preserved: $branch"',
+        "    return 1",
+        "  fi",
+        '  git commit -m "merge: $name" --no-edit 2>/dev/null || true',
+        "}",
+        "",
+    ];
+}
 /**
  * Generate transition check code after all groups execute.
  */
@@ -316,6 +404,10 @@ export function compileWorkflowToShell(plan, options) {
     // run_agent function
     lines.push(...generateRunAgentFn(opts));
     lines.push("");
+    // merge_worktree function (only if needed)
+    if (needsWorktreeSupport(plan)) {
+        lines.push(...generateMergeWorktreeFn());
+    }
     // Main execution
     if (plan.retry.max_retries > 0) {
         // With retry loop

package/dist/schema/types.d.ts

@@ -139,6 +139,7 @@ export interface WorkflowStepDef {
     completion?: CompletionCheck[];
     checkpoints?: StepCheckpoint[];
     handoff?: StepHandoff;
+    isolation?: "none" | "worktree" | "auto";
 }
 /** Top-level workflow definition */
 export interface WorkflowDef {
@@ -150,7 +151,19 @@ export interface WorkflowDef {
     max_rounds?: number;
     produces?: HandoffArtifact[];
     consumes?: HandoffArtifact[];
+    default_isolation?: "none" | "worktree" | "auto";
+    merge_strategy?: "escalate";
+}
+/** Parallel block syntax sugar — expanded by compiler into steps with depends_on */
+export interface ParallelBlockDef {
+    parallel: {
+        isolation?: "none" | "worktree" | "auto";
+        merge_strategy?: "escalate";
+        steps: WorkflowStepDef[];
+    };
 }
+/** Raw workflow step entry: either a regular step or a parallel block (syntax sugar) */
+export type RawWorkflowStepEntry = WorkflowStepDef | ParallelBlockDef;
 export interface EpigeneticEffect {
     gene?: string;
     action?: ModifierAction;
@@ -320,6 +333,9 @@ export interface WorkflowStep {
 export interface ParallelGroup {
     group_index: number;
     step_ids: string[];
+    isolation: "none" | "worktree";
+    merge_strategy: "escalate";
+    scope_overlap: boolean;
 }
 /** Compiled transition rule */
 export interface TransitionRule {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
   ],
   "files": [
     "dist",
+    "spec",
     ".claude-plugin",
     "README.md",
     "LICENSE"

package/spec/parallel-isolation.md

@@ -0,0 +1,205 @@
+# Spec: DNA 并行执行 + Worktree 隔离
+
+## Metadata
+- Interview: 8 rounds, final ambiguity 20%
+- Type: brownfield
+- Date: 2026-04-14
+- Phase: 6 (基础体验)
+
+## Goal
+
+DNA 模板可声明并行执行策略和文件隔离策略，编译到 workflow-runner 生成的 bash 脚本中实际执行。支持强制 worktree、编译时自动判断（scope overlap）、和无隔离三种模式。
+
+## 核心设计决策
+
+| 决策 | 结论 | 理由 |
+|------|------|------|
+| 执行方式 | 自管 worktree (bash) | 不依赖 CC 平台特性，完全自控 |
+| isolation 语义 | 纯文件隔离 | context 隔离已由独立进程解决，context 保护已由 Handoff 解决 |
+| Schema 声明 | step 属性 + parallel block 双支持 | 灵活性 + 简洁性兼顾 |
+| auto 模式 | 编译时 scope overlap 检测 | DNA 独有能力——Role scope 编译时已知 |
+| merge 策略 | escalate only (MVP) | 冲突报告给用户，不自动解决 |
+| 模型差异 | 暂不考虑 | 后续扩展 |
+
+## Schema 设计
+
+### isolation 取值
+
+| 值 | 含义 |
+|---|---|
+| `none` | 共享目录（默认，当前行为） |
+| `worktree` | 强制每个并行 step 开 worktree |
+| `auto` | 编译时分析 scope overlap，自动决定 none 或 worktree |
+
+### 两种声明方式
+
+**方式 A: step 属性 + workflow 默认值（隐式并行）**
+
+```yaml
+workflows:
+  rescue:
+    default_isolation: auto       # workflow 级默认
+    merge_strategy: escalate
+    steps:
+      - id: investigate
+        role: investigator
+      - id: fix-auth
+        role: surgeon
+        isolation: worktree       # step 级覆盖
+        depends_on: [investigate]
+      - id: fix-api
+        role: surgeon
+                                   # 继承 workflow 默认 auto
+        depends_on: [investigate]
+      - id: report
+        depends_on: [fix-auth, fix-api]
+```
+
+编译器通过 `depends_on` + Kahn 拓扑排序自动检测并行组（已实现）。
+
+**方式 B: 显式 parallel block（语法糖）**
+
+```yaml
+workflows:
+  rescue:
+    steps:
+      - id: investigate
+        role: investigator
+
+      - parallel:
+          isolation: worktree
+          merge_strategy: escalate
+          steps:
+            - id: fix-auth
+              role: surgeon
+            - id: fix-api
+              role: surgeon
+
+      - id: report
+        depends_on: [fix-auth, fix-api]
+```
+
+parallel block 编译时展开为带 `depends_on` 的独立 step + 统一 isolation 设置。
+
+### isolation 粒度
+
+| 粒度 | 声明位置 | 含义 |
+|------|----------|------|
+| step 级 | step.isolation | 该 step 的并行执行隔离 |
+| workflow 级 | workflow.default_isolation | 所有并行组的默认隔离策略 |
+
+step 级 > workflow 级（覆盖优先级）。
+
+## auto 模式编译逻辑
+
+```
+对每个 ParallelGroup:
+  1. 收集组内所有 step 对应 role 的 write scope
+  2. 做 glob 交叉检测（minimatch 或等价）
+  3. 无重叠 → 编译为 none
+  4. 有重叠 → 编译为 worktree
+  5. 无法判断（"**/*"）→ 保守编译为 worktree
+```
+
+## workflow-runner 生成
+
+### isolation: none（当前行为不变）
+
+```bash
+# Group 1: fix-auth, fix-api (parallel, no isolation)
+run_agent "dna-surgeon" 'prompt' "fix-auth" &
+PID_fix_auth=$!
+run_agent "dna-surgeon" 'prompt' "fix-api" &
+PID_fix_api=$!
+wait $PID_fix_auth || STEP_fix_auth_STATUS=1
+wait $PID_fix_api || STEP_fix_api_STATUS=1
+```
+
+### isolation: worktree
+
+```bash
+# Group 1: fix-auth, fix-api (parallel, worktree isolation)
+MAIN_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+git worktree add .dna/worktrees/fix-auth -b dna-wt-fix-auth HEAD 2>/dev/null
+git worktree add .dna/worktrees/fix-api -b dna-wt-fix-api HEAD 2>/dev/null
+
+(cd .dna/worktrees/fix-auth && run_agent "dna-surgeon" 'prompt' "fix-auth") &
+PID_fix_auth=$!
+(cd .dna/worktrees/fix-api && run_agent "dna-surgeon" 'prompt' "fix-api") &
+PID_fix_api=$!
+
+wait $PID_fix_auth || STEP_fix_auth_STATUS=1
+wait $PID_fix_api || STEP_fix_api_STATUS=1
+
+# Merge (escalate on conflict)
+merge_worktree() {
+  local branch=$1 name=$2
+  if ! git merge --no-commit --no-ff "$branch" 2>/dev/null; then
+    git merge --abort
+    echo "[Intent DNA] CONFLICT: $name conflicts with $MAIN_BRANCH. Manual resolution required."
+    echo "[Intent DNA] Branch preserved: $branch"
+    return 1
+  fi
+  git commit -m "merge: $name" --no-edit
+}
+
+merge_worktree "dna-wt-fix-auth" "fix-auth"
+merge_worktree "dna-wt-fix-api" "fix-api"
+
+# Cleanup (only if merge succeeded)
+git worktree remove .dna/worktrees/fix-auth 2>/dev/null
+git worktree remove .dna/worktrees/fix-api 2>/dev/null
+```
+
+## Constraint IR 扩展
+
+```typescript
+// ParallelGroup 扩展
+interface ParallelGroup {
+  group_index: number;
+  step_ids: string[];
+  isolation: 'none' | 'worktree';       // auto 已被编译期解析
+  merge_strategy: 'escalate';            // MVP: escalate only
+  scope_overlap: boolean;                // 编译期分析结果
+}
+
+// WorkflowIR 扩展
+interface WorkflowIR {
+  // ... 现有字段
+  parallel_groups?: ParallelGroupIR[];   // 新增
+}
+```
+
+## 与 DNA 现有概念的关系
+
+| DNA 概念 | 在并行隔离中的角色 |
+|---|---|
+| **Role scope** | auto 模式的编译时 overlap 分析输入 |
+| **Handoff** | 并行 step 的 artifact 传递（已实现） |
+| **Threshold codon** | 可声明 `parallel_without_isolation == false` 硬约束 |
+| **Attract codon** | `attract: worktree_per_task` 软提示（保留兼容） |
+| **Hooks enforce** | worktree 内 scope enforce 仍生效 |
+
+## 不做
+
+- 自动冲突解决（MVP 只 escalate）
+- LLM 模型差异适配（暂不考虑）
+- context budget 管理（已由独立进程 + Handoff 解决）
+- container 级隔离（过度设计）
+
+## Acceptance Criteria
+
+- [ ] Schema: WorkflowStepDef 支持 `isolation` 字段
+- [ ] Schema: WorkflowDef 支持 `default_isolation` + `merge_strategy`
+- [ ] Schema: `parallel:` block 语法糖可解析
+- [ ] Compiler: auto 模式 scope overlap 检测正确
+- [ ] Compiler: parallel block 展开为 step + depends_on
+- [ ] workflow-runner: isolation=none 行为不变（向后兼容）
+- [ ] workflow-runner: isolation=worktree 生成 git worktree 生命周期脚本
+- [ ] workflow-runner: merge 冲突时 escalate（报告 + 保留分支）
+- [ ] E2E: 两个并行 step 写不同目录，auto → none，正确执行
+- [ ] E2E: 两个并行 step 写相同目录，auto → worktree，隔离执行 + merge
+- [ ] Dogfood: flutter-rewrite rescue workflow 可配置 isolation
+- [ ] IR: ParallelGroup 包含 isolation + scope_overlap 信息
+- [ ] 测试覆盖所有新增代码