create-claude-workspace 1.1.151 → 2.0.0

package/dist/scheduler/tasks/queue.spec.js

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest';
+import { buildGraph, getParallelBatches, isPhaseComplete, getNextPhase, isProjectComplete, getBlockedTasks } from './queue.mjs';
+import { parseTodoMd } from './parser.mjs';
+// ─── Fixtures ───
+const MULTI_PHASE_TODO = `# TODO.md
+
+## Phase 0: Foundation
+
+- [x] **Init workspace** — scaffolding
+  - Type: fullstack
+  - Complexity: S
+  - Depends on: nothing
+
+- [ ] **Configure ESLint** — code quality
+  - Type: fullstack
+  - Complexity: S
+  - Depends on: nothing
+
+## Phase 1: Auth
+
+- [ ] **Auth types** — interfaces
+  - Type: backend
+  - Complexity: S
+  - Depends on: Phase 0
+
+- [ ] **Login API** — endpoint
+  - Type: backend
+  - Complexity: M
+  - Depends on: Auth types
+
+- [ ] **Login form** — UI
+  - Type: frontend
+  - Complexity: S
+  - Depends on: Auth types
+
+## Phase 2: Dashboard
+
+- [ ] **Dashboard layout** — grid
+  - Type: frontend
+  - Complexity: L
+  - Depends on: Phase 1
+`;
+const CYCLIC_TODO = `## Phase 0: Cycle
+
+- [ ] **Task A** — first
+  - Type: backend
+  - Complexity: S
+  - Depends on: Task C
+
+- [ ] **Task B** — second
+  - Type: backend
+  - Complexity: S
+  - Depends on: Task A
+
+- [ ] **Task C** — third
+  - Type: backend
+  - Complexity: S
+  - Depends on: Task B
+`;
+const KIT_UPGRADE_TODO = `## Phase 1: Feature
+
+- [ ] **Upgrade sharp** — major version
+  - Type: backend
+  - Complexity: S
+  - Kit-Upgrade: v2.0
+
+- [ ] **Feature A** — new feature
+  - Type: backend
+  - Complexity: M
+  - Depends on: nothing
+`;
+// ─── buildGraph ───
+describe('buildGraph', () => {
+    it('builds graph from parsed tasks', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        const graph = buildGraph(tasks);
+        expect(graph.tasks.size).toBe(6);
+    });
+    it('returns runnable tasks (deps satisfied)', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        const graph = buildGraph(tasks);
+        const runnable = graph.runnable();
+        // "Init workspace" is done, "Configure ESLint" has no deps → runnable
+        expect(runnable.map(t => t.title)).toContain('Configure ESLint');
+        // "Auth types" depends on Phase 0 (Init workspace is done, ESLint is not) → blocked
+        expect(runnable.map(t => t.title)).not.toContain('Auth types');
+    });
+    it('detects no cycle in valid graph', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        const graph = buildGraph(tasks);
+        expect(graph.findCycle()).toBeNull();
+    });
+});
+describe('cycle detection', () => {
+    it('detects cycle in dependency graph', () => {
+        const tasks = parseTodoMd(CYCLIC_TODO);
+        const graph = buildGraph(tasks);
+        const cycle = graph.findCycle();
+        expect(cycle).not.toBeNull();
+        expect(cycle.length).toBeGreaterThan(1);
+    });
+});
+describe('kit-upgrade priority', () => {
+    it('sorts kit-upgrade tasks before regular tasks', () => {
+        const tasks = parseTodoMd(KIT_UPGRADE_TODO);
+        const graph = buildGraph(tasks);
+        const runnable = graph.runnable();
+        expect(runnable.length).toBe(2);
+        expect(runnable[0].kitUpgrade).toBe(true);
+    });
+});
+describe('complexity sorting', () => {
+    it('sorts S before M before L within same phase', () => {
+        const todo = `## Phase 0: X
+- [ ] **Large task** — big
+  - Type: backend
+  - Complexity: L
+  - Depends on: nothing
+- [ ] **Small task** — tiny
+  - Type: backend
+  - Complexity: S
+  - Depends on: nothing
+- [ ] **Medium task** — mid
+  - Type: backend
+  - Complexity: M
+  - Depends on: nothing
+`;
+        const tasks = parseTodoMd(todo);
+        const graph = buildGraph(tasks);
+        const runnable = graph.runnable();
+        expect(runnable[0].complexity).toBe('S');
+        expect(runnable[1].complexity).toBe('M');
+        expect(runnable[2].complexity).toBe('L');
+    });
+});
+// ─── getParallelBatches ───
+describe('getParallelBatches', () => {
+    it('returns empty for empty input', () => {
+        expect(getParallelBatches([])).toEqual([]);
+    });
+    it('returns single batch for single task', () => {
+        const tasks = parseTodoMd(`## Phase 0: X\n- [ ] **Solo** — one\n  - Type: backend\n  - Complexity: S\n`);
+        const graph = buildGraph(tasks);
+        const batches = getParallelBatches(graph.runnable());
+        expect(batches).toHaveLength(1);
+        expect(batches[0]).toHaveLength(1);
+    });
+    it('batches independent tasks from same phase', () => {
+        const todo = `## Phase 0: Setup
+- [ ] **Task A** — first
+  - Type: backend
+  - Complexity: S
+  - Depends on: nothing
+- [ ] **Task B** — second
+  - Type: frontend
+  - Complexity: S
+  - Depends on: nothing
+`;
+        const tasks = parseTodoMd(todo);
+        const graph = buildGraph(tasks);
+        const batches = getParallelBatches(graph.runnable());
+        expect(batches).toHaveLength(1);
+        expect(batches[0]).toHaveLength(2);
+    });
+});
+// ─── Phase helpers ───
+describe('isPhaseComplete', () => {
+    it('returns true when all tasks in phase are done/skipped', () => {
+        const tasks = [
+            { id: 'p0-1', title: 'A', phase: 0, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'added' },
+            { id: 'p0-2', title: 'B', phase: 0, type: 'backend', complexity: 'S', status: 'skipped', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 2, changelog: 'none' },
+        ];
+        expect(isPhaseComplete(tasks, 0)).toBe(true);
+    });
+    it('returns false when a task is still todo', () => {
+        const tasks = [
+            { id: 'p0-1', title: 'A', phase: 0, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'added' },
+            { id: 'p0-2', title: 'B', phase: 0, type: 'backend', complexity: 'S', status: 'todo', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 2, changelog: 'added' },
+        ];
+        expect(isPhaseComplete(tasks, 0)).toBe(false);
+    });
+    it('returns false for nonexistent phase', () => {
+        expect(isPhaseComplete([], 99)).toBe(false);
+    });
+});
+describe('getNextPhase', () => {
+    it('returns lowest phase with todo tasks', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        expect(getNextPhase(tasks)).toBe(0); // ESLint is still todo
+    });
+    it('returns null when all tasks are done', () => {
+        const tasks = [
+            { id: 'p0-1', title: 'A', phase: 0, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'added' },
+        ];
+        expect(getNextPhase(tasks)).toBeNull();
+    });
+});
+describe('isProjectComplete', () => {
+    it('returns true when all tasks are done/skipped', () => {
+        const tasks = [
+            { id: 'p0-1', title: 'A', phase: 0, type: 'backend', complexity: 'S', status: 'done', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 1, changelog: 'added' },
+            { id: 'p1-1', title: 'B', phase: 1, type: 'backend', complexity: 'S', status: 'skipped', dependsOn: [], issueMarker: null, kitUpgrade: false, lineNumber: 2, changelog: 'none' },
+        ];
+        expect(isProjectComplete(tasks)).toBe(true);
+    });
+    it('returns false when tasks remain', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        expect(isProjectComplete(tasks)).toBe(false);
+    });
+    it('returns false for empty task list', () => {
+        expect(isProjectComplete([])).toBe(false);
+    });
+});
+describe('getBlockedTasks', () => {
+    it('identifies blocked tasks', () => {
+        const tasks = parseTodoMd(MULTI_PHASE_TODO);
+        const graph = buildGraph(tasks);
+        const blocked = getBlockedTasks(graph);
+        // Auth types, Login API, Login form, Dashboard are blocked
+        expect(blocked.length).toBeGreaterThan(0);
+        expect(blocked.some(t => t.title === 'Auth types')).toBe(true);
+    });
+});

package/dist/scheduler/types.mjs

@@ -0,0 +1,20 @@
+// ─── Multi-agent scheduler types ───
+export const SCHEDULER_DEFAULTS = {
+    projectDir: process.cwd(),
+    concurrency: 1,
+    maxIterations: 50,
+    maxTurns: 50,
+    skipPermissions: false,
+    resume: false,
+    resumeSession: null,
+    logFile: '.claude/scheduler/scheduler.log',
+    noPull: false,
+    noLock: false,
+    dryRun: false,
+    notifyCommand: null,
+    idlePollInterval: 5 * 60_000,
+    maxIdleTime: 0,
+    interactive: false,
+    delay: 5_000,
+    cooldown: 60_000,
+};

package/dist/{scripts/lib → scheduler/ui}/tui.mjs

@@ -22,6 +22,8 @@ const DIM = '\x1b[2m';
 const HIDE_CURSOR = '\x1b[?25l';
 const SHOW_CURSOR = '\x1b[?25h';
 const CLEAR_LINE = '\r\x1b[2K';
+const CLEAR_TO_END = '\x1b[J'; // clear from cursor to end of screen
+const CURSOR_UP = (n) => n > 0 ? `\x1b[${n}A` : '';
 // ─── Tool icons ───
 const ICONS = {
     Bash: '⚡', Read: '📖', Write: '✏️ ', Edit: '🔧', Glob: '🔍', Grep: '🔎',
@@ -39,7 +41,7 @@ export class TUI {
     onInput = null;
     onHotkey = null;
     state;
-    statusBarVisible = false;
+    statusBarLines = 0;
     statusTimer = null;
     stdinHandler = null;
     topAgent = null;
@@ -50,6 +52,7 @@ export class TUI {
             iteration: 0, maxIter: 0, loopStart: Date.now(), iterStart: 0,
             tools: 0, tokensIn: 0, tokensOut: 0, agents: [], taskName: '',
             tasksDone: 0, tasksTotal: 0, paused: false, inputBuf: '',
+            pendingInputs: [],
         };
         if (this.interactive) {
             // Hide cursor to prevent flickering
@@ -122,10 +125,10 @@ export class TUI {
     }
     destroy() {
         if (this.interactive) {
-            // Clear status bar
-            if (this.statusBarVisible) {
-                process.stdout.write(CLEAR_LINE);
-                this.statusBarVisible = false;
+            // Clear status area
+            if (this.statusBarLines > 0) {
+                process.stdout.write(CURSOR_UP(this.statusBarLines - 1) + '\r' + CLEAR_TO_END);
+                this.statusBarLines = 0;
             }
             // Show cursor
             process.stdout.write(SHOW_CURSOR);
@@ -151,6 +154,19 @@ export class TUI {
     setInputHandler(h) { this.onInput = h; }
     setHotkeyHandler(h) { this.onHotkey = h; }
     isPaused() { return this.state.paused; }
+    addPendingInput(text) {
+        this.state.pendingInputs.push(text);
+        this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.magenta}▲${RESET}  ${ANSI_COLORS.white}Queued:${RESET} ${trunc(text, 60)}`);
+        this.renderStatusBar();
+    }
+    consumePendingInput() {
+        const item = this.state.pendingInputs.shift();
+        if (item) {
+            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}▼${RESET}  ${ANSI_COLORS.white}Processing:${RESET} ${trunc(item, 60)}`);
+            this.renderStatusBar();
+        }
+        return item;
+    }
     /** Set the top-level agent name so all log lines show it from the start. */
     setTopAgent(name) {
         this.topAgent = name;
@@ -158,69 +174,92 @@ export class TUI {
             this.state.agents.push(name);
         }
     }
-    // ─── Status bar (overwrites current line, no \n) ───
-    buildStatusBar() {
+    // ─── Status area (multi-line: pending queue + input + stats) ───
+    buildStatusLines() {
         const s = this.state;
+        const lines = [];
+        // Line 1: Pending input queue (only if non-empty)
+        if (s.pendingInputs.length > 0) {
+            const nums = ['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨'];
+            const items = s.pendingInputs.slice(0, 5).map((t, i) => `${nums[i] || '•'} ${trunc(t, 25)}`).join('  ');
+            const more = s.pendingInputs.length > 5 ? `  +${s.pendingInputs.length - 5}` : '';
+            lines.push(` ${ANSI_COLORS.magenta}[${s.pendingInputs.length} queued]${RESET} ${ANSI_COLORS.gray}${items}${more}${RESET}`);
+        }
+        // Line 2: Input prompt
+        if (s.inputBuf) {
+            lines.push(` ${ANSI_COLORS.white}› ${s.inputBuf}${RESET}`);
+        }
+        else {
+            lines.push(` ${ANSI_COLORS.gray}› type to send input${RESET}`);
+        }
+        // Line 3: Status bar (stats)
         const elapsed = fmtDur(Date.now() - s.loopStart);
         const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
         const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
         const filled = Math.round((pct / 100) * 8);
-        const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
+        const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
         const tok = fmtTok(s.tokensIn + s.tokensOut);
         const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let line = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
-        if (cur)
-            line += ` | ${cur}`;
+        let stats = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
+        if (cur) {
+            const col = ANSI_COLORS[agentColor(cur)] || '';
+            stats += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
+        }
         if (s.taskName)
-            line += ` | ${trunc(s.taskName, 20)}`;
+            stats += ` | ${ANSI_COLORS.cyan}${trunc(s.taskName, 20)}${RESET}\x1b[7m`;
         if (s.paused)
-            line += ' | PAUSED';
-        line += s.inputBuf ? `  › ${s.inputBuf}` : '  › type to send input';
-        // Truncate to terminal width
-        const cols = process.stdout.columns || 120;
-        if (line.length > cols)
-            line = line.slice(0, cols - 1) + '…';
-        return line;
+            stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
+        stats += ` ${RESET}`;
+        lines.push(stats);
+        return lines;
     }
-    buildColoredStatusBar() {
+    /** Plain-text version for testing / non-ANSI contexts. */
+    buildPlainStatusLines() {
         const s = this.state;
+        const lines = [];
+        if (s.pendingInputs.length > 0) {
+            const items = s.pendingInputs.slice(0, 5).map((t, i) => `${i + 1}. ${trunc(t, 25)}`).join('  ');
+            const more = s.pendingInputs.length > 5 ? `  +${s.pendingInputs.length - 5}` : '';
+            lines.push(` [${s.pendingInputs.length} queued] ${items}${more}`);
+        }
+        lines.push(s.inputBuf ? ` › ${s.inputBuf}` : ' › type to send input');
         const elapsed = fmtDur(Date.now() - s.loopStart);
         const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
         const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
         const filled = Math.round((pct / 100) * 8);
-        const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
+        const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
         const tok = fmtTok(s.tokensIn + s.tokensOut);
         const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let line = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
-        if (cur) {
-            const col = ANSI_COLORS[agentColor(cur)] || '';
-            line += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
-        }
+        let stats = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
+        if (cur)
+            stats += ` | ${cur}`;
         if (s.taskName)
-            line += ` | ${ANSI_COLORS.cyan}${trunc(s.taskName, 20)}${RESET}\x1b[7m`;
+            stats += ` | ${trunc(s.taskName, 20)}`;
         if (s.paused)
-            line += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
-        if (s.inputBuf) {
-            line += `  ${RESET}${ANSI_COLORS.white}› ${s.inputBuf}${RESET}`;
-        }
-        else {
-            line += `  ${RESET}${ANSI_COLORS.gray}› type to send input${RESET}`;
+            stats += ' | PAUSED';
+        lines.push(stats);
+        return lines;
+    }
+    clearStatusArea() {
+        if (this.statusBarLines > 0) {
+            // Move cursor up to first status line, then clear everything below
+            process.stdout.write(CURSOR_UP(this.statusBarLines - 1) + '\r' + CLEAR_TO_END);
         }
-        line += ` ${RESET}`;
-        return line;
     }
     renderStatusBar() {
         if (!this.interactive)
             return;
-        const line = this.buildColoredStatusBar();
-        process.stdout.write(CLEAR_LINE + line);
-        this.statusBarVisible = true;
+        this.clearStatusArea();
+        const lines = this.buildStatusLines();
+        process.stdout.write(lines.join('\n'));
+        this.statusBarLines = lines.length;
     }
     // ─── Log output (stdout — preserves scroll history) ───
     log(formatted, raw) {
-        if (this.interactive && this.statusBarVisible) {
-            // Clear the status bar line, write the log line, then re-render status bar
-            process.stdout.write(CLEAR_LINE + formatted + '\n');
+        if (this.interactive && this.statusBarLines > 0) {
+            // Clear status area, write the log line, then re-render status
+            this.clearStatusArea();
+            process.stdout.write(formatted + '\n');
             this.renderStatusBar();
         }
         else {
@@ -299,6 +338,10 @@ export class TUI {
                 this.onAssistant(message);
                 break;
             case 'user':
+                // Detect echoed user input (string content) vs tool results (array content)
+                if (typeof message.message?.content === 'string' && this.state.pendingInputs.length > 0) {
+                    this.consumePendingInput();
+                }
                 this.onToolResult(message);
                 break;
             case 'system':

package/dist/{scripts/lib → scheduler/ui}/tui.spec.js

@@ -288,3 +288,59 @@ describe('TUI — message handling', () => {
         expect(true).toBe(true);
     });
 });
+describe('TUI — pending input queue', () => {
+    it('addPendingInput logs the queued message', () => {
+        const tui = new TUI(LOG_FILE, false);
+        tui.addPendingInput('fix login bug');
+        expect(readLog()).toContain('Queued:');
+        expect(readLog()).toContain('fix login bug');
+    });
+    it('consumePendingInput returns and logs first item', () => {
+        const tui = new TUI(LOG_FILE, false);
+        tui.addPendingInput('first');
+        tui.addPendingInput('second');
+        const consumed = tui.consumePendingInput();
+        expect(consumed).toBe('first');
+        expect(readLog()).toContain('Processing:');
+        expect(readLog()).toContain('first');
+    });
+    it('consumePendingInput returns undefined when empty', () => {
+        const tui = new TUI(LOG_FILE, false);
+        expect(tui.consumePendingInput()).toBeUndefined();
+    });
+    it('echoed user message consumes from pending queue', () => {
+        const tui = new TUI(LOG_FILE, false);
+        tui.addPendingInput('add tests');
+        // Simulate SDK echoing back the user message (string content, not tool_result array)
+        tui.handleMessage(msg({
+            type: 'user',
+            message: { role: 'user', content: 'add tests' },
+        }));
+        const log = readLog();
+        expect(log).toContain('Queued:');
+        expect(log).toContain('Processing:');
+        // Queue should be empty now
+        expect(tui.consumePendingInput()).toBeUndefined();
+    });
+    it('tool_result user messages do not consume from queue', () => {
+        const tui = new TUI(LOG_FILE, false);
+        tui.addPendingInput('pending task');
+        // Tool result has array content, should NOT consume
+        tui.handleMessage(msg({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'ok', is_error: false }] },
+        }));
+        // Queue should still have the item
+        expect(tui.consumePendingInput()).toBe('pending task');
+    });
+    it('multiple pending inputs are consumed in FIFO order', () => {
+        const tui = new TUI(LOG_FILE, false);
+        tui.addPendingInput('first');
+        tui.addPendingInput('second');
+        tui.addPendingInput('third');
+        // Consume via echoed user messages
+        tui.handleMessage(msg({ type: 'user', message: { role: 'user', content: 'first' } }));
+        tui.handleMessage(msg({ type: 'user', message: { role: 'user', content: 'second' } }));
+        expect(tui.consumePendingInput()).toBe('third');
+    });
+});

package/dist/scheduler/util/memory.mjs

@@ -0,0 +1,126 @@
+// ─── Pure string transformations for MEMORY.md ───
+// All functions are pure: string in → string out. No file I/O.
+/**
+ * Read a top-level section value from MEMORY.md.
+ * Sections are h2 headings (`## Section Name`), value is everything until the next heading.
+ */
+export function readField(content, field) {
+    const sections = splitSections(content);
+    const section = sections.find(s => s.heading === field);
+    if (!section)
+        return null;
+    const trimmed = section.body.trim();
+    return trimmed || null;
+}
+/**
+ * Write a top-level section value. Creates the section if it doesn't exist.
+ */
+export function writeField(content, field, value) {
+    const sections = splitSections(content);
+    const idx = sections.findIndex(s => s.heading === field);
+    if (idx >= 0) {
+        sections[idx] = { heading: field, body: value + '\n' };
+        return assembleSections(content, sections);
+    }
+    // Append new section
+    const trimmed = content.trimEnd();
+    return `${trimmed}\n\n## ${field}\n${value}\n`;
+}
+function splitSections(content) {
+    const sections = [];
+    const lines = content.split('\n');
+    let currentHeading = null;
+    let bodyLines = [];
+    for (const line of lines) {
+        const match = line.match(/^## (.+)$/);
+        if (match) {
+            if (currentHeading !== null) {
+                sections.push({ heading: currentHeading, body: bodyLines.join('\n') });
+            }
+            currentHeading = match[1].trim();
+            bodyLines = [];
+        }
+        else if (currentHeading !== null) {
+            bodyLines.push(line);
+        }
+    }
+    if (currentHeading !== null) {
+        sections.push({ heading: currentHeading, body: bodyLines.join('\n') });
+    }
+    return sections;
+}
+function assembleSections(original, sections) {
+    // Preserve everything before the first ## heading
+    let preamble = '';
+    if (original.startsWith('## ')) {
+        preamble = '';
+    }
+    else {
+        const idx = original.indexOf('\n## ');
+        preamble = idx >= 0 ? original.slice(0, idx + 1) : '';
+    }
+    const body = sections
+        .map(s => `## ${s.heading}\n${s.body}`)
+        .join('\n');
+    return preamble + body;
+}
+/**
+ * Append a completed task to the "Done" section.
+ */
+export function addDoneItem(content, taskTitle, date) {
+    const done = readField(content, 'Done');
+    if (!done || done === '(nothing yet)') {
+        return writeField(content, 'Done', `- ${taskTitle} (${date})`);
+    }
+    return writeField(content, 'Done', `${done}\n- ${taskTitle} (${date})`);
+}
+/**
+ * Set the "Next" section to a specific task.
+ */
+export function setNextItem(content, taskTitle) {
+    return writeField(content, 'Next', `- ${taskTitle}`);
+}
+/**
+ * Read Session Config as key-value pairs.
+ */
+export function readSessionConfig(content) {
+    const section = readField(content, 'Session Config');
+    if (!section)
+        return {};
+    const config = {};
+    for (const line of section.split('\n')) {
+        const match = line.match(/^-\s*(\w[\w_\s]*\w|\w+):\s*(.+)$/);
+        if (match) {
+            config[match[1].trim()] = match[2].trim();
+        }
+    }
+    return config;
+}
+/**
+ * Check if the project is marked as complete.
+ */
+export function isProjectComplete(content) {
+    return /^Current Phase:.*PROJECT COMPLETE/mi.test(content)
+        || /^Project_Status:\s*complete/mi.test(content)
+        || /## Current Phase\s*\n.*PROJECT COMPLETE/mi.test(content);
+}
+/**
+ * Read iteration count from MEMORY.md.
+ */
+export function readIterationCount(content) {
+    const value = readField(content, 'Iterations This Session');
+    if (!value)
+        return 0;
+    const n = parseInt(value, 10);
+    return isNaN(n) ? 0 : n;
+}
+/**
+ * Increment iteration count.
+ */
+export function incrementIterations(content) {
+    const current = readIterationCount(content);
+    return writeField(content, 'Iterations This Session', String(current + 1));
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}