meow-swarm 0.1.1 → 0.1.2

package/README.md

@@ -1,174 +1,111 @@
 # meow-swarm
 
-![](https://img.shields.io/badge/npm-meow--swarm-blue?style=flat-square) ![](https://img.shields.io/badge/Node.js-18%2B-brightgreen?style=flat-square) ![](https://img.shields.io/badge/License-MIT-green?style=flat-square) ![](https://img.shields.io/badge/TypeScript-5.0-blue?style=flat-square)
+**The problem:** You want an AI coding agent that runs autonomously — not a chat window you babysit, but a background worker that accepts a task, runs to completion, and reports back. While you sleep. While you work on something else. In CI.
 
-**`meow -p`** — the primary interface. Run autonomous coding agents in the background.
+**The solution:** `meow -p "task"` dispatches a self-healing, quality-gated coding agent into the background. It checkpoints every step to SQLite, retries on failure, stops when it's stuck, and surfaces everything in a TUI dashboard.
 
-```
+```bash
 npm install -g meow-swarm
-meow -p "fix the auth bug in src/auth.ts"
+meow -p "refactor auth into its own service"
 ```
 
-meow-swarm is a sovereign, stateful, multi-agent coding harness that runs locally in your terminal. It coordinates L1→L4 specialist agents, checkpoints every task state to SQLite, gates output quality before commit, and exposes a TUI dashboard. You fire it and come back later — it is not a synchronous chat partner.
-
 ---
 
-## Get Started
+## Install
+
+**Requires:** Node.js 18+ · `ANTHROPIC_API_KEY` env var set
 
 ```bash
-# Primary: headless mode (no TTY required) — this is meow -p
-meow -p "fix the stalled REPL in src/cli/repl.ts"
+npm install -g meow-swarm
+export ANTHROPIC_API_KEY=sk-ant-...   # or set in shell profile
 
-# Interactive REPL
-meow
+# Primary: headless (no TTY required) — designed for scripts, CI, or background dispatch
+meow -p "fix the race condition in src/queue.ts"
 
-# Interactive TUI
+# Interactive TUI dashboard
 meow --tui
-```
-
-**Requirements:** Node.js 18+, `ANTHROPIC_API_KEY` env var. Bun is not supported (better-sqlite3 requires Node.js native addons).
-
----
-
-## What is meow-swarm?
 
-A background daemon harness for autonomous coding agents. Think `nohup ./worker.sh &` — you dispatch a task, it runs in the background, you check the TUI or state files later.
-
-```
-Task arrives
-    │
-    ▼
-L4 SPECIALIST (Claude Code) — implements
-    │
-    ▼
-MISSION REVIEWER — scores output across 7 criteria
-    │
-    ├── score >= threshold ──► COMMIT
-    │
-    └── score < threshold ──► RETRY (with review notes)
-                                   │
-                    ┌──────────────┴──────────────┐
-                    ▼                             ▼
-              CONVERGENCE CHECK             STAGNATION CHECK
-              ─ token budget?                ─ 2 iters no improvement?
-              ─ max iters hit?              ─ diminishing returns?
-                    │                             │
-                    ▼                             ▼
-               STOP / REPORT                   ADAPT / DECOMPOSE
+# Interactive REPL
+meow
 ```
 
-meow-swarm does NOT grind until the user kills it. It evaluates whether continued iteration is productive and stops when it is not.
-
----
-
-## Quality Gates
-
-Every output passes through structural gates before it can be committed:
-
-| Gate | Checks | Fail action |
-|------|--------|-------------|
-| `NO_MOCKS` | No `TODO`, `FIXME`, placeholder code | Retry with note |
-| `TYPE_CHECK` | `tsc --noEmit` passes | Retry |
-| `LINT_CLEAN` | ESLint reports 0 errors | Retry |
-| `REAL_TESTS` | Test files exist and non-empty | Warn (non-fatal) |
-| `MISSION_COMPLETE` | Goal keywords in output | Retry if missing |
-| `SOP_COMPLIANCE` | Think-Plan-Verify in output | Retry if missing |
-
----
-
-## Convergence Logic
-
-meow-swarm stops iterating when:
-
-- **Stagnation** — No score improvement for 2 consecutive iterations
-- **Token budget exceeded** — Cumulative spend crosses threshold
-- **Diminishing returns** — Score improvement falls below minimum delta
-
----
-
-## Execution Modes
-
-| Mode | Behavior |
-|------|----------|
-| `SEQUENTIAL` | One task at a time. Full review between each step. |
-| `SHIP` | Pass through all specialists with final review only. |
-| `PARALLEL` | Run independent tasks concurrently. |
-| `AUDIT_ONLY` | Score existing output without executing. |
+Bun is not supported. `better-sqlite3` requires Node.js native addons.
 
 ---
 
-## Architecture
+## What it actually does
 
 ```
-L1 LIAISON       — Human-facing. Receives tasks, escalates ambiguity.
-L2 ARCHITECT     — Mid-layer planner. Breaks tasks, sequences dependencies.
-L3 ORCHESTRATOR  — Execution coordinator. TaskQueue, convergence checks.
-L4 SPECIALISTS   — Claude Code / Aider subprocesses.
+you → meow -p "task" → background → checkpoint → quality gate → done
+                                    ↓ stuck?
+                              retry / adapt / stop + report
 ```
 
-**Key files:**
-
-| File | Purpose |
-|------|---------|
-| `src/index.ts` | CLI entry: `meow -p` for headless, `meow` for REPL, `meow --tui` for TUI |
-| `src/agent/agent.ts` | MEOW-3-RULE: 3-retry loop + fixMeow() + suggestUpstreamContribution() |
-| `src/agent/summoner.ts` | Spawns specialist agents as subprocesses |
-| `src/agent/mission_reviewer.ts` | 7-criterion scoring, quality gates |
-| `src/orchestrator/Orchestrator.ts` | Convergence checks, task dispatch |
-| `src/kernel/kernel.ts` | Heartbeat loop, watchdog, respawn |
-| `src/db/database.ts` | SQLite + sqlite-vec for persistence + checkpointing |
+1. **Receives a task** via `meow -p` (headless, no TTY) or `meow` (interactive REPL)
+2. **Dispatches to L4 specialist** (Claude Code subprocess)
+3. **Mission reviewer scores output** across 7 criteria
+4. **Quality gate** — if output fails, it retries with reviewer notes
+5. **Convergence check** — stops if stagnating, budget exceeded, or diminishing returns
+6. **Checkpoints state** to SQLite after every iteration — crash-safe
+7. **TUI dashboard** shows live task progress, queue, and history
 
 ---
 
-## meow -p (the primary interface)
+## Self-healing: the MEOW-3-RULE
 
-`meow -p` is the primary headless interface — no TTY required, designed for calling from scripts, CI, or other AI agents:
+When `meow -p` fails 3 times, it doesn't just give up. It surfaces a diagnostic:
 
 ```
-meow -p "your task description"
+Task arrives → meow -p "task"   (3 retry attempts)
+  ↓ fails × 3
+claude -p "fix meow-swarm"       (repairs meow-swarm's own code, NOT the task)
+  ↓
+you re-run → meow -p "task"     (now succeeds)
 ```
 
-The `-p` / `--plan` flag activates non-interactive mode. Task output goes to stdout. Progress goes to the TTY if available, otherwise to `~/.meow/` state files.
+`claude -p` only fires when meow-swarm's own code/prompts are broken. It fixes meow-swarm, then you re-dispatch the original task. This is the operator loop — you never fix tasks manually.
 
 ---
 
-## MEOW-3-RULE
-
-meow-swarm's self-repair loop:
+## Quality gates
 
-```
-Task arrives → meow -p "task" (meow-swarm gets 3 retry attempts)
-  ↓ fails × 3
-claude -p "fix meow-swarm" (fixes meow-swarm's own code, NOT the task)
-  ↓
-User re-invokes same task → meow -p → succeeds
-```
+Every output is scored before it can be marked complete:
 
-`claude -p` only runs when meow-swarm's own code/prompts/tools are broken. It patches meow-swarm, then meow-swarm retries and completes the task.
+| Gate | Checks | On fail |
+|------|--------|---------|
+| `NO_MOCKS` | No `TODO`, `FIXME`, placeholder code | Retry with note |
+| `TYPE_CHECK` | `tsc --noEmit` passes | Retry |
+| `LINT_CLEAN` | ESLint 0 errors | Retry |
+| `MISSION_COMPLETE` | Goal keywords present in output | Retry |
+| `SOP_COMPLIANCE` | Think-Plan-Verify pattern | Retry |
 
 ---
 
 ## Configuration
 
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `ANTHROPIC_API_KEY` | API key for LLM calls | (required) |
-| `ANTHROPIC_BASE_URL` | LLM endpoint | MiniMax gateway |
-| `ANTHROPIC_MODEL` | Model name | `claude-sonnet-4` |
-| `MEOW_DB` | SQLite database path | `~/.meow/meow.db` |
-| `MEOW_MODE` | Execution mode | `SEQUENTIAL` |
+| Variable | Default | Notes |
+|----------|---------|-------|
+| `ANTHROPIC_API_KEY` | *(required)* | API key for LLM calls |
+| `ANTHROPIC_BASE_URL` | *(not set)* | Override for custom LLM endpoints |
+| `ANTHROPIC_MODEL` | `claude-sonnet-4` | Model name |
+| `MEOW_DB` | `~/.meow/meow.db` | SQLite checkpoint store |
+| `MEOW_MODE` | `SEQUENTIAL` | `SEQUENTIAL` · `PARALLEL` · `SHIP` · `AUDIT_ONLY` |
 
 ---
 
-## npm
+## Architecture
 
 ```
-npm install -g meow-swarm
-https://www.npmjs.com/package/meow-swarm
+L1 LIAISON      — Receives tasks, escalates ambiguity to human
+L2 ARCHITECT     — Breaks tasks, sequences dependencies
+L3 ORCHESTRATOR  — Task queue, convergence checks, dispatch
+L4 SPECIALISTS   — Claude Code subprocesses (can be swapped)
 ```
 
+State is checkpointed to SQLite after every operation. If the process dies, the next invocation resumes from the last checkpoint.
+
 ---
 
 ## License
 
-MIT — see [LICENSE](LICENSE)
+MIT

package/dist/index.js

@@ -289,9 +289,9 @@ var init_harvester = __esm({
     "use strict";
     init_env();
     Harvester = class {
-      quantumMemory;
-      constructor(quantumMemory) {
-        this.quantumMemory = quantumMemory;
+      agenticMemory;
+      constructor(agenticMemory) {
+        this.agenticMemory = agenticMemory;
       }
       /**
        * Distill session logs into a SKILL.md file.
@@ -341,7 +341,7 @@ var init_harvester = __esm({
           const magnitude = Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0)) || 1;
           return arr.map((v) => v / magnitude);
         };
-        const memories = await this.quantumMemory.recall(goal, mockEmbedding(goal));
+        const memories = await this.agenticMemory.recall(goal, mockEmbedding(goal));
         return memories.map((m) => m.content);
       }
       /**
@@ -718,8 +718,8 @@ async function summon(agentName, context) {
     return `\u274C Escalation failed. ${agent.name} error: ${error instanceof Error ? error.message : String(error)}`;
   }
 }
-async function summonHarvester(goal, complexity, quantumMemory, successfulPatterns = []) {
-  const harvester = new Harvester(quantumMemory);
+async function summonHarvester(goal, complexity, agenticMemory, successfulPatterns = []) {
+  const harvester = new Harvester(agenticMemory);
   const ctx = {
     goal,
     complexity,
@@ -752,7 +752,7 @@ ${blueprint}
 INSTRUCTIONS:
 0. BEFORE STARTING: Run 'npx skills find <relevant-topic>' to check the unified ecosystem (https://github.com/stancsz/skills). If a relevant skill exists (see https://github.com/vercel-labs/skills/blob/main/skills/find-skills/SKILL.md), use it to solve the task.
 1. FIX the immediate issue and ensure all tests pass.
-2. DO NOT TOUCH 'quantum_*.ts' files unless the goal specifically asks for it.
+2. DO NOT TOUCH 'agentic_*.ts' files unless the goal specifically asks for it.
 3. DO NOT COMMIT: MEOW is the Expert Taster and will review/commit your work.
 4. REPORT: Summarize your changes and provide exact steps for MEOW to verify your work.
 5. RECURSIVE IMPROVEMENT: If you find a missing pattern, create a reusable skill in 'src/skills/'.
@@ -934,10 +934,9 @@ var init_mission_reviewer = __esm({
         this.agent = agent;
       }
       /**
-       * Performs a Quantum Structural Analysis of the current workspace.
+       * Performs a Structural Analysis of the current workspace.
        */
       async verify(goal, testCmd) {
-        console.log(pc2.bold(pc2.cyan("\n\u{1F9D0} [QUANTUM REVIEW] Starting structural analysis...")));
         let diff = "";
         try {
           const { stdout } = await execAsync("git diff HEAD~1", { encoding: "utf-8" });
@@ -988,7 +987,7 @@ var init_mission_reviewer = __esm({
           }
         ];
         const decisionSpace = [{ diff, goal }];
-        const auditResult = await this.agent.quantumReasoning.solve(decisionSpace, constraints, (msg) => {
+        const auditResult = await this.agent.reasoningEngine.solve(decisionSpace, constraints, (msg) => {
           process.stdout.write(`\r${pc2.dim("Running Logic Audit: " + msg)}`);
         });
         process.stdout.write("\n");
@@ -1328,7 +1327,7 @@ Please follow these instructions for the current task.`
             return "Error: Context management system not available.";
           }
           await agent.compressAndOffload();
-          return "Successfully archived conversation tail to Quantum Knowledge Base. L1 context is now pruned.";
+          return "Successfully archived conversation tail to Agentic Memory Store. L1 context is now pruned.";
         }
       },
       {
@@ -1462,6 +1461,9 @@ var init_ExtensionManager = __esm({
         });
         for (const file of files) {
           try {
+            if (file.endsWith(".ts")) {
+              continue;
+            }
             const fileUrl = pathToFileURL(file).href;
             const module = await import(fileUrl);
             const extension = module.default || module.extension;
@@ -1473,6 +1475,9 @@ var init_ExtensionManager = __esm({
               });
             }
           } catch (e) {
+            if (e?.code === "ERR_UNKNOWN_FILE_EXTENSION" || e?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+              continue;
+            }
             console.error(`Failed to discover extension at ${file}:`, e);
           }
         }
@@ -1534,26 +1539,29 @@ var init_ExtensionManager = __esm({
   }
 });
 
-// src/agent/quantum_memory.ts
-import pc3 from "picocolors";
-var QuantumMemory;
-var init_quantum_memory = __esm({
-  "src/agent/quantum_memory.ts"() {
+// src/agent/memory.ts
+var AgenticMemory;
+var init_memory = __esm({
+  "src/agent/memory.ts"() {
     "use strict";
-    QuantumMemory = class {
+    AgenticMemory = class {
       db;
       kernel;
       reasoning;
-      measuredIds = /* @__PURE__ */ new Set();
+      recalledIds = /* @__PURE__ */ new Set();
       constructor(db, kernel, reasoning) {
         this.db = db;
         this.kernel = kernel;
         this.reasoning = reasoning;
       }
+      /**
+       * Recall relevant memories from the semantic store.
+       * Uses sqlite-vec for nearest-neighbor search on embeddings.
+       */
       async recall(queryText, queryEmbedding) {
         let candidates = [];
         try {
-          const notInClause = Array.from(this.measuredIds).join(",") || -1;
+          const notInClause = Array.from(this.recalledIds).join(",") || -1;
           candidates = await this.db.query(
             `SELECT
           v.rowid,
@@ -1568,165 +1576,111 @@ var init_quantum_memory = __esm({
         ORDER BY v.distance`,
             [new Float32Array(queryEmbedding)]
           );
-        } catch (e) {
+        } catch {
           return [];
         }
         if (candidates.length === 0) return [];
-        if (candidates.length === 1) {
-          const winner2 = candidates[0];
-          this.measuredIds.add(winner2.rowid);
-          return [{
-            content: winner2.content,
-            metadata: JSON.parse(winner2.metadata),
-            distance: winner2.distance
-          }];
-        }
-        const winner = await this.reasoning.groverSearch(candidates, queryText, (msg) => {
-          process.stdout.write(`\r${pc3.magenta(msg)}`);
-        });
-        if (!winner) return [];
-        this.measuredIds.add(winner.rowid);
-        return [{
-          content: winner.content,
-          metadata: JSON.parse(winner.metadata),
-          distance: winner.distance
-        }];
+        const best = await this.reasoning.findBest(
+          candidates,
+          queryText,
+          (msg) => this.kernel.log?.(msg, "memory")
+        );
+        if (best) {
+          this.recalledIds.add(best.rowid);
+        }
+        return candidates.map((c) => ({
+          content: c.content,
+          metadata: JSON.parse(c.metadata || "{}"),
+          distance: c.distance
+        }));
       }
       /**
-       * Store new context (Unitary Evolution of State)
+       * Store a new memory entry with its embedding.
+       * Used after task completion to record successful patterns.
        */
-      store(content, embedding, metadata = {}) {
-        this.kernel.push({
-          type: "STORE_VECTOR",
-          content,
-          embedding,
-          metadata
-        });
+      async store(content, metadata, embedding) {
+        try {
+          await this.db.execute(
+            `INSERT INTO vector_memory_data (content, metadata) VALUES (?, ?)`,
+            [content, JSON.stringify(metadata)]
+          );
+          const rowId = await this.db.query("SELECT last_insert_rowid() as id");
+          if (rowId?.[0]?.id) {
+            await this.db.execute(
+              `INSERT INTO vec_memory (rowid, embedding) VALUES (?, ?)`,
+              [rowId[0].id, new Float32Array(embedding)]
+            );
+          }
+        } catch (e) {
+          this.kernel.log?.(`Memory store failed: ${e}`, "warn");
+        }
+      }
+      /**
+       * Clear the recall session (set-based deduplication reset).
+       */
+      reset() {
+        this.recalledIds.clear();
       }
     };
   }
 });
 
-// src/agent/quantum_reasoning.ts
-import pc4 from "picocolors";
-import QuantumCircuit from "quantum-circuit";
-var QuantumReasoning;
-var init_quantum_reasoning = __esm({
-  "src/agent/quantum_reasoning.ts"() {
+// src/agent/reasoning.ts
+import pc3 from "picocolors";
+var ReasoningEngine;
+var init_reasoning = __esm({
+  "src/agent/reasoning.ts"() {
     "use strict";
-    QuantumReasoning = class {
+    ReasoningEngine = class {
       /**
-       * Solves a combinatorial optimization problem using a real QAOA circuit simulation.
-       * Maps decision space to qubits and applies variational rotations.
+       * Solves a combinatorial optimization problem using weighted constraint scoring.
+       * Evaluates all candidates against constraints and returns the highest-scoring one.
        */
       async solve(space, constraints, onPulse) {
         if (space.length === 0) return null;
         if (space.length === 1) return space[0];
-        const numQubits = Math.ceil(Math.log2(space.length));
-        if (numQubits === 0) return space[0];
-        const circuit = new QuantumCircuit(numQubits);
-        let gamma = 0.5;
-        let beta = 0.3;
-        for (let i = 0; i < numQubits; i++) {
-          circuit.addGate("h", i, i);
-        }
-        const numStates = Math.pow(2, numQubits);
-        for (let step = 0; step < 10; step++) {
-          for (let s = 0; s < numStates; s++) {
-            const choice = space[s % space.length];
-            const totalScore = constraints.reduce((acc, c) => acc + (c.evaluate(choice) ? c.weight : 0), 0);
-            if (totalScore > 0) {
-              for (let q = 0; q < numQubits; q++) {
-                if (!(s >> q & 1)) circuit.addGate("x", q, q);
-              }
-              circuit.addGate("rz", numQubits - 1, numQubits - 1, { params: [gamma * (totalScore / 100)] });
-              for (let q = 0; q < numQubits; q++) {
-                if (!(s >> q & 1)) circuit.addGate("x", q, q);
-              }
+        let best = null;
+        let bestScore = -1;
+        for (const candidate of space) {
+          const totalScore = constraints.reduce((acc, c) => {
+            try {
+              return acc + (c.evaluate(candidate) ? c.weight : 0);
+            } catch {
+              return acc;
             }
-          }
-          for (let i = 0; i < numQubits; i++) {
-            circuit.addGate("rx", i, i, { params: [beta] });
-          }
-          beta *= 0.95;
-          onPulse?.(`\u269B\uFE0F QAOA: \u03B3=${gamma.toFixed(3)} \u03B2=${beta.toFixed(3)} (Step ${step})`);
-          await new Promise((r) => setTimeout(r, 20));
-        }
-        circuit.run();
-        const results = circuit.probabilities();
-        let maxProb = -1;
-        let bestState = 0;
-        for (const state in results) {
-          if (results[state] > maxProb) {
-            maxProb = results[state];
-            bestState = parseInt(state, 2);
+          }, 0);
+          if (totalScore > bestScore) {
+            bestScore = totalScore;
+            best = candidate;
           }
         }
-        const winner = space[bestState % space.length];
         if (onPulse) {
-          onPulse(pc4.green(`\u269B\uFE0F Wavefunction Collapsed: Choice [${bestState % space.length}] Prob ${maxProb.toFixed(4)}`));
-        } else {
-          console.log(pc4.green(`
-\u269B\uFE0F Wavefunction Collapsed: Choice [${bestState % space.length}] with Prob ${maxProb.toFixed(4)}`));
+          onPulse(pc3.green(`\u2713 ConstraintSolver: Best score ${bestScore}, ${space.length} candidates evaluated`));
         }
-        return winner;
+        return best;
       }
       /**
-       * Grover's Algorithm Simulation for QRAM Recall.
-       * Amplifies the probability of the 'correct' semantic matches in a superposition.
+       * Fast search using keyword-overlap scoring.
+       * Returns the best candidate from a list given a query string.
        */
-      async groverSearch(candidates, query, onPulse) {
+      async findBest(candidates, query, onPulse) {
         if (candidates.length === 0) return null;
-        const numQubits = Math.ceil(Math.log2(candidates.length));
-        if (numQubits === 0) {
-          return candidates[0];
-        }
-        const circuit = new QuantumCircuit(numQubits);
-        for (let i = 0; i < numQubits; i++) {
-          circuit.addGate("h", i, i);
-        }
-        const iterations = Math.max(1, Math.floor(Math.sqrt(candidates.length)));
-        for (let iter = 0; iter < iterations; iter++) {
-          candidates.forEach((c, idx) => {
-            const queryTerms = query.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
-            const content = JSON.stringify(c).toLowerCase();
-            const score = queryTerms.filter((q) => content.includes(q)).length / queryTerms.length;
-            if (score > 0.3) {
-              for (let q = 0; q < numQubits; q++) {
-                if (idx >> q & 1) {
-                  circuit.addGate("z", q, q);
-                }
-              }
-            }
-          });
-          for (let i = 0; i < numQubits; i++) circuit.addGate("h", i, i);
-          for (let i = 0; i < numQubits; i++) circuit.addGate("x", i, i);
-          circuit.addGate("h", numQubits - 1, numQubits - 1);
-          circuit.addGate("rz", numQubits - 1, numQubits - 1, { params: [Math.PI] });
-          circuit.addGate("h", numQubits - 1, numQubits - 1);
-          for (let i = 0; i < numQubits; i++) circuit.addGate("x", i, i);
-          for (let i = 0; i < numQubits; i++) circuit.addGate("h", i, i);
-          onPulse?.(`\u{1F300} Grover Iteration ${iter + 1}/${iterations}: Amplifying amplitudes...`);
-          await new Promise((r) => setTimeout(r, 50));
-        }
-        circuit.run();
-        const results = circuit.probabilities();
-        let bestIdx = 0;
-        let maxProb = -1;
-        for (const state in results) {
-          if (results[state] > maxProb) {
-            maxProb = results[state];
-            bestIdx = parseInt(state, 2);
+        const queryTerms = query.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
+        if (queryTerms.length === 0) return candidates[0];
+        let best = null;
+        let bestScore = -1;
+        for (const c of candidates) {
+          const content = JSON.stringify(c).toLowerCase();
+          const score = queryTerms.filter((q) => content.includes(q)).length / queryTerms.length;
+          if (score > bestScore) {
+            bestScore = score;
+            best = c;
           }
         }
-        const winner = candidates[bestIdx % candidates.length];
         if (onPulse) {
-          onPulse(pc4.magenta(`\u{1F300} Grover Search Collapsed: Index [${bestIdx % candidates.length}] Prob ${maxProb.toFixed(4)}`));
-        } else {
-          console.log(pc4.magenta(`
-\u{1F300} Grover Search Collapsed: Index [${bestIdx % candidates.length}] with Prob ${maxProb.toFixed(4)}`));
+          onPulse(pc3.magenta(`\u2713 FastSearch: Best match score ${(bestScore * 100).toFixed(1)}%`));
         }
-        return winner;
+        return best;
       }
     };
   }
@@ -1738,7 +1692,7 @@ import { execSync as execSync3 } from "child_process";
 import { basename } from "path";
 import DiffMatchPatch from "diff-match-patch";
 import { resolve as resolve3 } from "path";
-import pc5 from "picocolors";
+import pc4 from "picocolors";
 var HEAD_PATTERN, DIVIDER_PATTERN, UPDATED_PATTERN, UDIFF_PATTERN, UDIFF_HUNK_PATTERN, REASONING_TAGS, Agent;
 var init_agent = __esm({
   "src/agent/agent.ts"() {
@@ -1748,8 +1702,8 @@ var init_agent = __esm({
     init_discovery();
     init_tool();
     init_ExtensionManager();
-    init_quantum_memory();
-    init_quantum_reasoning();
+    init_memory();
+    init_reasoning();
     init_env();
     HEAD_PATTERN = /^<{5,9} SEARCH>?\s*$/;
     DIVIDER_PATTERN = /^={5,9}\s*$/;
@@ -1773,8 +1727,8 @@ var init_agent = __esm({
       mcpManager;
       discoveryModule;
       extensionManager;
-      quantumMemory;
-      quantumReasoning;
+      agenticMemory;
+      reasoningEngine;
       kernel;
       db;
       L1_TOKEN_LIMIT = 4e4;
@@ -1785,7 +1739,7 @@ var init_agent = __esm({
       // Cap recovery attempts to prevent token burning
       MONOLITH_BLUEPRINT = `
 1. SINGLE WRITER PHYSICS: All state mutations (DB/Swarm) MUST go through MeowKernel. No direct writes.
-2. QUANTUM PRESERVATION: Do NOT modify 'quantum_*.ts' files unless explicitly asked.
+2. AGENTIC MEMORY PRESERVATION: Do NOT modify 'agentic_*.ts' files unless explicitly asked.
 3. SERIALIZED EXECUTION: Favor simple synchronous/serial patterns. Avoid complex parallel async logic.
 4. ROT RESISTANCE: Prefer Vanilla JS/TS over external dependencies. Match existing surgical style.
   `.trim();
@@ -1803,14 +1757,14 @@ var init_agent = __esm({
         this.extensionManager = new ExtensionManager();
         this.kernel = config2.kernel;
         this.db = config2.db;
-        this.quantumReasoning = new QuantumReasoning();
-        this.quantumMemory = new QuantumMemory(config2.db, config2.kernel, this.quantumReasoning);
+        this.reasoningEngine = new ReasoningEngine();
+        this.agenticMemory = new AgenticMemory(config2.db, config2.kernel, this.reasoningEngine);
       }
       async chat(userInput, runTests = false, testCmd, onStatus) {
         this.messages.push({ role: "user", content: userInput });
         this.updateTokenEstimate();
         if (this.currentL1Tokens > this.L1_TOKEN_LIMIT || this.messages.length > 15) {
-          onStatus?.("\u269B\uFE0F  High-Water Mark: Offloading context to L3...");
+          onStatus?.("\u2192 [Memory] Offloading context to L3...");
           await this.compressAndOffload();
         }
         let lastError = null;
@@ -1858,11 +1812,11 @@ Please fix the code and try again.`
                     onStatus?.(`\u{1F527} [LINT-FIX LOOP] Error detected (${this.lintFixAttempts}/${this.LINT_FIX_LOOP_MAX}). Prompting fix...`);
                     continue;
                   } else if (errorDetected && this.lintFixAttempts >= this.LINT_FIX_LOOP_MAX) {
-                    console.log(pc5.yellow(`\u26A0\uFE0F [LINT-FIX LOOP] Max recovery attempts (${this.LINT_FIX_LOOP_MAX}) reached. Flagging for human review.`));
+                    console.log(pc4.yellow(`\u26A0\uFE0F [LINT-FIX LOOP] Max recovery attempts (${this.LINT_FIX_LOOP_MAX}) reached. Flagging for human review.`));
                     result += "\n\n[RECOVERY LOOP EXHAUSTED - Manual intervention required]";
                   }
                 }
-                await this.quantumMemory.store(
+                await this.agenticMemory.store(
                   `Tool [${toolName}] result for query [${userInput}]: ${result.substring(0, 500)}`,
                   this.mockEmbedding(userInput),
                   { tool: toolName, type: "tool_output" }
@@ -2252,12 +2206,12 @@ ${files}
         const lastUserMessage = this.messages.filter((m) => m.role === "user").pop();
         let relevantMemories = [];
         if (lastUserMessage && lastUserMessage.content.trim()) {
-          relevantMemories = await this.quantumMemory.recall(lastUserMessage.content, this.mockEmbedding(lastUserMessage.content));
+          relevantMemories = await this.agenticMemory.recall(lastUserMessage.content, this.mockEmbedding(lastUserMessage.content));
         }
         if (relevantMemories.length > 0) {
           prompt += `
 
-# RECALLED QUANTUM CONTEXT (Associative Knowledge):
+# RECALLED AGENTIC MEMORY (Associative Knowledge):
 `;
           prompt += relevantMemories.map((m) => `- ${m.content}`).join("\n");
           prompt += `
@@ -2627,7 +2581,7 @@ Respond with your fix using SEARCH/REPLACE blocks.`;
       }
       /**
        * Tiered Offloading: Moves older context from L1 (Hot) to L3 (Cold Storage)
-       * by summarizing it and archiving the raw content into Quantum Memory.
+       * by summarizing it and archiving the raw content into Agentic Memory.
        */
       async compressAndOffload() {
         const offloadCount = Math.floor(this.messages.length / 2);
@@ -2638,7 +2592,7 @@ Respond with your fix using SEARCH/REPLACE blocks.`;
 
 ${rawContent}`;
         const summary = await this.callLLM("You are a context compression engine.", [{ role: "user", content: anchorPrompt }]);
-        await this.quantumMemory.store(
+        await this.agenticMemory.store(
           `CONTEXT_ANCHOR: ${summary}`,
           this.mockEmbedding(summary),
           { type: "archived_context", original_length: rawContent.length }
@@ -3603,28 +3557,28 @@ var init_ResultAggregator = __esm({
 });
 
 // src/architect/Architect.ts
-import pc6 from "picocolors";
+import pc5 from "picocolors";
 var Architect;
 var init_Architect = __esm({
   "src/architect/Architect.ts"() {
     "use strict";
     init_TaskDecomposer();
     init_FileCoordinator();
-    init_quantum_reasoning();
+    init_reasoning();
     Architect = class {
       orchestrator;
       decomposer;
       coordinator;
-      quantumReasoning;
+      reasoningEngine;
       config;
       constructor(orchestrator) {
         this.orchestrator = orchestrator;
         this.decomposer = new TaskDecomposer(orchestrator["agent"]);
         this.coordinator = new FileCoordinator();
-        this.quantumReasoning = new QuantumReasoning();
+        this.reasoningEngine = new ReasoningEngine();
         this.config = {
           maxParallelWave: 4,
-          enableQuantumOptimization: true,
+          enableOptimization: true,
           enableImplicitParallel: true,
           taskTimeoutMs: 12e4
         };
@@ -3634,9 +3588,9 @@ var init_Architect = __esm({
        */
       async plan(brief, options) {
         const opts = { ...this.config, ...options };
-        console.log(pc6.cyan(`
+        console.log(pc5.cyan(`
 \u{1F3DB}\uFE0F [ARCHITECT] Planning for mission: ${brief.missionId}`));
-        console.log(pc6.dim(`    Intent: ${brief.intent} | Domain: ${brief.domain} | Complexity: ${brief.complexity}`));
+        console.log(pc5.dim(`    Intent: ${brief.intent} | Domain: ${brief.domain} | Complexity: ${brief.complexity}`));
         const context = {
           availableFiles: brief.targetFiles,
           existingSkills: [],
@@ -3646,13 +3600,13 @@ var init_Architect = __esm({
           maxSubtasks: opts.maxParallelWave * 2,
           enableImplicitParallel: opts.enableImplicitParallel
         });
-        console.log(pc6.dim(`    Decomposed into ${tasks.length} tasks`));
+        console.log(pc5.dim(`    Decomposed into ${tasks.length} tasks`));
         const conflicts = this.detectConflicts(tasks);
         if (conflicts.length > 0) {
-          console.log(pc6.yellow(`    \u26A0\uFE0F  File conflicts detected: ${conflicts.length}`));
+          console.log(pc5.yellow(`    \u26A0\uFE0F  File conflicts detected: ${conflicts.length}`));
         }
-        const parallelWaves = opts.enableQuantumOptimization ? await this.optimizeWithQuantum(tasks, opts) : this.computeSimpleWaves(tasks, opts);
-        console.log(pc6.dim(`    Scheduled in ${parallelWaves.length} parallel wave(s)`));
+        const parallelWaves = opts.enableOptimization ? await this.optimizeWithSolver(tasks, opts) : this.computeSimpleWaves(tasks, opts);
+        console.log(pc5.dim(`    Scheduled in ${parallelWaves.length} parallel wave(s)`));
         const lockedFiles = this.acquireLocks(tasks);
         const complexityScore = this.computeComplexityScore(tasks, brief);
         return {
@@ -3692,11 +3646,11 @@ var init_Architect = __esm({
        * Optimize task scheduling using QUBO-based parallelization.
        * Uses QAOA to minimize task entanglement and maximize parallelism.
        */
-      async optimizeWithQuantum(tasks, opts) {
+      async optimizeWithSolver(tasks, opts) {
         if (tasks.length <= 1) {
           return [tasks.map((t) => t.id)];
         }
-        console.log(pc6.dim("    \u269B\uFE0F  Running QAOA optimization..."));
+        console.log(pc5.dim("    \u2192  Running constraint optimization..."));
         const constraints = [
           {
             id: "DEPENDENCY_CONSTRAINT",
@@ -3739,12 +3693,12 @@ var init_Architect = __esm({
           }
         ];
         const assignments = this.generateWaveAssignments(tasks, opts.maxParallelWave);
-        const bestAssignment = await this.quantumReasoning.solve(
+        const bestAssignment = await this.reasoningEngine.solve(
           assignments,
           constraints,
-          (msg) => process.stdout.write(`\r      ${pc6.dim(msg)}`)
+          (msg) => process.stdout.write(`\r      ${pc5.dim(msg)}`)
         );
-        console.log(pc6.dim(""));
+        console.log(pc5.dim(""));
         if (bestAssignment) {
           return bestAssignment.waves;
         }
@@ -3774,7 +3728,7 @@ var init_Architect = __esm({
         return assignments;
       }
       /**
-       * Simple wave computation without quantum optimization.
+       * Simple sequential computation without optimization.
        * Groups tasks by dependency depth.
        */
       computeSimpleWaves(tasks, opts) {
@@ -4063,7 +4017,7 @@ var init_ExecutionMode = __esm({
 });
 
 // src/orchestrator/QualityConvergenceChecker.ts
-import * as pc7 from "picocolors";
+import * as pc6 from "picocolors";
 var DEFAULT_CONVERGENCE_CONFIG, QualityConvergenceChecker;
 var init_QualityConvergenceChecker = __esm({
   "src/orchestrator/QualityConvergenceChecker.ts"() {
@@ -4110,7 +4064,7 @@ var init_QualityConvergenceChecker = __esm({
             tokenEfficiency,
             stagnationCount: this.stagnationCount,
             iteration,
-            message: pc7.green(`All ${gatesTotal} quality gates passed \u2014 ready to ship`)
+            message: pc6.green(`All ${gatesTotal} quality gates passed \u2014 ready to ship`)
           };
         }
         if (totalTokens > this.config.tokenBudgetPerTask) {
@@ -4123,7 +4077,7 @@ var init_QualityConvergenceChecker = __esm({
             tokenEfficiency,
             stagnationCount: this.stagnationCount,
             iteration,
-            message: pc7.red(`Token budget exceeded: ${totalTokens} > ${this.config.tokenBudgetPerTask} \u2014 stopping`)
+            message: pc6.red(`Token budget exceeded: ${totalTokens} > ${this.config.tokenBudgetPerTask} \u2014 stopping`)
           };
         }
         if (qualityDelta < this.config.minQualityDelta) {
@@ -4138,7 +4092,7 @@ var init_QualityConvergenceChecker = __esm({
               tokenEfficiency,
               stagnationCount: this.stagnationCount,
               iteration,
-              message: pc7.yellow(
+              message: pc6.yellow(
                 `Quality stagnating: +${qualityDelta} pts for ${this.stagnationCount} consecutive iterations \u2014 stopping to preserve tokens`
               )
             };
@@ -4156,7 +4110,7 @@ var init_QualityConvergenceChecker = __esm({
             tokenEfficiency,
             stagnationCount: this.stagnationCount,
             iteration,
-            message: pc7.yellow(
+            message: pc6.yellow(
               `Diminishing returns: +${qualityDelta} pts but token efficiency ${tokenEfficiency.toFixed(3)} < ${this.config.minQualityPerToken} pts/1k tokens \u2014 stopping`
             )
           };
@@ -4170,7 +4124,7 @@ var init_QualityConvergenceChecker = __esm({
           tokenEfficiency,
           stagnationCount: this.stagnationCount,
           iteration,
-          message: pc7.cyan(
+          message: pc6.cyan(
             `Quality improving: +${qualityDelta} pts (${tokenEfficiency.toFixed(3)} pts/1k tokens), stagnation=${this.stagnationCount} \u2014 continuing`
           )
         };
@@ -4207,7 +4161,7 @@ var init_QualityConvergenceChecker = __esm({
 });
 
 // src/orchestrator/SelfReviewRunner.ts
-import pc8 from "picocolors";
+import pc7 from "picocolors";
 var DEFAULT_SELF_REVIEW_CONFIG, SelfReviewRunner;
 var init_SelfReviewRunner = __esm({
   "src/orchestrator/SelfReviewRunner.ts"() {
@@ -4243,14 +4197,14 @@ var init_SelfReviewRunner = __esm({
         let iteration = 0;
         let lastResult = null;
         let artifacts = [];
-        console.log(pc8.bold(pc8.cyan(`
+        console.log(pc7.bold(pc7.cyan(`
 \u{1F37D}\uFE0F  [SELF-REVIEW] Starting ${this.config.mode} execution for task: ${task.id}`)));
         if (this.config.mode === "audit_only" /* AUDIT_ONLY */) {
-          console.log(pc8.dim("[SELF-REVIEW] Audit-only mode \u2014 verifying without executing"));
+          console.log(pc7.dim("[SELF-REVIEW] Audit-only mode \u2014 verifying without executing"));
           return this.runAuditOnly(task);
         }
         if (this.config.mode === "parallel" /* PARALLEL */) {
-          console.log(pc8.dim("[SELF-REVIEW] Parallel mode \u2014 executing without self-review"));
+          console.log(pc7.dim("[SELF-REVIEW] Parallel mode \u2014 executing without self-review"));
           const result = await executorFn(task);
           return {
             passes: result.success,
@@ -4266,15 +4220,15 @@ var init_SelfReviewRunner = __esm({
         }
         while (iteration < this.config.maxIterations) {
           iteration++;
-          console.log(pc8.cyan(`
+          console.log(pc7.cyan(`
 \u{1F4E6} [ITERATION ${iteration}/${this.config.maxIterations}] Executing task...`));
           lastResult = await executorFn(task);
           if (!lastResult.success) {
-            console.log(pc8.red(`\u274C [ITERATION ${iteration}] Execution failed: ${lastResult.error}`));
+            console.log(pc7.red(`\u274C [ITERATION ${iteration}] Execution failed: ${lastResult.error}`));
             break;
           }
           artifacts = lastResult.artifacts || [];
-          console.log(pc8.cyan(`
+          console.log(pc7.cyan(`
 \u{1F50D} [ITERATION ${iteration}] Running self-review...`));
           const reviewContext = {
             taskId: task.id,
@@ -4286,15 +4240,15 @@ var init_SelfReviewRunner = __esm({
           const qualityScore = this.computeQualityScore(gateResults);
           const issues = gateResults.flatMap((g) => g.issues || []);
           const warnings = gateResults.flatMap((g) => g.warnings || []);
-          console.log(pc8.cyan(`
+          console.log(pc7.cyan(`
 \u{1F4CA} [ITERATION ${iteration}] Quality Score: ${qualityScore}% | Gates: ${gateResults.filter((g) => g.passed).length}/${gateResults.length}`));
           if (this.config.enableConvergenceCheck) {
             const tokensThisIteration = this.estimateTokens(lastResult);
             const gatesPassedCount = gateResults.filter((g) => g.passed).length;
             const decision = this.convergenceChecker.check(qualityScore, tokensThisIteration, gatesPassedCount, gateResults.length);
-            console.log(pc8.dim("   " + decision.message));
+            console.log(pc7.dim("   " + decision.message));
             if (!decision.shouldContinue) {
-              console.log(pc8.yellow("\n\u26A0\uFE0F  [ITERATION " + iteration + "] " + decision.reason.toUpperCase() + " \u2014 stopping quality loop"));
+              console.log(pc7.yellow("\n\u26A0\uFE0F  [ITERATION " + iteration + "] " + decision.reason.toUpperCase() + " \u2014 stopping quality loop"));
               return {
                 passes: false,
                 qualityScore,
@@ -4314,7 +4268,7 @@ var init_SelfReviewRunner = __esm({
             return gate?.blocking && !g.passed;
           });
           if (!blockingFailed && qualityScore >= this.config.minQualityScore) {
-            console.log(pc8.green(`
+            console.log(pc7.green(`
 \u2705 [ITERATION ${iteration}] Quality gates PASSED \u2014 ready to ship`));
             return {
               passes: true,
@@ -4329,12 +4283,12 @@ var init_SelfReviewRunner = __esm({
             };
           }
           if (iteration >= this.config.maxIterations) {
-            console.log(pc8.red(`
+            console.log(pc7.red(`
 \u{1F6AB} [ITERATION ${iteration}] Max iterations reached. Quality gates FAILED.`));
-            console.log(pc8.red(`   Issues: ${issues.join(", ") || "none"}`));
-            console.log(pc8.red(`   Score: ${qualityScore}% (min: ${this.config.minQualityScore}%)`));
+            console.log(pc7.red(`   Issues: ${issues.join(", ") || "none"}`));
+            console.log(pc7.red(`   Score: ${qualityScore}% (min: ${this.config.minQualityScore}%)`));
             if (this.config.allowHumanOverride) {
-              console.log(pc8.yellow(`
+              console.log(pc7.yellow(`
 \u26A0\uFE0F  [SELF-REVIEW] Prompting for human override...`));
             }
             return {
@@ -4349,10 +4303,10 @@ var init_SelfReviewRunner = __esm({
               timeSpentMs: Date.now() - startTime
             };
           }
-          console.log(pc8.yellow(`
+          console.log(pc7.yellow(`
 \u{1F527} [ITERATION ${iteration}] Quality gates FAILED \u2014 refining and retrying...`));
           if (issues.length > 0) {
-            console.log(pc8.dim(`   Issues to fix: ${issues.join("; ")}`));
+            console.log(pc7.dim(`   Issues to fix: ${issues.join("; ")}`));
           }
           await this.sleep(1e3);
         }
@@ -4375,19 +4329,19 @@ var init_SelfReviewRunner = __esm({
         const results = [];
         for (const gate of this.config.qualityGates) {
           try {
-            console.log(pc8.dim(`   Checking gate: ${gate.name}...`));
+            console.log(pc7.dim(`   Checking gate: ${gate.name}...`));
             const result = await gate.check(ctx);
             results.push(result);
             if (result.passed) {
-              console.log(pc8.green(`   \u2705 ${gate.name}: ${result.details}`));
+              console.log(pc7.green(`   \u2705 ${gate.name}: ${result.details}`));
             } else {
-              console.log(pc8.red(`   \u274C ${gate.name}: ${result.details}`));
+              console.log(pc7.red(`   \u274C ${gate.name}: ${result.details}`));
               if (result.issues) {
-                result.issues.forEach((issue) => console.log(pc8.red(`      - ${issue}`)));
+                result.issues.forEach((issue) => console.log(pc7.red(`      - ${issue}`)));
               }
             }
           } catch (error) {
-            console.log(pc8.red(`   \u274C ${gate.name}: Error \u2014 ${error.message}`));
+            console.log(pc7.red(`   \u274C ${gate.name}: Error \u2014 ${error.message}`));
             results.push({
               passed: false,
               details: `Gate error: ${error.message}`,
@@ -5529,7 +5483,7 @@ init_agent();
 init_Liaison();
 init_Orchestrator();
 import * as p from "@clack/prompts";
-import pc9 from "picocolors";
+import pc8 from "picocolors";
 function createRepl(agent) {
   let orchestrator = null;
   let liaison = null;
@@ -5561,19 +5515,19 @@ function createRepl(agent) {
   return {
     async start() {
       process.stdout.write("\x1Bc");
-      console.log(pc9.bold(pc9.cyan("MEOW")) + pc9.dim(" | ") + pc9.white("Layered Agency System"));
-      console.log(pc9.dim("L1: Liaison | L2: Architect | L3: Swarm | L4: Auditor\n"));
+      console.log(pc8.bold(pc8.cyan("MEOW")) + pc8.dim(" | ") + pc8.white("Layered Agency System"));
+      console.log(pc8.dim("L1: Liaison | L2: Architect | L3: Swarm | L4: Auditor\n"));
       liaison = new Liaison(agent);
       while (true) {
         const input = await p.text({
-          message: pc9.bold(pc9.cyan(">>")),
+          message: pc8.bold(pc8.cyan(">>")),
           placeholder: "",
           validate(value) {
             if (!value || value.length === 0) return "Please enter a message";
           }
         });
         if (p.isCancel(input)) {
-          console.log(pc9.cyan("\nGoodbye!"));
+          console.log(pc8.cyan("\nGoodbye!"));
           process.exit(0);
         }
         const text2 = input;
@@ -5583,31 +5537,31 @@ function createRepl(agent) {
           switch (cmd) {
             case "exit":
             case "quit":
-              console.log(pc9.cyan("Goodbye!"));
+              console.log(pc8.cyan("Goodbye!"));
               process.exit(0);
               break;
             case "clear":
               process.stdout.write("\x1Bc");
               agent.clearHistory();
-              console.log(pc9.bold(pc9.cyan("MEOW")) + pc9.dim(" | ") + pc9.white("Context Cleared\n"));
+              console.log(pc8.bold(pc8.cyan("MEOW")) + pc8.dim(" | ") + pc8.white("Context Cleared\n"));
               break;
             case "help":
-              console.log(pc9.bold("\nCommands:"));
-              console.log(pc9.cyan("  /add <file>    ") + pc9.dim("- Add file to context"));
-              console.log(pc9.cyan("  /drop <file>   ") + pc9.dim("- Remove file from context"));
-              console.log(pc9.cyan("  /files         ") + pc9.dim("- List files in context"));
-              console.log(pc9.cyan("  /clear         ") + pc9.dim("- Clear context and screen"));
-              console.log(pc9.cyan("  /parallel      ") + pc9.dim("- Toggle parallel orchestrator mode"));
-              console.log(pc9.cyan("  /status        ") + pc9.dim("- Show orchestrator status"));
-              console.log(pc9.cyan("  /exit          ") + pc9.dim("- Exit REPL\n"));
+              console.log(pc8.bold("\nCommands:"));
+              console.log(pc8.cyan("  /add <file>    ") + pc8.dim("- Add file to context"));
+              console.log(pc8.cyan("  /drop <file>   ") + pc8.dim("- Remove file from context"));
+              console.log(pc8.cyan("  /files         ") + pc8.dim("- List files in context"));
+              console.log(pc8.cyan("  /clear         ") + pc8.dim("- Clear context and screen"));
+              console.log(pc8.cyan("  /parallel      ") + pc8.dim("- Toggle parallel orchestrator mode"));
+              console.log(pc8.cyan("  /status        ") + pc8.dim("- Show orchestrator status"));
+              console.log(pc8.cyan("  /exit          ") + pc8.dim("- Exit REPL\n"));
               break;
             case "files":
               const files = agent.getFiles();
               if (files.length === 0) {
-                console.log(pc9.cyan("No files in context."));
+                console.log(pc8.cyan("No files in context."));
               } else {
-                console.log(pc9.bold("\nFiles in Context:"));
-                files.forEach((f) => console.log(pc9.dim(`  - ${f}`)));
+                console.log(pc8.bold("\nFiles in Context:"));
+                files.forEach((f) => console.log(pc8.dim(`  - ${f}`)));
                 console.log("");
               }
               break;
@@ -5615,27 +5569,27 @@ function createRepl(agent) {
               if (parallelMode) {
                 parallelMode = false;
                 orchestrator = null;
-                console.log(pc9.yellow("Parallel mode disabled [OFF]. Using sequential execution."));
+                console.log(pc8.yellow("Parallel mode disabled [OFF]. Using sequential execution."));
               } else {
                 parallelMode = true;
                 orchestrator = new Orchestrator(agent);
-                console.log(pc9.green("Parallel mode enabled [ON]. Use '/' delimited tasks for parallel execution."));
+                console.log(pc8.green("Parallel mode enabled [ON]. Use '/' delimited tasks for parallel execution."));
               }
               continue;
             case "status":
               if (orchestrator) {
                 const status = orchestrator.getStatus();
-                console.log(pc9.bold("\n## Orchestrator Status:"));
-                console.log(`  Queue: ${JSON.stringify(status.queue, null, 2).split("\n").map((l) => pc9.dim(l)).join("\n")}`);
-                console.log(pc9.dim(`  Workers: ${status.workers}`));
-                console.log(pc9.dim(`  Locked Files: ${status.lockedFiles}
+                console.log(pc8.bold("\n## Orchestrator Status:"));
+                console.log(`  Queue: ${JSON.stringify(status.queue, null, 2).split("\n").map((l) => pc8.dim(l)).join("\n")}`);
+                console.log(pc8.dim(`  Workers: ${status.workers}`));
+                console.log(pc8.dim(`  Locked Files: ${status.lockedFiles}
 `));
               } else {
-                console.log(pc9.dim("Orchestrator not initialized. Use /parallel to enable."));
+                console.log(pc8.dim("Orchestrator not initialized. Use /parallel to enable."));
               }
               continue;
             default:
-              console.log(pc9.red(`Unknown command: /${cmd}`));
+              console.log(pc8.red(`Unknown command: /${cmd}`));
           }
           continue;
         }
@@ -5644,7 +5598,7 @@ function createRepl(agent) {
         try {
           let response;
           if (parallelMode || hasExplicitTasks) {
-            s.message(pc9.dim("Initializing Architect (L2)..."));
+            s.message(pc8.dim("Initializing Architect (L2)..."));
             if (!orchestrator) {
               orchestrator = new Orchestrator(agent);
             }
@@ -5654,60 +5608,60 @@ function createRepl(agent) {
                 tasks: hasExplicitTasks ? text2 : void 0,
                 onStatus: (update) => {
                   if (update.progress) {
-                    s.message(pc9.dim(`${update.progress.label}: ${update.progress.current}/${update.progress.total}`));
+                    s.message(pc8.dim(`${update.progress.label}: ${update.progress.current}/${update.progress.total}`));
                   } else {
-                    s.message(pc9.dim(update.message));
+                    s.message(pc8.dim(update.message));
                   }
                 }
               }
             );
             response = result.summary;
           } else {
-            s.message(pc9.dim("L1: Parsing intent..."));
+            s.message(pc8.dim("L1: Parsing intent..."));
             const liaisonResponse = await liaison.chat(
               text2,
               // Stream callback - shows thoughts as they arrive
               (chunk) => {
                 if (!chunk.done && chunk.text) {
-                  process.stdout.write(pc9.dim(chunk.text));
+                  process.stdout.write(pc8.dim(chunk.text));
                 }
               },
               // Status callback - updates spinner message
               (status) => {
-                s.message(pc9.dim(status));
+                s.message(pc8.dim(status));
               }
             );
             response = liaisonResponse.text;
-            console.log(pc9.dim(`
+            console.log(pc8.dim(`
 [Intent: ${liaisonResponse.brief.intent}] [Domain: ${liaisonResponse.brief.domain}] [Complexity: ${liaisonResponse.brief.complexity}]`));
             if (liaisonResponse.brief.complexity > 60) {
-              s.message(pc9.dim("Complex request detected. Handing off to Architect (L2)..."));
+              s.message(pc8.dim("Complex request detected. Handing off to Architect (L2)..."));
               if (!orchestrator) {
                 orchestrator = new Orchestrator(agent);
               }
               const result = await orchestrator.execute(text2, {
                 onStatus: (update) => {
-                  s.message(pc9.dim(update.message));
+                  s.message(pc8.dim(update.message));
                 }
               });
               response = result.summary;
             }
           }
-          s.stop(pc9.dim("Done"));
+          s.stop(pc8.dim("Done"));
           console.log("");
           const termWidth = getTerminalWidth();
           const usableWidth = Math.max(termWidth - 6, 20);
           const dashLine = boxLine("\u2500", usableWidth);
-          const headerLine = pc9.bold(pc9.cyan("\u250C\u2500\u2500 MEOW \u2500" + boxLine("\u2500", usableWidth - 7)));
-          const footerLine = pc9.bold(pc9.cyan("\u2514" + dashLine + "\u2500\u2500\u2518"));
+          const headerLine = pc8.bold(pc8.cyan("\u250C\u2500\u2500 MEOW \u2500" + boxLine("\u2500", usableWidth - 7)));
+          const footerLine = pc8.bold(pc8.cyan("\u2514" + dashLine + "\u2500\u2500\u2518"));
           console.log(headerLine);
-          const coloredResponse = response.replace(/^# (.*)/gm, (_, m) => pc9.bold(pc9.cyan(m))).replace(/^## (.*)/gm, (_, m) => pc9.bold(pc9.white(m))).replace(/\*\*(.*?)\*\*/g, (_, m) => pc9.bold(pc9.white(m))).replace(/`(.*?)`/g, (_, m) => pc9.yellow(m));
-          console.log(coloredResponse.split("\n").map((line) => pc9.bold(pc9.cyan("\u2502  ")) + sanitizeForBox(line)).join("\n"));
+          const coloredResponse = response.replace(/^# (.*)/gm, (_, m) => pc8.bold(pc8.cyan(m))).replace(/^## (.*)/gm, (_, m) => pc8.bold(pc8.white(m))).replace(/\*\*(.*?)\*\*/g, (_, m) => pc8.bold(pc8.white(m))).replace(/`(.*?)`/g, (_, m) => pc8.yellow(m));
+          console.log(coloredResponse.split("\n").map((line) => pc8.bold(pc8.cyan("\u2502  ")) + sanitizeForBox(line)).join("\n"));
           console.log(footerLine);
           console.log("");
         } catch (err) {
           const errorMsg = String(err).length > 100 ? String(err).substring(0, 100) + "..." : String(err);
-          s.stop(pc9.red("Error: " + errorMsg));
+          s.stop(pc8.red("Error: " + errorMsg));
         }
       }
     }
@@ -5715,7 +5669,7 @@ function createRepl(agent) {
 }
 
 // src/kernel/kernel.ts
-import pc10 from "picocolors";
+import pc9 from "picocolors";
 import fs from "fs";
 import path from "path";
 var MeowKernel = class {
@@ -5751,7 +5705,7 @@ var MeowKernel = class {
     this.logDir = logDir;
     this.logFile = path.join(logDir, `meow-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
     this.logStream = fs.createWriteStream(this.logFile, { flags: "a" });
-    this.log(pc10.cyan("\u{1F680} Meow Kernel initialized"), "KERNEL");
+    this.log(pc9.cyan("\u{1F680} Meow Kernel initialized"), "KERNEL");
   }
   logDir = "";
   logFile = "";
@@ -5859,7 +5813,7 @@ var MeowKernel = class {
       [pid]
     );
     this.agentHeartbeats.delete(pid);
-    console.log(pc10.cyan(`\u{1F504} [WATCHDOG] Respawning agent for mission: ${mission.goal}`));
+    console.log(pc9.cyan(`\u{1F504} [WATCHDOG] Respawning agent for mission: ${mission.goal}`));
     const { spawn: spawn3 } = __require("child_process");
     const shell = process.platform === "win32";
     const isBun2 = typeof globalThis.Bun !== "undefined";
@@ -5878,7 +5832,7 @@ var MeowKernel = class {
       stdio: "inherit"
     }).pid;
     await this.registerMission(newPid, mission.agent_name, mission.goal);
-    console.log(pc10.green(`\u2705 [WATCHDOG] Respawned agent with new PID ${newPid}`));
+    console.log(pc9.green(`\u2705 [WATCHDOG] Respawned agent with new PID ${newPid}`));
     for (const cb of this.respawnCallbacks) {
       cb(pid, newPid);
     }
@@ -5943,7 +5897,7 @@ var MeowKernel = class {
     const entangled = this.monolithEntanglement.get(pid);
     if (entangled && (status === "completed" || status === "failed")) {
       entangled.forEach((partnerPid) => {
-        console.log(pc10.magenta(`
+        console.log(pc9.magenta(`
 \u{1F30C} [SPOOKY ACTION] Mission ${pid} collapsed to ${status}. Propagating interference to Partner ${partnerPid}...`));
         this.push({ type: "SET_STATE", key: `interference_${partnerPid}`, value: {
           sourcePid: pid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meow-swarm",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "meow -p: Autonomous multi-agent coding harness. Run coding agents in background, checkpoint state, TUI dashboard.",
   "main": "dist/index.js",
@@ -33,7 +33,6 @@
     "js-yaml": "4.1.1",
     "mathjs": "^15.2.0",
     "picocolors": "1.1.1",
-    "quantum-circuit": "^0.9.247",
     "sqlite-vec": "^0.1.9"
   },
   "devDependencies": {