@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.87

package/dist/core/context/repo-skeleton.js

@@ -1,40 +1,40 @@
 /**
- * Tier 0 repo skeleton builder - α6.5 Phase 1 (three-tier context).
+ * Tier 0 repo skeleton builder - Phase 1 (three-tier context).
  *
  * The skeleton is the ~5KB "always loaded" tier in the three-tier
  * model. Goal: give the agent enough structural awareness to navigate
  * an unfamiliar repo on the first turn without uploading the whole
  * tree. We capture:
  *
- *   - cwd + current branch (best-effort, no exec)
- *   - detected package manager (lockfile heuristic)
- *   - primary languages (file-extension histogram, top 5)
- *   - ASCII directory tree (depth <= MAX_TREE_DEPTH, collapses busy
- *     dirs to a "(N dirs, M files)" line)
- *   - package.json projection (name/version/scripts/deps)
- *   - first MAX_README_LINES of README.md
+ *  - cwd + current branch (best-effort, no exec)
+ *  - detected package manager (lockfile heuristic)
+ *  - primary languages (file-extension histogram, top 5)
+ *  - ASCII directory tree (depth <= MAX_TREE_DEPTH, collapses busy
+ *    dirs to a "(N dirs, M files)" line)
+ *  - package.json projection (name/version/scripts/deps)
+ *  - first MAX_README_LINES of README.md
  *
  * Hard constraints:
  *
- *   1. **5KB cap on the rendered string**. We render in priority
- *      order (headers + meta first, then tree, then package.json, then
- *      README) and truncate the tail with a "..." marker rather than
- *      omitting fields. The walker's bound is independent: it stops
- *      visiting dirs after a hard `MAX_WALK_NODES` even when the
- *      skeleton would still fit.
+ *  1. **5KB cap on the rendered string**. We render in priority
+ *     order (headers + meta first, then tree, then package.json, then
+ *     README) and truncate the tail with a "..." marker rather than
+ *     omitting fields. The walker's bound is independent: it stops
+ *     visiting dirs after a hard `MAX_WALK_NODES` even when the
+ *     skeleton would still fit.
  *
- *   2. **Ignore-aware**: every fs read is filtered through `PugiIgnore`
- *      so `.env`, `*.pem`, `node_modules/`, etc. stay out. The walker
- *      uses the same matcher so `node_modules/` is never expanded.
+ *  2. **Ignore-aware**: every fs read is filtered through `PugiIgnore`
+ *     so `.env`, `*.pem`, `node_modules/`, etc. stay out. The walker
+ *     uses the same matcher so `node_modules/` is never expanded.
  *
- *   3. **No exec**: we read `.git/HEAD` for the branch, never spawn
- *      `git`. The skeleton is built on session bootstrap; spawning
- *      git on every launch is slow + makes the CLI flaky on hosts
- *      without git installed.
+ *  3. **No exec**: we read `.git/HEAD` for the branch, never spawn
+ *     `git`. The skeleton is built on session bootstrap; spawning
+ *     git on every launch is slow + makes the CLI flaky on hosts
+ *     without git installed.
  *
- *   4. **Best-effort**: every FS read is wrapped in try/catch.
- *      Missing README / missing package.json / unreadable file -> the
- *      field is omitted but the skeleton still builds.
+ *  4. **Best-effort**: every FS read is wrapped in try/catch.
+ *     Missing README / missing package.json / unreadable file -> the
+ *     field is omitted but the skeleton still builds.
  */
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
@@ -64,7 +64,7 @@ export function buildRepoSkeleton(cwd, options) {
     // contracts, customer-specific data, NDA'd boilerplate) keeps those
     // files out of the agent context. Without this gate, the direct
     // skeleton reads would BYPASS the matcher even though the walker
-    // honours it. triple-review P1 (PR #380).
+    // honours it. triple-review P1 (PR).
     const pkg = readPackageJson(normalised, ignore);
     const packageManager = detectPackageManager(normalised, ignore);
     const walk = walkTree(normalised, ignore);
@@ -93,10 +93,10 @@ export function buildRepoSkeleton(cwd, options) {
  *
  * Section order (highest priority first):
  *
- *   1. Meta header (cwd / branch / package manager / languages)
- *   2. Directory tree
- *   3. package.json projection (name / version / scripts / deps count)
- *   4. README excerpt
+ *  1. Meta header (cwd / branch / package manager / languages)
+ *  2. Directory tree
+ *  3. package.json projection (name / version / scripts / deps count)
+ *  4. README excerpt
  *
  * Each lower-priority section is appended only when there is room for
  * its FULL body. Partial sections would mislead the model (e.g. a
@@ -132,7 +132,7 @@ export function renderSkeleton(skeleton) {
     return out;
 }
 /* ------------------------------------------------------------------ */
-/* Section renderers                                                  */
+/* Section renderers                                                 */
 /* ------------------------------------------------------------------ */
 function renderHeader(skeleton) {
     const lines = [];
@@ -184,7 +184,7 @@ function renderReadmeSection(skeleton) {
     return `\n## README (first ${MAX_README_LINES} lines)\n${skeleton.readmeExcerpt}`;
 }
 /* ------------------------------------------------------------------ */
-/* Signal readers                                                     */
+/* Signal readers                                                    */
 /* ------------------------------------------------------------------ */
 /**
  * Read the current branch from `.git/HEAD` WITHOUT spawning git. The
@@ -264,7 +264,7 @@ export function readPackageJson(cwd, ignore) {
     // package.json to .pugiignore (private template projects, customer
     // boilerplate under NDA) must not have it read into the agent
     // context even though the walker would have skipped it.
-    // triple-review P1 (PR #380). The matcher is optional so direct callers
+    // triple-review P1 (PR). The matcher is optional so direct callers
     // (e.g. unit tests of readPackageJson in isolation) keep working.
     if (ignore?.isIgnored(pkgPath))
         return undefined;
@@ -298,7 +298,7 @@ export function readReadme(cwd, overridePath, ignore) {
     for (const candidate of candidates) {
         // Skip candidates the operator has explicitly ignored. A workspace
         // README that documents private contracts / customer data must
-        // never land in the rendered skeleton. triple-review P1 (PR #380).
+        // never land in the rendered skeleton. triple-review P1 (PR).
         if (ignore?.isIgnored(candidate))
             continue;
         const raw = safeRead(candidate);
@@ -383,7 +383,7 @@ function walkTree(cwd, ignore) {
 }
 /**
  * Render a `DirNode` as a UTF-8 ASCII-tree string. Lines use the
- * Claude Code convention: `├──` / `└──` glyphs, two-space indents per
+ * the upstream tool convention: `├──` / `└──` glyphs, two-space indents per
  * level. Collapsed dirs land as `name/ (N dirs, M files)`.
  */
 function renderTree(root) {
@@ -408,12 +408,12 @@ function appendChildren(node, prefix, lines) {
         const isLast = i === children.length - 1;
         const glyph = isLast ? '└── ' : '├── ';
         lines.push(`${prefix}${glyph}${child.name}/${counts(child)}`);
-        const nextPrefix = `${prefix}${isLast ? '    ' : '│   '}`;
+        const nextPrefix = `${prefix}${isLast ? '   ' : '│  '}`;
         appendChildren(child, nextPrefix, lines);
     }
 }
 /* ------------------------------------------------------------------ */
-/* Language histogram                                                 */
+/* Language histogram                                                */
 /* ------------------------------------------------------------------ */
 /**
  * Map a filename to a human-readable language label. Returns null for
@@ -495,7 +495,7 @@ export function topLanguages(histogram, topN) {
     return entries.slice(0, topN).map(([lang]) => lang);
 }
 /* ------------------------------------------------------------------ */
-/* Small helpers                                                      */
+/* Small helpers                                                     */
 /* ------------------------------------------------------------------ */
 function safeRead(path) {
     // Stat first to keep the regular-file guard (Codex R2 P2): a FIFO or

package/dist/core/context/tool-eviction.js

@@ -0,0 +1,55 @@
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export function evictByLRU(entries, targetTokens) {
+    const sorted = [...entries].sort((a, b) => a.usedAt.localeCompare(b.usedAt));
+    const total = sorted.reduce((sum, e) => sum + e.tokensEst, 0);
+    if (total <= targetTokens) {
+        return {
+            evicted: [],
+            kept: sorted.map((e) => e.id),
+            freedTokens: 0,
+        };
+    }
+    const evicted = [];
+    const kept = [];
+    let freedTokens = 0;
+    let remaining = total;
+    for (const entry of sorted) {
+        if (remaining > targetTokens) {
+            evicted.push(entry.id);
+            freedTokens += entry.tokensEst;
+            remaining -= entry.tokensEst;
+        }
+        else {
+            kept.push(entry.id);
+        }
+    }
+    return { evicted, kept, freedTokens };
+}
+export function evictByContentClass(entries, rules, now = new Date()) {
+    const ruleByTool = new Map(rules.map((r) => [r.tool, r]));
+    const nowMs = now.getTime();
+    const evicted = [];
+    const kept = [];
+    let freedTokens = 0;
+    for (const entry of entries) {
+        const rule = ruleByTool.get(entry.tool);
+        if (!rule) {
+            kept.push(entry.id);
+            continue;
+        }
+        const ageMs = nowMs - new Date(entry.ts).getTime();
+        const tooOld = ageMs > rule.maxAgeMs;
+        const tooBig = entry.tokensEst > rule.maxTokens;
+        if (tooOld || tooBig) {
+            evicted.push(entry.id);
+            freedTokens += entry.tokensEst;
+        }
+        else {
+            kept.push(entry.id);
+        }
+    }
+    return { evicted, kept, freedTokens };
+}
+//# sourceMappingURL=tool-eviction.js.map

package/dist/core/context/watcher.js

@@ -1,5 +1,5 @@
 /**
- * chokidar-based filewatch - α6.5 Phase 1 (three-tier context).
+ * chokidar-based filewatch - Phase 1 (three-tier context).
  *
  * The REPL needs a live signal when files change so the operator's
  * agent can re-read a stale file, and so the status bar can surface a
@@ -8,35 +8,35 @@
  *
  * Design choices:
  *
- *   1. **Ignore-aware**: every watched path is filtered through the
- *      same `PugiIgnore` matcher the skeleton walker uses. We pass the
- *      matcher into chokidar's `ignored` option so `node_modules/`,
- *      `dist/`, `.git/`, and secret files are never watched at all -
- *      this matters because chokidar's resource bound is the number
- *      of watched paths, not the number of total files in the repo.
+ *  1. **Ignore-aware**: every watched path is filtered through the
+ *     same `PugiIgnore` matcher the skeleton walker uses. We pass the
+ *     matcher into chokidar's `ignored` option so `node_modules/`,
+ *     `dist/`, `.git/`, and secret files are never watched at all -
+ *     this matters because chokidar's resource bound is the number
+ *     of watched paths, not the number of total files in the repo.
  *
- *   2. **Throttle**: chokidar can fire dozens of `change` events when
- *      a code formatter rewrites a directory. We batch events in a
- *      `THROTTLE_WINDOW_MS` window and emit a single aggregated event
- *      so the REPL system line / status bar do not flicker.
+ *  2. **Throttle**: chokidar can fire dozens of `change` events when
+ *     a code formatter rewrites a directory. We batch events in a
+ *     `THROTTLE_WINDOW_MS` window and emit a single aggregated event
+ *     so the REPL system line / status bar do not flicker.
  *
- *   3. **Watch cap**: per spec, the watcher caps watched paths at
- *      `MAX_WATCHED_PATHS`. Once the count crosses the cap we close
- *      the watcher and fall back to "no live updates this session" -
- *      better to silently lose the badge than to consume thousands of
- *      file descriptors. The fallback path emits one warning event so
- *      the operator knows live updates are off.
+ *  3. **Watch cap**: per spec, the watcher caps watched paths at
+ *     `MAX_WATCHED_PATHS`. Once the count crosses the cap we close
+ *     the watcher and fall back to "no live updates this session" -
+ *     better to silently lose the badge than to consume thousands of
+ *     file descriptors. The fallback path emits one warning event so
+ *     the operator knows live updates are off.
  *
- *   4. **Lifecycle**: `start()` is async (chokidar's `ready` event)
- *      so the caller can `await` the initial scan. `close()` is also
- *      async (chokidar's close is async). The watcher is reusable
- *      across multiple `start` / `close` pairs, but Phase 1 expects
- *      one-watcher-per-REPL-session.
+ *  4. **Lifecycle**: `start()` is async (chokidar's `ready` event)
+ *     so the caller can `await` the initial scan. `close()` is also
+ *     async (chokidar's close is async). The watcher is reusable
+ *     across multiple `start` / `close` pairs, but Phase 1 expects
+ *     one-watcher-per-REPL-session.
  *
- *   5. **Testability**: the chokidar handle is injectable via the
- *      `watchFactory` option. Production wires `chokidar.watch`;
- *      tests pass a fake emitter that lets the spec drive `add` /
- *      `change` / `unlink` events synchronously.
+ *  5. **Testability**: the chokidar handle is injectable via the
+ *     `watchFactory` option. Production wires `chokidar.watch`;
+ *     tests pass a fake emitter that lets the spec drive `add` /
+ *     `change` / `unlink` events synchronously.
  */
 import { EventEmitter } from 'node:events';
 import chokidar from 'chokidar';
@@ -50,7 +50,7 @@ export const THROTTLE_WINDOW_MS = 250;
  * giant subtree post-ready can blow past the cap without ever
  * re-evaluating. Sample every N adds so the cap fires within a
  * bounded window even on post-ready growth. Cheap: one Map
- * iteration per N adds. triple-review P2 (PR #380).
+ * iteration per N adds. triple-review P2 (PR).
  */
 export const CAP_CHECK_ADD_INTERVAL = 1_000;
 /**
@@ -76,7 +76,7 @@ export class PugiWatcher extends EventEmitter {
     /**
      * Counter of `add` events received since the last cap-check sample.
      * When it crosses CAP_CHECK_ADD_INTERVAL we schedule another check.
-     * Resets on every cap-check run. triple-review P2 (PR #380).
+     * Resets on every cap-check run. triple-review P2 (PR).
      */
     addsSinceLastCapCheck = 0;
     constructor(options) {
@@ -97,7 +97,7 @@ export class PugiWatcher extends EventEmitter {
         // the event so emit() does not crash the CLI; any real consumer
         // that subscribes later receives the events as normal because
         // EventEmitter delivers to every registered listener, not just one.
-        // Codex P1 (PR #380).
+        // Codex P1 (PR).
         this.on('error', () => {
             /* defensive no-op so emit('error') never throws */
         });
@@ -162,7 +162,7 @@ export class PugiWatcher extends EventEmitter {
                 // post-ready burst (e.g. `git checkout` of a giant subtree)
                 // does not silently blow past the watched-paths cap. The
                 // ready-time check is preserved; this is the missing follow-up
-                // sampler the comment promised. triple-review P2 (PR #380).
+                // sampler the comment promised. triple-review P2 (PR).
                 this.addsSinceLastCapCheck += 1;
                 if (this.addsSinceLastCapCheck >= CAP_CHECK_ADD_INTERVAL) {
                     this.addsSinceLastCapCheck = 0;
@@ -225,7 +225,7 @@ export class PugiWatcher extends EventEmitter {
         return this.buffer.length;
     }
     /* ------------------------------------------------------------ */
-    /* Internals                                                    */
+    /* Internals                                                   */
     /* ------------------------------------------------------------ */
     queue(kind, path) {
         if (this.closed)
@@ -291,7 +291,7 @@ export class PugiWatcher extends EventEmitter {
     }
 }
 /* ------------------------------------------------------------------ */
-/* Helpers                                                            */
+/* Helpers                                                           */
 /* ------------------------------------------------------------------ */
 /**
  * Convert an absolute path to a repo-relative POSIX path. chokidar

package/dist/core/context/working-set.js

@@ -1,41 +1,41 @@
 /**
- * Tier 1 working-set tracker - α6.5 Phase 1 (three-tier context).
+ * Tier 1 working-set tracker - Phase 1 (three-tier context).
  *
  * The model context window is finite. Tier 0 (repo skeleton, ~5KB) is
- * always loaded; Tier 2 (RAG, Anvil-side, deferred to α6.5b) answers
+ * always loaded; Tier 2 (RAG, Anvil-side, deferred to ) answers
  * queries on demand. Tier 1 - the working set - lives between them: the
  * subset of files the agent has touched THIS session, bounded so a
  * long REPL session does not unbounded-grow the system prompt.
  *
  * Design choices:
  *
- *   1. **LRU semantics**: the most-recently-touched file stays in the
- *      window; the oldest is evicted when the cap is hit. We use a
- *      `Map` so insertion order doubles as recency order (delete +
- *      re-set bubbles the entry to the tail).
+ *  1. **LRU semantics**: the most-recently-touched file stays in the
+ *     window; the oldest is evicted when the cap is hit. We use a
+ *     `Map` so insertion order doubles as recency order (delete +
+ *     re-set bubbles the entry to the tail).
  *
- *   2. **Source tracking**: every `track()` call records the source -
- *      `read` (agent fetched the file), `edit` (agent modified it),
- *      `write` (agent created it). The source seeds future heuristics
- *      (e.g. always pin edited files near the cap, never evict files
- *      written this session) but Phase 1 keeps the policy simple:
- *      pure LRU.
+ *  2. **Source tracking**: every `track()` call records the source -
+ *     `read` (agent fetched the file), `edit` (agent modified it),
+ *     `write` (agent created it). The source seeds future heuristics
+ *     (e.g. always pin edited files near the cap, never evict files
+ *     written this session) but Phase 1 keeps the policy simple:
+ *     pure LRU.
  *
- *   3. **No persistence**: working set is in-memory only. A REPL
- *      restart rebuilds from scratch (and from `/resume` SessionStore
- *      replay if/when we wire that). Per α6.5 spec: "node:sqlite NOT
- *      needed for this sprint."
+ *  3. **No persistence**: working set is in-memory only. A REPL
+ *     restart rebuilds from scratch (and from `/resume` SessionStore
+ *     replay if/when we wire that). Per spec: "node:sqlite NOT
+ *     needed for this sprint."
  *
- *   4. **Path normalisation**: we resolve every path to an absolute
- *      form on insert so two `track()` calls with `./foo.ts` and
- *      `/abs/cwd/foo.ts` collapse to one entry.
+ *  4. **Path normalisation**: we resolve every path to an absolute
+ *     form on insert so two `track()` calls with `./foo.ts` and
+ *     `/abs/cwd/foo.ts` collapse to one entry.
  *
- *   5. **Defensive cap**: `MAX_WORKING_SET = 50` per spec. We hold the
- *      cap as a configurable option so tests can dial it down to
- *      exercise eviction without 51 fixture files.
+ *  5. **Defensive cap**: `MAX_WORKING_SET = 50` per spec. We hold the
+ *     cap as a configurable option so tests can dial it down to
+ *     exercise eviction without 51 fixture files.
  */
 import { resolve } from 'node:path';
-/** Spec-mandated default cap. Mirrors the doc string in the α6.5 sprint plan. */
+/** Spec-mandated default cap. Mirrors the doc string in the sprint plan. */
 export const DEFAULT_WORKING_SET_CAPACITY = 50;
 export class WorkingSet {
     entries = new Map();

package/dist/core/coordinator/agent-tools.js

@@ -0,0 +1,77 @@
+function snapshot(task) {
+    return { ...task };
+}
+function isTerminal(status) {
+    return status === 'completed' || status === 'cancelled' || status === 'failed';
+}
+export function createAgentCoordinator(options) {
+    const tasks = new Map();
+    return {
+        async createTask(agentType, prompt) {
+            const { taskId } = await options.spawn(agentType, prompt);
+            const task = {
+                id: taskId,
+                agentType,
+                prompt,
+                status: 'queued',
+                createdAt: Date.now(),
+            };
+            tasks.set(task.id, task);
+            task.status = 'running';
+            task.startedAt = Date.now();
+            return snapshot(task);
+        },
+        async sendMessage(taskId, message) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                throw new Error(`agent task ${taskId} not found`);
+            }
+            if (task.status !== 'running') {
+                throw new Error(`agent task ${taskId} is not running (status=${task.status})`);
+            }
+            await options.send(taskId, message);
+        },
+        async stopTask(taskId) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                throw new Error(`agent task ${taskId} not found`);
+            }
+            if (isTerminal(task.status)) {
+                return;
+            }
+            await options.stop(taskId);
+            task.status = 'cancelled';
+            task.completedAt = Date.now();
+        },
+        listTasks() {
+            return Array.from(tasks.values())
+                .sort((a, b) => b.createdAt - a.createdAt)
+                .map(snapshot);
+        },
+        getTask(taskId) {
+            const task = tasks.get(taskId);
+            return task ? snapshot(task) : null;
+        },
+        markCompleted(taskId, output) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                return;
+            }
+            task.status = 'completed';
+            task.completedAt = Date.now();
+            task.output = output;
+            delete task.error;
+        },
+        markFailed(taskId, error) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                return;
+            }
+            task.status = 'failed';
+            task.completedAt = Date.now();
+            task.error = error;
+            delete task.output;
+        },
+    };
+}
+//# sourceMappingURL=agent-tools.js.map

package/dist/core/coordinator/agent-toolset.js

@@ -0,0 +1,65 @@
+// apps/pugi-cli/src/core/coordinator/agent-toolset.ts
+import { randomUUID } from 'node:crypto';
+export class AgentCoordinator {
+    agents = new Map();
+    spawnAgent(subagentType, prompt) {
+        const handle = {
+            id: randomUUID(),
+            subagentType,
+            prompt,
+            status: 'spawned',
+            spawnedAt: new Date().toISOString(),
+        };
+        this.agents.set(handle.id, handle);
+        return handle;
+    }
+    sendMessage(agentId, _message) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return { ok: false, reason: `agent ${agentId} not found` };
+        }
+        if (agent.status !== 'spawned' && agent.status !== 'running') {
+            return { ok: false, reason: `agent ${agentId} not accepting messages (status=${agent.status})` };
+        }
+        return { ok: true };
+    }
+    taskStop(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return { ok: false, reason: `agent ${agentId} not found` };
+        }
+        agent.status = 'stopped';
+        agent.completedAt = new Date().toISOString();
+        return { ok: true };
+    }
+    markCompleted(agentId, result) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'completed';
+        agent.completedAt = new Date().toISOString();
+        agent.result = result;
+    }
+    markFailed(agentId, reason) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'failed';
+        agent.completedAt = new Date().toISOString();
+        agent.result = reason;
+    }
+    listAgents(filter) {
+        const all = Array.from(this.agents.values());
+        if (!filter?.status) {
+            return all;
+        }
+        const wanted = filter.status;
+        return all.filter((a) => a.status === wanted);
+    }
+    getAgent(id) {
+        return this.agents.get(id);
+    }
+}
+//# sourceMappingURL=agent-toolset.js.map

package/dist/core/coordinator/fsm.js

@@ -0,0 +1,73 @@
+export class CoordinatorFSM {
+    state;
+    constructor() {
+        this.state = {
+            phase: 'research',
+            inflightOps: [],
+            completedPhases: [],
+        };
+    }
+    getState() {
+        // Return a shallow copy to prevent direct mutation of the internal state.
+        return {
+            ...this.state,
+            inflightOps: [...this.state.inflightOps],
+            completedPhases: [...this.state.completedPhases],
+        };
+    }
+    canStart(op) {
+        switch (this.state.phase) {
+            case 'research':
+                return op === 'read';
+            case 'synth':
+                return op === 'read';
+            case 'impl':
+                if (op === 'write') {
+                    // 'write' is only allowed when no other operations are in flight.
+                    return this.state.inflightOps.length === 0;
+                }
+                // 'read' and 'exec' are allowed as long as no 'write' is in flight.
+                return !this.state.inflightOps.includes('write');
+            case 'done':
+                return false;
+            default:
+                return false;
+        }
+    }
+    start(op) {
+        if (!this.canStart(op)) {
+            throw new Error(`Operation '${op}' cannot be started in phase '${this.state.phase}' with inflight ops: [${this.state.inflightOps.join(', ')}]`);
+        }
+        this.state.inflightOps.push(op);
+    }
+    finish(op) {
+        const opIndex = this.state.inflightOps.indexOf(op);
+        if (opIndex === -1) {
+            throw new Error(`Cannot finish operation '${op}' as it is not in flight. Inflight ops: [${this.state.inflightOps.join(', ')}]`);
+        }
+        this.state.inflightOps.splice(opIndex, 1);
+    }
+    advance() {
+        if (this.state.inflightOps.length > 0) {
+            throw new Error(`Cannot advance phase with operations in flight: [${this.state.inflightOps.join(', ')}]`);
+        }
+        const currentPhase = this.state.phase;
+        let nextPhase;
+        switch (currentPhase) {
+            case 'research':
+                nextPhase = 'synth';
+                break;
+            case 'synth':
+                nextPhase = 'impl';
+                break;
+            case 'impl':
+                nextPhase = 'done';
+                break;
+            case 'done':
+                throw new Error("Cannot advance from final phase 'done'.");
+        }
+        this.state.completedPhases.push(currentPhase);
+        this.state.phase = nextPhase;
+    }
+}
+//# sourceMappingURL=fsm.js.map