codymaster 4.4.4 → 4.5.1

package/dist/token-budget.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultBudget = getDefaultBudget;
+exports.loadBudget = loadBudget;
+exports.checkBudget = checkBudget;
+exports.estimateTokens = estimateTokens;
+exports.generateBudgetReport = generateBudgetReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CM_DIR = '.cm';
+const BUDGET_FILE = 'token-budget.json';
+// ─── Default Budget ─────────────────────────────────────────────────────────
+function getDefaultBudget() {
+    return {
+        model_context_window: 200000,
+        allocations: {
+            system_prompt: 5000, // 2.5%
+            skill_index_L0: 2500, // 1.25%
+            skill_active_full: 5000, // 2.5%
+            memory_working: 500, // 0.25%
+            memory_learnings: 650, // 0.325%
+            codebase_skeleton: 1500, // 0.75%
+            context_retrieval: 10000, // 5%
+            conversation_history: 30000, // 15%
+            generation_budget: 144850, // 72.425%
+        },
+        enforcement: 'soft',
+    };
+}
+// ─── Load Budget ────────────────────────────────────────────────────────────
+function loadBudget(projectPath) {
+    const budgetPath = path_1.default.join(projectPath, CM_DIR, BUDGET_FILE);
+    if (!fs_1.default.existsSync(budgetPath)) {
+        return getDefaultBudget();
+    }
+    try {
+        const raw = fs_1.default.readFileSync(budgetPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (_a) {
+        return getDefaultBudget();
+    }
+}
+// ─── Check Budget ────────────────────────────────────────────────────────────
+function checkBudget(budget, category, tokenCount) {
+    const allocs = budget.allocations;
+    const allocated = allocs[category];
+    if (allocated === undefined) {
+        return {
+            allowed: false,
+            remaining: 0,
+            suggestion: `Unknown category "${category}". Valid: ${Object.keys(allocs).join(', ')}`,
+        };
+    }
+    const remaining = allocated - tokenCount;
+    const overBudget = remaining < 0;
+    if (!overBudget) {
+        return { allowed: true, remaining };
+    }
+    const suggestion = buildSuggestion(category, tokenCount, allocated);
+    if (budget.enforcement === 'hard') {
+        return { allowed: false, remaining, suggestion };
+    }
+    // Soft mode: allow but warn
+    return { allowed: true, remaining, suggestion };
+}
+function buildSuggestion(category, used, allocated) {
+    const over = used - allocated;
+    if (category === 'memory_learnings') {
+        return `memory_learnings over by ~${over} tokens. Switch to L0 index (cm://memory/learnings/L0) to reduce to ~100 tokens.`;
+    }
+    if (category === 'codebase_skeleton') {
+        return `codebase_skeleton over by ~${over} tokens. Use cm://resources/skeleton/L0 for module-level index (~500 tokens).`;
+    }
+    if (category === 'memory_working') {
+        return `memory_working over by ~${over} tokens. Read CONTINUITY abstract only (first 3 lines).`;
+    }
+    return `${category} over budget by ~${over} tokens. Consider using L0 index instead of full content.`;
+}
+// ─── Estimate Tokens ─────────────────────────────────────────────────────────
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+// ─── Budget Report ────────────────────────────────────────────────────────────
+function generateBudgetReport(budget) {
+    const total = budget.model_context_window;
+    const lines = [
+        `Token Budget Report (${total.toLocaleString()} context window, enforcement: ${budget.enforcement})`,
+        '─'.repeat(70),
+        `${'Category'.padEnd(25)} ${'Allocated'.padStart(10)} ${'% of CTX'.padStart(10)}`,
+        '─'.repeat(70),
+    ];
+    const allocs = budget.allocations;
+    for (const [cat, allocated] of Object.entries(allocs)) {
+        const pct = ((allocated / total) * 100).toFixed(2);
+        lines.push(`${cat.padEnd(25)} ${allocated.toLocaleString().padStart(10)} ${(pct + '%').padStart(10)}`);
+    }
+    const sum = Object.values(allocs).reduce((a, b) => a + b, 0);
+    lines.push('─'.repeat(70));
+    lines.push(`${'TOTAL'.padEnd(25)} ${sum.toLocaleString().padStart(10)} ${(((sum / total) * 100).toFixed(2) + '%').padStart(10)}`);
+    return lines.join('\n');
+}

package/dist/uri-resolver.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = resolve;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const context_db_1 = require("./context-db");
+const context_bus_1 = require("./context-bus");
+// ─── Main Resolver ───────────────────────────────────────────────────────────
+/**
+ * Resolve a cm:// URI to content at the requested depth.
+ *
+ * URI patterns:
+ *   cm://memory/working             → CONTINUITY.md abstract (L0) or full (L2)
+ *   cm://memory/learnings           → learnings index (L0) or all learnings (L2)
+ *   cm://memory/learnings/{id}      → specific learning by ID
+ *   cm://memory/decisions           → decisions index (L0) or all (L2)
+ *   cm://skills/{name}              → SKILL.md at depth
+ *   cm://skills/{name}/L0           → index entry only
+ *   cm://resources/skeleton         → skeleton-index.md (L0) or full (L2)
+ *   cm://resources/architecture     → architecture.mmd
+ *   cm://pipeline/current           → context bus state
+ */
+function resolve(uri, projectPath, depth = 'L1') {
+    if (!uri.startsWith('cm://')) {
+        return notFound(uri, depth, `URI must start with cm://`);
+    }
+    const rest = uri.slice('cm://'.length); // e.g. "memory/learnings/L005"
+    const parts = rest.split('/').filter(Boolean);
+    if (parts.length === 0) {
+        return notFound(uri, depth, 'Empty URI path');
+    }
+    const [ns, ...tail] = parts;
+    switch (ns) {
+        case 'memory': return resolveMemory(uri, tail, projectPath, depth);
+        case 'skills': return resolveSkill(uri, tail, projectPath, depth);
+        case 'resources': return resolveResource(uri, tail, projectPath, depth);
+        case 'pipeline': return resolvePipeline(uri, tail, projectPath, depth);
+        default:
+            return notFound(uri, depth, `Unknown namespace "${ns}". Valid: memory, skills, resources, pipeline`);
+    }
+}
+// ─── memory/* ────────────────────────────────────────────────────────────────
+function resolveMemory(uri, tail, projectPath, depth) {
+    const [resource, id] = tail;
+    switch (resource) {
+        case 'working': {
+            const contPath = path_1.default.join(projectPath, '.cm', 'CONTINUITY.md');
+            if (!fs_1.default.existsSync(contPath))
+                return notFound(uri, depth, 'CONTINUITY.md not found');
+            const full = fs_1.default.readFileSync(contPath, 'utf-8');
+            if (depth === 'L0' || depth === 'L1') {
+                // Return first 10 non-empty lines as abstract
+                const abstract = full.split('\n').filter(l => l.trim()).slice(0, 10).join('\n');
+                return found(uri, depth, abstract);
+            }
+            return found(uri, depth, full);
+        }
+        case 'learnings': {
+            if (id) {
+                // cm://memory/learnings/L005 — specific entry
+                const dbPath = (0, context_db_1.getDbPath)(projectPath);
+                const learning = (0, context_db_1.getLearningById)(dbPath, id);
+                if (!learning)
+                    return notFound(uri, depth, `Learning "${id}" not found`);
+                return found(uri, depth, formatLearning(learning));
+            }
+            if (depth === 'L0') {
+                // Return cached L0 index
+                const indexPath = path_1.default.join(projectPath, '.cm', 'learnings-index.md');
+                if (fs_1.default.existsSync(indexPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(indexPath, 'utf-8'));
+                }
+            }
+            // L1/L2: query all from SQLite
+            const dbPath = (0, context_db_1.getDbPath)(projectPath);
+            const learnings = (0, context_db_1.queryLearnings)(dbPath, '', undefined, 50);
+            if (learnings.length === 0) {
+                // Fallback to JSON file
+                const jsonPath = path_1.default.join(projectPath, '.cm', 'memory', 'learnings.json');
+                if (fs_1.default.existsSync(jsonPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(jsonPath, 'utf-8'));
+                }
+                return found(uri, depth, '[]');
+            }
+            return found(uri, depth, JSON.stringify(learnings, null, 2));
+        }
+        case 'decisions': {
+            if (depth === 'L0') {
+                // Short list of decision IDs + 1-line summary
+                const dbPath = (0, context_db_1.getDbPath)(projectPath);
+                const decisions = (0, context_db_1.queryDecisions)(dbPath, '', 20);
+                const lines = ['# Decisions Index', ''];
+                for (const d of decisions) {
+                    lines.push(`- ${d.id}: ${d.decision.slice(0, 80)}`);
+                }
+                return found(uri, depth, lines.join('\n'));
+            }
+            const dbPath = (0, context_db_1.getDbPath)(projectPath);
+            const decisions = (0, context_db_1.queryDecisions)(dbPath, '', 50);
+            if (decisions.length === 0) {
+                const jsonPath = path_1.default.join(projectPath, '.cm', 'memory', 'decisions.json');
+                if (fs_1.default.existsSync(jsonPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(jsonPath, 'utf-8'));
+                }
+                return found(uri, depth, '[]');
+            }
+            return found(uri, depth, JSON.stringify(decisions, null, 2));
+        }
+        default:
+            return notFound(uri, depth, `Unknown memory resource "${resource}". Valid: working, learnings, decisions`);
+    }
+}
+// ─── skills/* ────────────────────────────────────────────────────────────────
+function resolveSkill(uri, tail, projectPath, depth) {
+    const [skillName, depthOverride] = tail;
+    if (!skillName)
+        return notFound(uri, depth, 'Skill name required: cm://skills/{name}');
+    const effectiveDepth = depthOverride || depth;
+    // Look in project skills/ dir, then global ~/.claude/skills/
+    const candidates = [
+        path_1.default.join(projectPath, 'skills', skillName, 'SKILL.md'),
+        path_1.default.join(projectPath, '.claude', 'skills', skillName, 'SKILL.md'),
+        path_1.default.join(process.env.HOME || '', '.claude', 'skills', skillName, 'SKILL.md'),
+    ];
+    const skillPath = candidates.find(p => fs_1.default.existsSync(p));
+    if (!skillPath)
+        return notFound(uri, depth, `Skill "${skillName}" not found`);
+    const full = fs_1.default.readFileSync(skillPath, 'utf-8');
+    if (effectiveDepth === 'L0') {
+        // Front matter + description only (~50 tokens)
+        const lines = full.split('\n');
+        const summary = lines.slice(0, 10).join('\n');
+        return found(uri, effectiveDepth, summary);
+    }
+    if (effectiveDepth === 'L1') {
+        // First 40 lines (~600 tokens)
+        return found(uri, effectiveDepth, full.split('\n').slice(0, 40).join('\n'));
+    }
+    return found(uri, effectiveDepth, full);
+}
+// ─── resources/* ─────────────────────────────────────────────────────────────
+function resolveResource(uri, tail, projectPath, depth) {
+    const [resource] = tail;
+    switch (resource) {
+        case 'skeleton': {
+            if (depth === 'L0' || depth === 'L1') {
+                const indexPath = path_1.default.join(projectPath, '.cm', 'skeleton-index.md');
+                if (fs_1.default.existsSync(indexPath)) {
+                    return found(uri, depth, fs_1.default.readFileSync(indexPath, 'utf-8'));
+                }
+            }
+            const fullPath = path_1.default.join(projectPath, '.cm', 'skeleton.md');
+            if (!fs_1.default.existsSync(fullPath))
+                return notFound(uri, depth, 'skeleton.md not found — run: cm continuity index');
+            return found(uri, depth, fs_1.default.readFileSync(fullPath, 'utf-8'));
+        }
+        case 'architecture': {
+            const mmdPath = path_1.default.join(projectPath, '.cm', 'architecture.mmd');
+            if (!fs_1.default.existsSync(mmdPath))
+                return notFound(uri, depth, 'architecture.mmd not found');
+            return found(uri, depth, fs_1.default.readFileSync(mmdPath, 'utf-8'));
+        }
+        default:
+            return notFound(uri, depth, `Unknown resource "${resource}". Valid: skeleton, architecture`);
+    }
+}
+// ─── pipeline/* ──────────────────────────────────────────────────────────────
+function resolvePipeline(uri, tail, projectPath, depth) {
+    const [sub] = tail;
+    if (!sub || sub === 'current') {
+        const bus = (0, context_bus_1.readBus)(projectPath);
+        if (!bus)
+            return notFound(uri, depth, 'No active context bus. Start a chain first.');
+        if (depth === 'L0') {
+            const summary = `Pipeline: ${bus.pipeline} | Step: ${bus.current_step} | Steps done: ${Object.keys(bus.shared_context).length}`;
+            return found(uri, depth, summary);
+        }
+        return found(uri, depth, JSON.stringify(bus, null, 2));
+    }
+    return notFound(uri, depth, `Unknown pipeline resource "${sub}"`);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function found(uri, depth, content) {
+    return { uri, depth, content, tokenEstimate: Math.ceil(content.length / 4), found: true };
+}
+function notFound(uri, depth, reason) {
+    const content = `# Not Found\n\nURI: ${uri}\nReason: ${reason}`;
+    return { uri, depth, content, tokenEstimate: Math.ceil(content.length / 4), found: false };
+}
+function formatLearning(l) {
+    var _a, _b;
+    if (!l)
+        return '';
+    return [
+        `### ${l.id}: ${l.what_failed}`,
+        `- **Why:** ${l.why_failed}`,
+        `- **Fix:** ${l.how_to_prevent}`,
+        `- **Scope:** ${(_a = l.scope) !== null && _a !== void 0 ? _a : 'global'} | **TTL:** ${(_b = l.ttl) !== null && _b !== void 0 ? _b : 60}d`,
+    ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codymaster",
-  "version": "4.4.4",
+  "version": "4.5.1",
   "description": "68+ Skills. Ship 10x faster. AI-powered coding skill kit for Claude, Cursor, Gemini & more.",
   "main": "dist/index.js",
   "repository": {
@@ -59,12 +59,15 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
+    "better-sqlite3": "^12.8.0",
     "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
     "commander": "^14.0.3",
     "express": "^5.2.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "@types/prompts": "^2.4.9",
@@ -73,5 +76,8 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
+  },
+  "overrides": {
+    "path-to-regexp": "^8.4.0"
   }
 }

package/skills/_shared/helpers.md

@@ -7,20 +7,56 @@
 
 ## #Load-Working-Memory
 
-Before executing any significant action, ALWAYS:
-
-1. **Read** `.cm/CONTINUITY.md` → understand current state, Active Goal, Next Actions
-2. **Run Memory Audit** — decay check + conflict detection + integrity scan (see `cm-continuity`)
-3. **Scope-filter learnings** — if working on module X:
-   - Load from `.cm/learnings.json` ONLY where `scope == "global"` or `scope == "module:X"`
-   - **NEVER** load `status = "invalidated"` (proven wrong — skip entirely)
-   - **CAUTION** with `status = "corrected"` (was wrong, verify before applying)
-   - **TRUST** high `reinforceCount` + recent `lastRelevant`
-   - **VERIFY** `reinforceCount = 0` + old `lastRelevant` (low confidence)
-   - SKIP learnings for other modules (reduces noise + saves tokens)
-4. **Check** "Next Actions" — pick up where you left off
-
-> **Token savings:** Scope-filtered reading loads ~250 tokens instead of ~2,500.
+Before executing any significant action, ALWAYS load context in this order (cheapest → richest):
+
+### Step 1 — Check context bus (free, ~50 tokens)
+```
+Read .cm/context-bus.json (or: cm continuity bus)
+→ If active pipeline found:
+    - Note current_step and pipeline name
+    - Read shared_context to see what upstream skills already produced
+    - SKIP re-doing any work already recorded in shared_context
+→ If no bus: fresh session, proceed normally
+```
+
+### Step 2 — Load L0 indexes first (~600 tokens total)
+```
+Read .cm/learnings-index.md   (~100 tokens) — IDs + 1-line summaries
+Read .cm/skeleton-index.md    (~500 tokens) — modules, entry points, config files
+
+→ If a specific learning ID looks relevant → resolve cm://memory/learnings/{id} for full detail
+→ If a specific module looks relevant   → resolve cm://resources/skeleton at L2 for full detail
+→ Otherwise: L0 is sufficient — DO NOT load full files
+```
+
+### Step 3 — Scope-filter learnings (only if L0 flags relevant entries)
+```
+Query: cm_query(scope="learnings", query="{current module or error type}", limit=5)
+   OR read .cm/memory/learnings.json filtered to scope == "global" | "module:X"
+
+Rules:
+  NEVER  load status = "invalidated"   (proven wrong)
+  CAUTION status = "corrected"         (verify before applying)
+  TRUST  high reinforceCount + recent lastRelevant
+  SKIP   learnings for other modules (noise + wasted tokens)
+```
+
+### Step 4 — Check working memory
+```
+Read .cm/CONTINUITY.md → Active Goal, Next Actions, current phase
+Run Memory Audit (decay + conflict detection) — see cm-continuity
+```
+
+### Step 5 — Token budget check (before injecting large context)
+```
+cm continuity budget  (or: loadBudget + checkBudget in code)
+→ If category is over soft limit → use L0/L1 depth instead of L2
+→ Never inject full skeleton (20KB) when skeleton-index.md (~2KB) suffices
+```
+
+> **Token savings v5:** Full cold load ~3,200 tokens → Smart Spine load ~700 tokens (78% reduction).
+> L0 indexes + context bus + scope filter make this possible.
+> Only escalate to L2 when L0/L1 explicitly flag the need.
 
 ---
 

package/skills/cm-autopilot/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: cm-autopilot
+description: Easy-to-use conversational CLI (Claude Code style) for non-technical users to spawn parallel AI tasks supervised by a visual web dashboard.
+---
+
+# CM AutoPilot CLI — Conversational Task Supervisor
+
+> **Just talk to it. It plans, splits, and watches parallel tasks for you.**
+
+## What it does
+- Provides a conversational CLI interface using `rich` and `prompt_toolkit`.
+- Translates user intent into multiple parallel tasks.
+- Integrates with `cm-content-factory`'s Dashboard (`localhost:5050`) for a visual way to track multi-threading.
+- Allows non-technical users to utilize the Cody Master skill set effortlessly.
+
+## Requirements
+- Python 3.9+
+- `rich`
+- `prompt_toolkit`
+
+## How to run
+
+1. Launch the conversational CLI:
+   ```bash
+   python3 skills/cm-autopilot/scripts/autopilot.py
+   ```
+2. The CLI will ask what you want to do. Explain your complex request (e.g., "Dịch 10 bài báo sang tiếng anh", "Research 5 competitors").
+3. The AutoPilot will generate tasks and push them into the Queue.
+4. AutoPilot will automatically start the visual Dashboard at `http://localhost:5050` so you can watch your jobs execute in parallel.

package/skills/cm-autopilot/scripts/autopilot.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+AutoPilot CLI — Conversational Interface for Cody Master Skills
+
+This is a Claude Code-style interactive CLI. It talks to the user,
+understands their goals, creates a plan, and then parallelizes
+tasks into the Agent Dispatcher (queue) while launching the Visual
+Dashboard for easy tracking.
+"""
+
+import sys
+import time
+import os
+import subprocess
+import threading
+from pathlib import Path
+
+# Add cm-content-factory to sys.path to reuse the dispatcher and state manager
+SKILLS_DIR = Path(__file__).resolve().parent.parent.parent
+CF_SCRIPTS = SKILLS_DIR / "cm-content-factory" / "scripts"
+sys.path.append(str(CF_SCRIPTS))
+
+try:
+    from agent_dispatcher import AgentDispatcher
+    from state_manager import StateManager
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.prompt import Prompt
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+except ImportError:
+    print("Please install requirements: pip install rich prompt_toolkit")
+    sys.exit(1)
+
+console = Console()
+project_root = Path(os.getcwd()).resolve()
+
+dispatcher = AgentDispatcher(str(project_root))
+state_mgr = StateManager(str(project_root))
+
+DASHBOARD_PROCESS = None
+
+def start_dashboard():
+    """Starts the cm-content-factory dashboard server in the background."""
+    global DASHBOARD_PROCESS
+    dashboard_script = CF_SCRIPTS / "dashboard_server.py"
+    if dashboard_script.exists():
+        DASHBOARD_PROCESS = subprocess.Popen(
+            [sys.executable, str(dashboard_script), "--port", "5050", "--no-open"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        return True
+    return False
+
+def show_welcome():
+    console.print(Panel.fit(
+        "[bold cyan]🚀 Welcome to Cody Master AutoPilot[/bold cyan]\n"
+        "[dim]Your conversational AI orchestrator.[/dim]\n\n"
+        "Tell me what you want to achieve, and I will plan, split,\n"
+        "and execute parallel tasks for you. No technical skills required.",
+        title="AutoPilot v1.0", border_style="cyan"
+    ))
+
+def mock_llm_task_parser(prompt: str) -> list:
+    """
+    Mock parser that simulates an LLM breaking down a user request 
+    into parallel tasks based on keywords.
+    """
+    tasks = []
+    lower_prompt = prompt.lower()
+    
+    if "dịch" in lower_prompt or "translate" in lower_prompt:
+        # Example: Dịch 5 bài báo
+        count = 5
+        for w in lower_prompt.split():
+            if w.isdigit():
+                count = int(w)
+                break
+        for i in range(1, count + 1):
+            tasks.append({
+                "id": f"translate-{int(time.time()*100)}-{i}",
+                "type": "translate",
+                "meta": {"file": f"article_{i}.txt", "target_lang": "en"}
+            })
+    elif "research" in lower_prompt or "tìm hiểu" in lower_prompt:
+        tasks.append({"id": f"res-1", "type": "research", "meta": {"topic": "Market Trends"}})
+        tasks.append({"id": f"res-2", "type": "research", "meta": {"topic": "Competitors"}})
+        tasks.append({"id": f"res-3", "type": "research", "meta": {"topic": "Keywords"}})
+    else:
+        # Generic fallback
+        tasks.append({"id": f"task-1", "type": "general", "meta": {"instruction": prompt}})
+        tasks.append({"id": f"task-2", "type": "general", "meta": {"instruction": "Review output"}})
+        
+    return tasks
+
+def background_worker(worker_id: str):
+    """A simple worker loop simulating parallel execution of tasks."""
+    state_mgr.register_agent(worker_id, "autopilot_worker")
+    while True:
+        task = dispatcher.claim_next(worker_id)
+        if not task:
+            time.sleep(2)
+            continue
+        
+        # Log active phase
+        phase_map = {"translate": "write", "research": "extract", "general": "plan"}
+        phase = phase_map.get(task["type"], "write")
+        state_mgr.update_phase(phase, "running", progress=0.1)
+        state_mgr.add_task(task["id"], "running", task["meta"])
+        
+        # Simulate work
+        dispatcher.heartbeat(worker_id, task["id"])
+        time.sleep(3) # Heavy work
+        
+        state_mgr.add_task(task["id"], "done", task["meta"])
+        dispatcher.complete(task["id"], worker_id, {"result": "success"})
+        state_mgr.log_event("info", f"[{worker_id}] Completed task: {task['id']}")
+        
+        # Check if phase done
+        q = dispatcher.get_queue()
+        if q["queued"] == 0 and q["claimed"] == 0:
+            state_mgr.update_phase(phase, "done", progress=1.0)
+
+def main_loop():
+    # Reset queue and state for fresh start
+    dispatcher.reset()
+    state_mgr.reset()
+    
+    # Start dashboard
+    if start_dashboard():
+        state_mgr.log_event("info", "Dashboard Server started on port 5050")
+    
+    # Start background workers (simulating multiple parallel agents)
+    for i in range(3):
+        t = threading.Thread(target=background_worker, args=(f"worker-{i+1}",), daemon=True)
+        t.start()
+        
+    try:
+        while True:
+            user_input = Prompt.ask("\n[bold green]You[/bold green]")
+            if user_input.lower() in ("exit", "quit", "q"):
+                break
+            
+            if not user_input.strip():
+                continue
+                
+            with Progress(
+                SpinnerColumn(), 
+                TextColumn("[progress.description]{task.description}"), 
+                transient=True
+            ) as progress:
+                progress.add_task("Thinking and Planning...", total=None)
+                time.sleep(1.5) # Simulate LLM thinking
+                tasks = mock_llm_task_parser(user_input)
+                
+            console.print(f"[bold blue]AutoPilot:[/bold blue] I've analyzed your request and created [bold]{len(tasks)}[/bold] parallel tasks.")
+            
+            # Queue them
+            dispatcher.enqueue_batch(tasks)
+            for t in tasks:
+                state_mgr.add_task(t["id"], "queued", t["meta"])
+                
+            console.print("[dim]Tasks have been dispatched to the worker queue.[/dim]")
+            console.print(f"👉 [bold magenta]Watch live progress at: http://localhost:5050[/bold magenta]")
+            
+            # Simple live status wait
+            with Progress() as pb:
+                task_pb = pb.add_task("Executing Pipeline...", total=len(tasks))
+                while True:
+                    q = dispatcher.get_queue()
+                    completed = q["done"] + q["failed"]
+                    pb.update(task_pb, completed=completed)
+                    
+                    if completed >= len(tasks):
+                        break
+                    time.sleep(1)
+                    
+            console.print("\n[bold green]✅ All tasks completed successfully![/bold green]")
+            
+    except KeyboardInterrupt:
+        console.print("\n[dim]Shutting down...[/dim]")
+        
+    finally:
+        if DASHBOARD_PROCESS:
+            DASHBOARD_PROCESS.terminate()
+
+if __name__ == "__main__":
+    show_welcome()
+    main_loop()