deepflow 0.1.101 → 0.1.102

package/bin/plan-consolidator.js

@@ -208,7 +208,8 @@ function consolidate(specEntries, fileConflicts) {
 
 /**
  * Render consolidated tasks as PLAN.md-compatible markdown.
- * Groups tasks under ### {specName} headings.
+ * Groups tasks under ### doing-{specName} headings with a details reference line.
+ * One line per task — no sub-bullets. Files omitted (live in mini-plans only).
  * Compatible with wave-runner's parsePlan regex (see wave-runner.js parsePlan).
  */
 function formatConsolidated(consolidated) {
@@ -221,11 +222,15 @@ function formatConsolidated(consolidated) {
 
   for (const task of consolidated) {
     if (task.specName !== lastSpec) {
-      lines.push(`### ${task.specName}\n`);
+      // Close previous spec with trailing blank line (already added after last task)
+      const doingName = `doing-${task.specName}`;
+      const planPath = `.deepflow/plans/${doingName}.md`;
+      lines.push(`### ${doingName}\n`);
+      lines.push(`> Details: [\`${planPath}\`](${planPath})\n`);
       lastSpec = task.specName;
     }
 
-    // Task header line
+    // Task header line — one line, no sub-bullets
     const tagPart = task.tags ? ` ${task.tags}` : '';
     // Append conflict annotations to description if any
     const conflictPart = task.conflictAnnotations.length > 0
@@ -233,23 +238,18 @@ function formatConsolidated(consolidated) {
       : '';
     const descPart = (task.description + conflictPart).trim();
     const headerDesc = descPart ? `: ${descPart}` : '';
-    lines.push(`- [ ] **${task.globalId}**${tagPart}${headerDesc}`);
 
-    // Files annotation
-    if (task.files.length > 0) {
-      lines.push(`  - Files: ${task.files.join(', ')}`);
-    }
-
-    // Blocked by annotation
-    if (task.blockedBy.length > 0) {
-      lines.push(`  - Blocked by: ${task.blockedBy.join(', ')}`);
-    } else {
-      lines.push('  - Blocked by: none');
-    }
+    // Blocked by suffix — omit entirely when empty
+    const blockedSuffix = task.blockedBy.length > 0
+      ? ` | Blocked by: ${task.blockedBy.join(', ')}`
+      : '';
 
-    lines.push('');
+    lines.push(`- [ ] **${task.globalId}**${tagPart}${headerDesc}${blockedSuffix}`);
   }
 
+  // Trailing newline after last task
+  lines.push('');
+
   return lines.join('\n');
 }
 

package/bin/wave-runner.js

@@ -85,14 +85,38 @@ function parsePlan(text) {
     // Match pending task header: - [ ] **T{N}**...
     const taskMatch = line.match(/^\s*-\s+\[\s+\]\s+\*\*T(\d+)\*\*(?:\s+\[[^\]]*\])?[:\s]*(.*)/);
     if (taskMatch) {
+      const rest = taskMatch[2].trim();
+
+      // Extract inline blocked-by (from " | Blocked by: T1, T2")
+      let inlineBlockedBy = [];
+      let descPart = rest;
+      const blockedInlineMatch = rest.match(/\s*\|\s*Blocked\s+by:\s+(.+)$/i);
+      if (blockedInlineMatch) {
+        descPart = rest.substring(0, rest.length - blockedInlineMatch[0].length).trim();
+        inlineBlockedBy = blockedInlineMatch[1]
+          .split(/[,\s]+/)
+          .map(s => s.trim())
+          .filter(s => /^T\d+$/.test(s));
+      }
+
+      // Extract inline model/effort (from " — model/effort")
+      let inlineModel = null;
+      let inlineEffort = null;
+      const modelInlineMatch = descPart.match(/\s*\u2014\s*(haiku|sonnet|opus)\/(low|medium|high)\s*$/i);
+      if (modelInlineMatch) {
+        descPart = descPart.substring(0, descPart.length - modelInlineMatch[0].length).trim();
+        inlineModel = modelInlineMatch[1].toLowerCase();
+        inlineEffort = modelInlineMatch[2].toLowerCase();
+      }
+
       current = {
         id: `T${taskMatch[1]}`,
         num: parseInt(taskMatch[1], 10),
-        description: taskMatch[2].trim(),
-        blockedBy: [],
-        model: null,
+        description: descPart,
+        blockedBy: inlineBlockedBy,
+        model: inlineModel,
         files: null,
-        effort: null,
+        effort: inlineEffort,
         spec: currentSpec,
       };
       tasks.push(current);
@@ -107,35 +131,43 @@ function parsePlan(text) {
     }
 
     if (current) {
-      // Match "Blocked by:" annotation
+      // Match "Blocked by:" annotation — only apply if inline parsing found no deps
       const blockedMatch = line.match(/^\s+-\s+Blocked\s+by:\s+(.+)/i);
       if (blockedMatch) {
-        const deps = blockedMatch[1]
-          .split(/[,\s]+/)
-          .map(s => s.trim())
-          .filter(s => /^T\d+$/.test(s));
-        current.blockedBy.push(...deps);
+        if (current.blockedBy.length === 0) {
+          const deps = blockedMatch[1]
+            .split(/[,\s]+/)
+            .map(s => s.trim())
+            .filter(s => /^T\d+$/.test(s));
+          current.blockedBy.push(...deps);
+        }
         continue;
       }
 
-      // Match "Model:" annotation
+      // Match "Model:" annotation — only apply if inline parsing found no model
       const modelMatch = line.match(/^\s+-\s+Model:\s+(.+)/i);
       if (modelMatch) {
-        current.model = modelMatch[1].trim();
+        if (current.model === null) {
+          current.model = modelMatch[1].trim();
+        }
         continue;
       }
 
-      // Match "Files:" annotation
+      // Match "Files:" annotation — always apply (no inline equivalent)
       const filesMatch = line.match(/^\s+-\s+Files:\s+(.+)/i);
       if (filesMatch) {
-        current.files = filesMatch[1].trim();
+        if (current.files === null) {
+          current.files = filesMatch[1].trim();
+        }
         continue;
       }
 
-      // Match "Effort:" annotation
+      // Match "Effort:" annotation — only apply if inline parsing found no effort
       const effortMatch = line.match(/^\s+-\s+Effort:\s+(.+)/i);
       if (effortMatch) {
-        current.effort = effortMatch[1].trim();
+        if (current.effort === null) {
+          current.effort = effortMatch[1].trim();
+        }
         continue;
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepflow",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "description": "Doing reveals what thinking can't predict — spec-driven iterative development for Claude Code",
   "keywords": [
     "claude",

package/src/commands/df/execute.md

@@ -83,7 +83,7 @@ Load PLAN.md (required), specs/doing-*.md, .deepflow/config.yaml. Missing → "N
 ```
 PLAN_TASK_FILES=!`ls .deepflow/plans/doing-*.md 2>/dev/null | tr '\n' ' ' || echo 'NOT_FOUND'`
 ```
-When `PLAN_TASK_FILES` is not `NOT_FOUND`, each file `.deepflow/plans/doing-{task_id}.md` contains the full task detail block (Steps, ACs, Impact) for that task. Load a task's detail file on demand when building its agent prompt (§6), falling back to the PLAN.md inline block if the file is absent.
+When `PLAN_TASK_FILES` is not `NOT_FOUND`, each file `.deepflow/plans/doing-{specName}.md` contains the full task detail (Files, Steps, ACs, Impact) for all tasks in that spec. Load a task's detail on demand when building its agent prompt (§6). PLAN.md is a slim index — Files and Impact live only in mini-plans.
 
 ### 2.5. REGISTER NATIVE TASKS
 
@@ -134,7 +134,7 @@ Context ≥50% → checkpoint and exit. Before spawning: `TaskUpdate(status: "in
 
 **Intra-wave isolation:** For standard (non-spike, non-optimize) parallel tasks, use `isolation: "worktree"` so each agent works in its own isolated branch. Spikes use sub-worktrees managed by §5.7. Optimize tasks run one at a time in the shared worktree.
 
-**File conflicts (1 file = 1 writer):** Check `Files:` lists. Overlap → spawn lowest-numbered only; rest stay pending. Log: `"⏳ T{N} deferred — file conflict with T{M} on {filename}"`
+**File conflicts (1 file = 1 writer):** Check `Files:` from wave-runner JSON output or from mini-plan detail files (`.deepflow/plans/doing-{specName}.md`). Overlap → spawn lowest-numbered only; rest stay pending. Log: `"⏳ T{N} deferred — file conflict with T{M} on {filename}"`
 
 **≥2 [SPIKE] tasks same problem →** Parallel Spike Probes (§5.7). **[OPTIMIZE] tasks →** Optimize Cycle (§5.9), one at a time.
 

package/src/commands/df/plan.md

@@ -161,28 +161,23 @@ You are a spec planner. Your job is to independently analyze a spec and produce
 
 ## OUTPUT FORMAT — MANDATORY (no deviations)
 Return ONLY a markdown task list. Use local T-numbering starting at T1.
-Each task MUST follow this exact format:
+Each task is ONE LINE. No sub-bullets in the output.
 
 ### {spec-name}
 
 - [ ] **T{N}**: {Task description}
-  - Files: {comma-separated file paths}
-  - Blocked by: none | T{N}[, T{M}...]
-
-Optional fields (add when applicable):
-  - Model: haiku | sonnet | opus
-  - Effort: low | medium | high
-  - Impact: {blast radius details, L3 only}
-  - Optimize: {metric block, for metric ACs only}
+- [ ] **T{N}** [SPIKE]: {Task description} | Blocked by: T{M}
+- [ ] **T{N}**: {Task description} | Blocked by: T{M}, T{K}
 
 Rules:
-- "Blocked by: none" is required (not "N/A", not empty)
+- No blockers → omit `| Blocked by:` entirely (do NOT write "none")
+- Has blockers → append ` | Blocked by: T{N}[, T{M}...]` to end of line
 - T-numbers are local to this spec (T1, T2, T3...)
 - One task = one atomic commit
 - Spike tasks use: **T{N}** [SPIKE]: {description}
 - L0-L1 specs: ONLY spike tasks allowed
 - L2+ specs: spikes + implementation tasks allowed
-- L3 specs: include Impact: blocks from impact analysis
+- Files, Impact, Model, Effort live ONLY in the mini-plan file (NOT in this output)
 ```
 
 #### 4.7.3. Collect & Persist Mini-Plans
@@ -246,11 +241,13 @@ Shell-inject the consolidator output:
 
 `` !`node "${HOME}/.claude/bin/plan-consolidator.js" --plans-dir .deepflow/plans/ 2>/dev/null || node .claude/bin/plan-consolidator.js --plans-dir .deepflow/plans/ 2>/dev/null || true` ``
 
-This produces the `## Tasks` section with:
+This produces a slim `## Tasks` section with:
 - Globally sequential T-ids (no gaps, no duplicates) — AC-4
-- Remapped `Blocked by` references (local → global)
+- Remapped `Blocked by` references (local → global), inline on task line
 - `[file-conflict: {filename}]` annotations on cross-spec file overlaps
+- Mini-plan reference links (`> Details: ...`) per spec section
 - Mini-plan files left byte-identical (read-only) — AC-5
+- **No Files, Impact, Model, or Effort** — those live only in mini-plans
 
 If the consolidator output is empty or contains `(no mini-plan files found` → abort, report error.
 
@@ -319,14 +316,18 @@ Defaults: sonnet / medium.
 
 ## Tasks
 
-{Insert the consolidated tasks from plan-consolidator verbatim, adding ONLY `Model:` and `Effort:` lines to each task. Do NOT alter T-ids, descriptions, Files, Blocked by, or conflict annotations.}
+{Insert the consolidated tasks from plan-consolidator verbatim, adding ` — model/effort` to each task line per the routing matrix. Do NOT alter T-ids, descriptions, Blocked by, or conflict annotations.}
+
+Example transformation:
+  Input:  `- [ ] **T3**: Create pkg/engine/go.mod | Blocked by: T8`
+  Output: `- [ ] **T3**: Create pkg/engine/go.mod — haiku/low | Blocked by: T8`
 
 Rules:
 - Do NOT renumber T-ids — they are already globally sequential from plan-consolidator
-- Do NOT modify Blocked by lines or conflict annotations — they are mechanical outputs
-- ONLY add Model: and Effort: lines per the routing matrix
-- Preserve all existing fields (Impact:, Optimize:, tags, etc.)
+- Do NOT modify Blocked by or conflict annotations — they are mechanical outputs
+- Insert ` — {model}/{effort}` BEFORE ` | Blocked by:` (or at end if no blocker)
 - Spike tasks keep their [SPIKE] or [OPTIMIZE] markers
+- One line per task — no sub-bullets
 ```
 
 **Post-consolidation:**
@@ -423,7 +424,16 @@ Prune stale `done-*` sections and orphaned headers. Recalculate Summary. Empty
 
 **Fan-out path:** Run ONLY after §5B consolidation is complete (AC-13). Operate on successfully planned specs only — specs whose sub-agents failed (§4.7.3) are NOT renamed and NOT appended to PLAN.md.
 
-Append tasks grouped by `### doing-{spec-name}`. Rename `specs/feature.md` → `specs/doing-feature.md` for each successfully planned spec only.
+Write PLAN.md as a **slim index** with progressive disclosure:
+- Summary table (counts)
+- Spec Gaps (from Opus output)
+- Cross-Spec Resolution narrative (from Opus output, if >1 spec)
+- Tasks grouped by `### doing-{spec-name}` with `> Details:` reference to mini-plan
+- One line per task: `- [ ] **T{N}**: desc — model/effort [| Blocked by: ...]`
+
+Files, Impact, Steps live ONLY in mini-plans (`.deepflow/plans/doing-{name}.md`).
+
+Rename `specs/feature.md` → `specs/doing-feature.md` for each successfully planned spec only.
 
 Report:
 ```