agdi 3.4.5 → 4.0.1

package/dist/index.js

@@ -11,8 +11,8 @@ import "./chunk-4VNS5WPM.js";
 
 // src/index.ts
 import { Command } from "commander";
-import chalk21 from "chalk";
-import ora7 from "ora";
+import chalk27 from "chalk";
+import ora12 from "ora";
 
 // src/core/llm/index.ts
 var PuterProvider = class {
@@ -2229,6 +2229,14 @@ var BaseAgent = class {
 ${context}`;
       }
     }
+    if (this.context?.architectureRules && !prompt.includes("# Project Architecture Rules")) {
+      fullPrompt += `
+
+# Project Architecture Rules
+CRITICAL: You MUST strictly adhere to the following architectural rules when generating code. Violations will be rejected.
+
+${this.context.architectureRules}`;
+    }
     const response = await Promise.race([
       this.llm.generate(fullPrompt, this.getSystemPrompt()),
       new Promise(
@@ -3483,6 +3491,8 @@ URL: ${deployResult.url || "See dashboard"}`,
 import * as fs7 from "fs/promises";
 import * as path7 from "path";
 import crypto2 from "crypto";
+import { exec as execCb } from "child_process";
+import { promisify as promisify3 } from "util";
 
 // src/context/repository-indexer.ts
 import fs6 from "fs/promises";
@@ -3527,80 +3537,80 @@ var TypeScriptParser = class extends CodeParser {
       const dependencies = /* @__PURE__ */ new Set();
       traverse(ast, {
         // Functions
-        FunctionDeclaration(path15) {
-          if (path15.node.id) {
+        FunctionDeclaration(path20) {
+          if (path20.node.id) {
             symbols.push({
-              name: path15.node.id.name,
+              name: path20.node.id.name,
               type: "function",
-              line: path15.node.loc?.start.line || 0,
-              endLine: path15.node.loc?.end.line,
-              signature: generateSignature(path15.node),
-              isExported: isExported(path15),
-              docstring: extractDocstring(path15.node)
+              line: path20.node.loc?.start.line || 0,
+              endLine: path20.node.loc?.end.line,
+              signature: generateSignature(path20.node),
+              isExported: isExported(path20),
+              docstring: extractDocstring(path20.node)
             });
           }
         },
         // Classes
-        ClassDeclaration(path15) {
-          if (path15.node.id) {
+        ClassDeclaration(path20) {
+          if (path20.node.id) {
             symbols.push({
-              name: path15.node.id.name,
+              name: path20.node.id.name,
               type: "class",
-              line: path15.node.loc?.start.line || 0,
-              endLine: path15.node.loc?.end.line,
-              signature: `class ${path15.node.id.name}`,
-              isExported: isExported(path15),
-              docstring: extractDocstring(path15.node)
+              line: path20.node.loc?.start.line || 0,
+              endLine: path20.node.loc?.end.line,
+              signature: `class ${path20.node.id.name}`,
+              isExported: isExported(path20),
+              docstring: extractDocstring(path20.node)
             });
           }
         },
         // Variables (const/let/var)
-        VariableDeclaration(path15) {
-          path15.node.declarations.forEach((decl) => {
+        VariableDeclaration(path20) {
+          path20.node.declarations.forEach((decl) => {
             if (t.isIdentifier(decl.id)) {
               symbols.push({
                 name: decl.id.name,
                 type: "variable",
-                line: path15.node.loc?.start.line || 0,
-                endLine: path15.node.loc?.end.line,
-                signature: `${path15.node.kind} ${decl.id.name}`,
-                isExported: isExported(path15),
-                docstring: extractDocstring(path15.node)
+                line: path20.node.loc?.start.line || 0,
+                endLine: path20.node.loc?.end.line,
+                signature: `${path20.node.kind} ${decl.id.name}`,
+                isExported: isExported(path20),
+                docstring: extractDocstring(path20.node)
               });
             }
           });
         },
         // Interfaces
-        TSInterfaceDeclaration(path15) {
+        TSInterfaceDeclaration(path20) {
           symbols.push({
-            name: path15.node.id.name,
+            name: path20.node.id.name,
             type: "interface",
-            line: path15.node.loc?.start.line || 0,
-            endLine: path15.node.loc?.end.line,
-            signature: `interface ${path15.node.id.name}`,
-            isExported: isExported(path15),
-            docstring: extractDocstring(path15.node)
+            line: path20.node.loc?.start.line || 0,
+            endLine: path20.node.loc?.end.line,
+            signature: `interface ${path20.node.id.name}`,
+            isExported: isExported(path20),
+            docstring: extractDocstring(path20.node)
           });
         },
         // Types
-        TSTypeAliasDeclaration(path15) {
+        TSTypeAliasDeclaration(path20) {
           symbols.push({
-            name: path15.node.id.name,
+            name: path20.node.id.name,
             type: "type",
-            line: path15.node.loc?.start.line || 0,
-            endLine: path15.node.loc?.end.line,
-            signature: `type ${path15.node.id.name}`,
-            isExported: isExported(path15),
-            docstring: extractDocstring(path15.node)
+            line: path20.node.loc?.start.line || 0,
+            endLine: path20.node.loc?.end.line,
+            signature: `type ${path20.node.id.name}`,
+            isExported: isExported(path20),
+            docstring: extractDocstring(path20.node)
           });
         },
         // Imports
-        ImportDeclaration(path15) {
-          const source = path15.node.source.value;
+        ImportDeclaration(path20) {
+          const source = path20.node.source.value;
           dependencies.add(source);
           const names = [];
           let isDefault = false;
-          path15.node.specifiers.forEach((specifier) => {
+          path20.node.specifiers.forEach((specifier) => {
             if (t.isImportDefaultSpecifier(specifier)) {
               isDefault = true;
               names.push(specifier.local.name);
@@ -3618,34 +3628,34 @@ var TypeScriptParser = class extends CodeParser {
             source,
             names,
             isDefault,
-            line: path15.node.loc?.start.line || 0
+            line: path20.node.loc?.start.line || 0
           });
         },
         // Exports
-        ExportNamedDeclaration(path15) {
-          if (path15.node.declaration) {
+        ExportNamedDeclaration(path20) {
+          if (path20.node.declaration) {
           } else {
-            path15.node.specifiers.forEach((specifier) => {
+            path20.node.specifiers.forEach((specifier) => {
               exports.push({
                 name: specifier.exported.name,
                 type: "named",
-                line: path15.node.loc?.start.line || 0
+                line: path20.node.loc?.start.line || 0
               });
             });
           }
-          if (path15.node.source) {
-            dependencies.add(path15.node.source.value);
+          if (path20.node.source) {
+            dependencies.add(path20.node.source.value);
           }
         },
-        ExportDefaultDeclaration(path15) {
+        ExportDefaultDeclaration(path20) {
           let name = "default";
-          if (path15.node.declaration && path15.node.declaration.id) {
-            name = path15.node.declaration.id.name;
+          if (path20.node.declaration && path20.node.declaration.id) {
+            name = path20.node.declaration.id.name;
           }
           exports.push({
             name,
             type: "default",
-            line: path15.node.loc?.start.line || 0
+            line: path20.node.loc?.start.line || 0
           });
         }
       });
@@ -3682,8 +3692,8 @@ var TypeScriptParser = class extends CodeParser {
     return ["ts", "tsx", "js", "jsx", "mjs", "cjs"];
   }
 };
-function isExported(path15) {
-  return t.isExportDeclaration(path15.parent) || t.isExportNamedDeclaration(path15.parent) || t.isExportDefaultDeclaration(path15.parent);
+function isExported(path20) {
+  return t.isExportDeclaration(path20.parent) || t.isExportNamedDeclaration(path20.parent) || t.isExportDefaultDeclaration(path20.parent);
 }
 function extractDocstring(node) {
   if (node.leadingComments && node.leadingComments.length > 0) {
@@ -3784,24 +3794,24 @@ var DependencyGraph = class {
     const cycles = [];
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const path15 = [];
+    const path20 = [];
     const dfs = (file) => {
       visited.add(file);
       recursionStack.add(file);
-      path15.push(file);
+      path20.push(file);
       const node = this.nodes.get(file);
       if (node) {
         for (const dep of node.imports) {
           if (!visited.has(dep)) {
             dfs(dep);
           } else if (recursionStack.has(dep)) {
-            const cycleStart = path15.indexOf(dep);
-            const cycle = path15.slice(cycleStart);
+            const cycleStart = path20.indexOf(dep);
+            const cycle = path20.slice(cycleStart);
             cycles.push([...cycle, dep]);
           }
         }
       }
-      path15.pop();
+      path20.pop();
       recursionStack.delete(file);
     };
     for (const file of this.nodes.keys()) {
@@ -3845,8 +3855,8 @@ var DependencyGraph = class {
   /**
    * Normalize path (remove .., etc.)
    */
-  normalizePath(path15) {
-    const parts = path15.split("/");
+  normalizePath(path20) {
+    const parts = path20.split("/");
     const result = [];
     for (const part of parts) {
       if (part === "..") {
@@ -4057,22 +4067,22 @@ var VectorStore = class {
   /**
    * Get stored hash for a file
    */
-  async getFileHash(path15) {
+  async getFileHash(path20) {
     await this.initialize();
     if (!this.db) return null;
-    const row = this.db.prepare("SELECT hash FROM indexed_files WHERE path = ?").get(path15);
+    const row = this.db.prepare("SELECT hash FROM indexed_files WHERE path = ?").get(path20);
     return row ? row.hash : null;
   }
   /**
    * Set/Update hash for a file
    */
-  async setFileHash(path15, hash) {
+  async setFileHash(path20, hash) {
     await this.initialize();
     if (!this.db) return;
     this.db.prepare(`
             INSERT OR REPLACE INTO indexed_files (path, hash, last_indexed)
             VALUES (?, ?, ?)
-        `).run(path15, hash, Date.now());
+        `).run(path20, hash, Date.now());
   }
   /**
    * Add embeddings to store
@@ -4363,8 +4373,8 @@ var RepositoryIndexer = class {
     for (const file of files) {
       try {
         const content = await fs6.readFile(file, "utf-8");
-        const crypto3 = await import("crypto");
-        const hash = crypto3.createHash("md5").update(content).digest("hex");
+        const crypto4 = await import("crypto");
+        const hash = crypto4.createHash("md5").update(content).digest("hex");
         const existingHash = await this.store.getFileHash(file);
         if (existingHash === hash) {
           skipped++;
@@ -4498,6 +4508,7 @@ ${symbol.docstring || ""}`);
 };
 
 // src/agents/core/squad-orchestrator.ts
+import * as readline from "readline";
 var SquadOrchestrator = class {
   manager;
   frontend;
@@ -4524,6 +4535,7 @@ var SquadOrchestrator = class {
       maxRetries: 3,
       parallel: true,
       autoDeploy: false,
+      breakpoints: false,
       ...config
     };
     const agentOptions = { verbose: this.config.verbose };
@@ -4546,135 +4558,143 @@ var SquadOrchestrator = class {
     this.log("\u{1F680} Agdi Squad Activated!", "header");
     this.log(`Goal: "${userPrompt}"`, "info");
     try {
-      this.log("\u{1F4CB} Phase 1: Planning", "phase");
-      const memoryContext = await this.retrieveRepositoryContext(userPrompt);
-      const userPromptWithMemory = memoryContext ? `${userPrompt}
+      const didStash = await this.stashUserChanges();
+      try {
+        this.log("\u{1F4CB} Phase 1: Planning", "phase");
+        const memoryContext = await this.retrieveRepositoryContext(userPrompt);
+        const userPromptWithMemory = memoryContext ? `${userPrompt}
 
 ${memoryContext}` : userPrompt;
-      const projectSpec = await this.manager.analyzeRequest(userPromptWithMemory);
-      this.tasks = this.manager.generateTasks(projectSpec);
-      this.context = {
-        projectSpec,
-        workspaceRoot: this.config.workspaceRoot,
-        tasks: this.tasks,
-        sharedMemory: /* @__PURE__ */ new Map([["repo_context", memoryContext]])
-      };
-      this.manager.setContext(this.context);
-      this.frontend.setContext(this.context);
-      this.backend.setContext(this.context);
-      this.qa.setContext(this.context);
-      this.devops.setContext(this.context);
-      this.log(`Created ${this.tasks.length} tasks`, "success");
-      this.log("\u26A1 Phase 2: Execution & Auto-Repair", "phase");
-      let attempts = 0;
-      let healthy = false;
-      while (attempts < this.config.maxRetries && !healthy) {
-        attempts++;
-        this.log(`
+        const projectSpec = await this.manager.analyzeRequest(userPromptWithMemory);
+        this.tasks = this.manager.generateTasks(projectSpec);
+        this.context = {
+          projectSpec,
+          workspaceRoot: this.config.workspaceRoot,
+          tasks: this.tasks,
+          sharedMemory: /* @__PURE__ */ new Map([["repo_context", memoryContext]]),
+          architectureRules: await this.readArchitectureRules()
+        };
+        this.manager.setContext(this.context);
+        this.frontend.setContext(this.context);
+        this.backend.setContext(this.context);
+        this.qa.setContext(this.context);
+        this.devops.setContext(this.context);
+        this.log(`Created ${this.tasks.length} tasks`, "success");
+        this.log("\u26A1 Phase 2: Execution & Auto-Repair", "phase");
+        let attempts = 0;
+        let healthy = false;
+        while (attempts < this.config.maxRetries && !healthy) {
+          attempts++;
+          this.log(`
 \u{1F504} Cycle ${attempts}/${this.config.maxRetries}`, "phase");
-        await this.executeTasks(filesCreated, filesModified, tasksSummary, errors);
-        this.log("\u{1F575}\uFE0F  QA Check", "task");
-        let qaTask = this.tasks.find((t2) => t2.assignee === "qa" && !this.completedTasks.has(t2.id));
-        if (!qaTask) {
-          qaTask = {
-            id: `qa-${attempts}`,
-            title: `Quality Assurance Cycle ${attempts}`,
-            description: "Review codebase for errors, missing features, and type safety.",
-            assignee: "qa",
-            dependencies: [],
-            priority: "high",
-            state: "pending",
-            createdAt: Date.now(),
-            retryCount: 0
-          };
-        }
-        const qaResult = await this.executeTask(qaTask);
-        tasksSummary.push({
-          id: qaTask.id,
-          title: qaTask.title,
-          assignee: qaTask.assignee,
-          status: qaResult.success ? "completed" : "failed",
-          duration: 0
-          // Placeholder
-        });
-        if (qaResult.files) {
-          await this.writeFiles(qaResult.files, filesCreated, filesModified);
-        }
-        if (qaResult.success) {
-          this.log("\u2728 QA Passed - Codebase is healthy", "success");
-          healthy = true;
-        } else {
-          this.log(`\u26A0\uFE0F  QA Found Issues: ${qaResult.errors?.length || 0} errors`, "warn");
-          if (qaResult.errors) {
-            qaResult.errors.forEach((e) => this.log(`  - ${e}`, "error"));
-          }
-          if (attempts < this.config.maxRetries) {
-            this.log("\u{1F6E0}\uFE0F  Generating Fix Plan...", "info");
-            const fixPrompt = `QA found these issues:
-${qaResult.errors?.join("\n")}
-
-Create specific tasks to fix these errors.`;
-            const fixTask = {
-              id: `fix-${attempts}`,
-              title: `Fix Issues from Cycle ${attempts}`,
-              description: `Fix the following errors:
-${qaResult.errors?.join("\n")}`,
-              assignee: "frontend",
-              // Defaulting to frontend for now, ideal would be to detect
+          await this.executeTasks(filesCreated, filesModified, tasksSummary, errors);
+          this.log("\u{1F575}\uFE0F  QA Check", "task");
+          let qaTask = this.tasks.find((t2) => t2.assignee === "qa" && !this.completedTasks.has(t2.id));
+          if (!qaTask) {
+            qaTask = {
+              id: `qa-${attempts}`,
+              title: `Quality Assurance Cycle ${attempts}`,
+              description: "Review codebase for errors, missing features, and type safety.",
+              assignee: "qa",
               dependencies: [],
-              priority: "critical",
+              priority: "high",
               state: "pending",
               createdAt: Date.now(),
               retryCount: 0
             };
-            this.tasks.push(fixTask);
-            this.log(`  + Added repair task: ${fixTask.title}`, "info");
-          }
-        }
-      }
-      if (!healthy) {
-        this.log("\u26A0\uFE0F  Max retries reached. Proceeding with best-effort.", "warn");
-      } else {
-        this.log("\u2705 Codebase is stable.", "success");
-      }
-      let deploymentUrl;
-      if (healthy && this.config.autoDeploy) {
-        this.log("\u{1F680} Phase 4: Deployment", "phase");
-        const devopsTask = this.tasks.find((t2) => t2.assignee === "devops");
-        if (devopsTask) {
-          const deployResult = await this.executeTask(devopsTask);
-          if (deployResult.success) {
-            const urlMatch = deployResult.content.match(/https:\/\/[^\s]+/);
-            deploymentUrl = urlMatch ? urlMatch[0] : void 0;
           }
+          const qaResult = await this.executeTask(qaTask);
           tasksSummary.push({
-            id: devopsTask.id,
-            title: devopsTask.title,
-            assignee: devopsTask.assignee,
-            status: deployResult.success ? "completed" : "failed",
-            duration: Date.now() - startTime
+            id: qaTask.id,
+            title: qaTask.title,
+            assignee: qaTask.assignee,
+            status: qaResult.success ? "completed" : "failed",
+            duration: 0
+            // Placeholder
           });
+          if (qaResult.files) {
+            await this.writeFiles(qaResult.files, filesCreated, filesModified);
+          }
+          if (qaResult.success) {
+            this.log("\u2728 QA Passed - Codebase is healthy", "success");
+            healthy = true;
+          } else {
+            this.log(`\u26A0\uFE0F  QA Found Issues: ${qaResult.errors?.length || 0} errors`, "warn");
+            if (qaResult.errors) {
+              qaResult.errors.forEach((e) => this.log(`  - ${e}`, "error"));
+            }
+            if (attempts < this.config.maxRetries) {
+              this.log("\u{1F6E0}\uFE0F  Generating Fix Plan...", "info");
+              const fixPrompt = `QA found these issues:
+${qaResult.errors?.join("\n")}
+
+Create specific tasks to fix these errors.`;
+              const fixTask = {
+                id: `fix-${attempts}`,
+                title: `Fix Issues from Cycle ${attempts}`,
+                description: `Fix the following errors:
+${qaResult.errors?.join("\n")}`,
+                assignee: "frontend",
+                // Defaulting to frontend for now, ideal would be to detect
+                dependencies: [],
+                priority: "critical",
+                state: "pending",
+                createdAt: Date.now(),
+                retryCount: 0
+              };
+              this.tasks.push(fixTask);
+              this.log(`  + Added repair task: ${fixTask.title}`, "info");
+            }
+          }
+        }
+        if (!healthy) {
+          this.log("\u26A0\uFE0F  Max retries reached. Proceeding with best-effort.", "warn");
+        } else {
+          this.log("\u2705 Codebase is stable.", "success");
+        }
+        let deploymentUrl;
+        if (healthy && this.config.autoDeploy) {
+          this.log("\u{1F680} Phase 4: Deployment", "phase");
+          const devopsTask = this.tasks.find((t2) => t2.assignee === "devops");
+          if (devopsTask) {
+            const deployResult = await this.executeTask(devopsTask);
+            if (deployResult.success) {
+              const urlMatch = deployResult.content.match(/https:\/\/[^\s]+/);
+              deploymentUrl = urlMatch ? urlMatch[0] : void 0;
+            }
+            tasksSummary.push({
+              id: devopsTask.id,
+              title: devopsTask.title,
+              assignee: devopsTask.assignee,
+              status: deployResult.success ? "completed" : "failed",
+              duration: Date.now() - startTime
+            });
+          }
+        }
+        const duration = Date.now() - startTime;
+        this.log("\u{1F389} Squad Mission Complete!", "header");
+        this.log(`Duration: ${(duration / 1e3).toFixed(1)}s`, "info");
+        this.log(`Files created: ${filesCreated.length}`, "info");
+        if (deploymentUrl) {
+          this.log(`Live URL: ${deploymentUrl}`, "success");
+        }
+        const result = {
+          success: errors.length === 0,
+          projectSpec,
+          filesCreated,
+          filesModified,
+          deploymentUrl,
+          duration,
+          tasksSummary,
+          errors
+        };
+        await this.finalizeRun(result);
+        return result;
+      } finally {
+        if (didStash) {
+          await this.popUserStash();
         }
       }
-      const duration = Date.now() - startTime;
-      this.log("\u{1F389} Squad Mission Complete!", "header");
-      this.log(`Duration: ${(duration / 1e3).toFixed(1)}s`, "info");
-      this.log(`Files created: ${filesCreated.length}`, "info");
-      if (deploymentUrl) {
-        this.log(`Live URL: ${deploymentUrl}`, "success");
-      }
-      const result = {
-        success: errors.length === 0,
-        projectSpec,
-        filesCreated,
-        filesModified,
-        deploymentUrl,
-        duration,
-        tasksSummary,
-        errors
-      };
-      await this.finalizeRun(result);
-      return result;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       this.log(`Mission failed: ${errorMsg}`, "error");
@@ -4714,7 +4734,10 @@ ${qaResult.errors?.join("\n")}`,
       const result = await this.executeTask(task);
       if (result.files) {
         await this.writeFiles(result.files, filesCreated, filesModified);
+        const writtenPaths = result.files.map((f) => f.path);
+        await this.commitTaskChanges(task, writtenPaths);
       }
+      await this.waitForBreakpoint(task, result);
       this.completedTasks.set(task.id, result);
       tasksSummary.push({
         id: task.id,
@@ -5110,6 +5133,221 @@ ${qaResult.errors?.join("\n")}`,
     });
     return diffPayload;
   }
+  // ==================== ARCHITECTURE ENFORCEMENT ====================
+  /**
+   * Read project architecture rules from ARCHITECTURE.md or .agdi/architecture.md.
+   * Returns the file contents if found, or undefined if no architecture file exists.
+   */
+  async readArchitectureRules() {
+    const candidates = [
+      path7.join(this.config.workspaceRoot, "ARCHITECTURE.md"),
+      path7.join(this.config.workspaceRoot, ".agdi", "architecture.md")
+    ];
+    for (const candidate of candidates) {
+      try {
+        const content = await fs7.readFile(candidate, "utf-8");
+        if (content.trim().length > 0) {
+          this.log(`\u{1F4D0} Loaded architecture rules from ${path7.relative(this.config.workspaceRoot, candidate)}`, "success");
+          await this.appendTrace("architecture_rules_loaded", {
+            source: path7.relative(this.config.workspaceRoot, candidate),
+            length: content.length
+          });
+          return content;
+        }
+      } catch {
+      }
+    }
+    this.log("No ARCHITECTURE.md found \u2014 agents will use default patterns.", "info");
+    return void 0;
+  }
+  // ==================== GIT STASH SAFETY ====================
+  /**
+   * Stash any uncommitted user changes before squad execution.
+   * This prevents the micro-commit feature from accidentally
+   * including user's staged/unstaged work in agent commits.
+   * Returns true if a stash was created.
+   */
+  async stashUserChanges() {
+    const execAsync7 = promisify3(execCb);
+    try {
+      const { stdout: status } = await execAsync7("git status --porcelain", {
+        cwd: this.config.workspaceRoot
+      });
+      if (!status.trim()) {
+        return false;
+      }
+      const stashMsg = `agdi-squad-${this.runId}`;
+      await execAsync7(`git stash push --include-untracked -m "${stashMsg}"`, {
+        cwd: this.config.workspaceRoot
+      });
+      this.log(`\u{1F4E6} Stashed ${status.trim().split("\\n").length} uncommitted change(s) for safety`, "info");
+      await this.appendTrace("stash_created", { message: stashMsg, changes: status.trim().split("\\n").length });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Pop the user's stashed changes after squad execution completes.
+   */
+  async popUserStash() {
+    const execAsync7 = promisify3(execCb);
+    try {
+      const stashMsg = `agdi-squad-${this.runId}`;
+      const { stdout: stashList } = await execAsync7("git stash list", {
+        cwd: this.config.workspaceRoot
+      });
+      const lines = stashList.trim().split("\\n");
+      const ourStash = lines.findIndex((l) => l.includes(stashMsg));
+      if (ourStash >= 0) {
+        await execAsync7(`git stash pop stash@{${ourStash}}`, {
+          cwd: this.config.workspaceRoot
+        });
+        this.log("\u{1F4E6} Restored your stashed changes.", "success");
+        await this.appendTrace("stash_restored", { stashIndex: ourStash });
+      }
+    } catch {
+      this.log("\u26A0 Could not restore stashed changes. Run `git stash pop` manually.", "warn");
+    }
+  }
+  // ==================== REVERSIBLE MICRO-COMMITS ====================
+  /**
+   * Atomically commit files generated by a single task.
+   * This creates a granular git history that allows developers to
+   * easily `git revert` any specific AI agent misstep.
+   *
+   * Failures are non-fatal — if git is unavailable or the workspace
+   * is not a repository, the build continues normally.
+   */
+  async commitTaskChanges(task, filePaths) {
+    if (filePaths.length === 0) return;
+    const execAsync7 = promisify3(execCb);
+    const cwd = this.config.workspaceRoot;
+    try {
+      await execAsync7("git rev-parse --is-inside-work-tree", { cwd });
+      const relativePaths = filePaths.map((fp) => {
+        const abs = path7.resolve(cwd, fp);
+        return path7.relative(cwd, abs);
+      });
+      const BATCH_SIZE = 50;
+      for (let i = 0; i < relativePaths.length; i += BATCH_SIZE) {
+        const batch = relativePaths.slice(i, i + BATCH_SIZE);
+        const escaped = batch.map((p) => `"${p.replace(/"/g, '\\"')}"`).join(" ");
+        await execAsync7(`git add ${escaped}`, { cwd });
+      }
+      const { stdout: staged } = await execAsync7("git diff --cached --name-only", { cwd });
+      if (!staged.trim()) {
+        this.log("No staged changes \u2014 skipping micro-commit", "info");
+        return;
+      }
+      const scope = task.assignee;
+      const subject = task.title.length > 72 ? task.title.substring(0, 69) + "..." : task.title;
+      const commitMsg = `feat(${scope}): ${subject}`;
+      const commitBody = [
+        "Auto-generated by Agdi Squad (Reversible Micro-Commit)",
+        "",
+        `Task ID : ${task.id}`,
+        `Agent   : ${task.assignee}`,
+        `Priority: ${task.priority}`,
+        `Run ID  : ${this.runId}`
+      ].join("\n");
+      await execAsync7(
+        `git commit -m "${commitMsg.replace(/"/g, '\\"')}" -m "${commitBody.replace(/"/g, '\\"')}"`,
+        { cwd }
+      );
+      this.log(`\u{1F4CC} Micro-commit: ${commitMsg}`, "success");
+      await this.appendTrace("micro_commit", {
+        taskId: task.id,
+        message: commitMsg,
+        files: relativePaths
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.log(`Micro-commit skipped: ${msg.split("\n")[0]}`, "warn");
+    }
+  }
+  // ==================== AI BREAKPOINTS ====================
+  /**
+   * Pause execution after a task completes so the developer can
+   * review generated files before the next agent takes over.
+   *
+   * Actions:
+   *   Enter   → continue to the next task
+   *   'skip'  → disable breakpoints for the remainder of the run
+   *   'abort' → halt the entire squad pipeline immediately
+   */
+  async waitForBreakpoint(task, result) {
+    if (!this.config.breakpoints) return;
+    const { emitAgentEvent: emitAgentEvent2 } = await import("./event-bus-MO5SFUME.js");
+    emitAgentEvent2({
+      type: "breakpoint",
+      agentName: task.assignee,
+      role: task.assignee,
+      message: `Breakpoint hit after task: ${task.title}`,
+      metadata: {
+        taskId: task.id,
+        files: result.files?.map((f) => f.path) ?? [],
+        success: result.success
+      }
+    });
+    console.log("");
+    console.log(chalk11.cyan.bold(`\u23F8  AI Breakpoint \u2014 Task Complete`));
+    console.log(chalk11.gray(`   Agent   : ${task.assignee}`));
+    console.log(chalk11.gray(`   Task    : ${task.title}`));
+    console.log(chalk11.gray(`   Status  : ${result.success ? chalk11.green("\u2713 success") : chalk11.red("\u2717 failed")}`));
+    if (result.files && result.files.length > 0) {
+      console.log(chalk11.gray(`   Files (${result.files.length}):`));
+      result.files.slice(0, 8).forEach((f) => {
+        console.log(chalk11.gray(`     \u2022 ${f.path}`));
+      });
+      if (result.files.length > 8) {
+        console.log(chalk11.gray(`     ... and ${result.files.length - 8} more`));
+      }
+    }
+    console.log("");
+    console.log(chalk11.yellow("   \u25B8 Press Enter to continue"));
+    console.log(chalk11.yellow('   \u25B8 Type "skip" to disable breakpoints for this run'));
+    console.log(chalk11.yellow('   \u25B8 Type "abort" to stop the squad'));
+    console.log("");
+    const answer = await this.promptUser("  \u23F8 ");
+    if (answer.trim().toLowerCase() === "skip") {
+      this.config.breakpoints = false;
+      this.log("Breakpoints disabled for the rest of this run.", "info");
+    } else if (answer.trim().toLowerCase() === "abort") {
+      this.log("Pipeline aborted by developer at breakpoint.", "error");
+      throw new Error("Pipeline aborted by developer at breakpoint");
+    }
+    emitAgentEvent2({
+      type: "breakpoint_resume",
+      agentName: task.assignee,
+      role: task.assignee,
+      message: `Breakpoint resumed after task: ${task.title}`
+    });
+    await this.appendTrace("breakpoint", {
+      taskId: task.id,
+      action: answer.trim().toLowerCase() || "continue"
+    });
+  }
+  /**
+   * Prompt the user for a single line of input via stdin.
+   * If stdin is not a TTY (e.g., running in CI), auto-continues.
+   */
+  promptUser(prompt) {
+    if (!process.stdin.isTTY) {
+      this.log("Non-interactive environment detected \u2014 auto-continuing breakpoint.", "info");
+      return Promise.resolve("");
+    }
+    return new Promise((resolve3) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question(prompt, (answer) => {
+        rl.close();
+        resolve3(answer);
+      });
+    });
+  }
   /**
    * Styled console logging
    */
@@ -5168,7 +5406,8 @@ Constraints: Build a production SaaS using Next.js App Router, Prisma, Postgres,
   const config = {
     workspaceRoot: options.output || process.cwd(),
     verbose: options.verbose ?? true,
-    autoDeploy: options.deploy ?? false
+    autoDeploy: options.deploy ?? false,
+    breakpoints: options.breakpoints ?? false
   };
   const spinner = ora4("Assembling the squad...").start();
   const orchestrator = new SquadOrchestrator(llm, config);
@@ -5236,8 +5475,8 @@ function parseGitHubUrl(url) {
   if (!cleanUrl.startsWith("github.com/")) {
     throw new Error("Invalid GitHub URL. Please use format: https://github.com/owner/repo");
   }
-  const path15 = cleanUrl.replace("github.com/", "");
-  const parts = path15.split("/");
+  const path20 = cleanUrl.replace("github.com/", "");
+  const parts = path20.split("/");
   if (parts.length < 2) {
     throw new Error("Invalid GitHub URL. Could not extract owner/repo.");
   }
@@ -5645,115 +5884,1393 @@ async function runReplayCommand(runId, llm, options = {}) {
   }
 }
 
-// src/commands/features.ts
+// src/commands/audit.ts
 import chalk16 from "chalk";
 import ora6 from "ora";
-import fsExtra from "fs-extra";
-import { resolve as resolve2, join as join6 } from "path";
-var DIRECTORY_COPY_TARGETS = [
-  { source: "skills", target: "skills" },
-  { source: "extensions", target: "extensions" },
-  { source: "src/routing", target: "src/routing" },
-  { source: "src/pairing", target: "src/pairing" },
-  { source: "src/channels/plugins", target: "src/channels/plugins" },
-  { source: "src/channels/allowlists", target: "src/channels/allowlists" }
-];
-var FILE_COPY_TARGETS = [
-  { source: "src/channels/allowlist-match.ts", target: "src/channels/allowlist-match.ts" },
-  { source: "src/channels/channel-config.ts", target: "src/channels/channel-config.ts" }
-];
-var ALL_DIRECTORY_COPY_TARGETS = [
-  { source: "dist", target: "dist" },
-  { source: "skills", target: "skills" },
-  { source: "extensions", target: "extensions" },
-  { source: "src", target: "src" },
-  { source: "scripts", target: "scripts" },
-  { source: "docs", target: "docs" },
-  { source: "test", target: "test" },
-  { source: "apps", target: "apps" },
-  { source: "assets", target: "assets" },
-  { source: "prisma", target: "prisma" },
-  { source: "ui", target: "ui" },
-  { source: "vendor", target: "vendor" },
-  { source: "website", target: "website" }
-];
-var ALL_FILE_COPY_TARGETS = [
-  { source: "agdi.mjs", target: "agdi.mjs" },
-  { source: "README.md", target: "README.md" },
-  { source: "LICENSE", target: "LICENSE" },
-  { source: "CHANGELOG.md", target: "CHANGELOG.md" },
-  { source: "SECURITY.md", target: "SECURITY.md" },
-  { source: "CONTRIBUTING.md", target: "CONTRIBUTING.md" },
-  { source: "pnpm-lock.yaml", target: "pnpm-lock.yaml" },
-  { source: "pnpm-workspace.yaml", target: "pnpm-workspace.yaml" },
-  { source: "tsconfig.json", target: "tsconfig.json" },
-  { source: "tsconfig.test.json", target: "tsconfig.test.json" },
-  { source: "vitest.config.ts", target: "vitest.config.ts" },
-  { source: "vitest.e2e.config.ts", target: "vitest.e2e.config.ts" },
-  { source: "vitest.unit.config.ts", target: "vitest.unit.config.ts" }
-];
-var EXCLUDED_PATH_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"]);
-var EXCLUDED_ALL_PATH_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", ".next"]);
-function shouldIncludePath(filePath) {
-  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-  const segments = normalized.split("/");
-  return !segments.some((segment) => EXCLUDED_PATH_SEGMENTS.has(segment));
+import * as fs10 from "fs/promises";
+import * as path10 from "path";
+var RULES = {
+  // React-specific
+  MISSING_ERROR_BOUNDARY: "react/error-boundary",
+  MISSING_KEY_PROP: "react/key-prop",
+  // Accessibility
+  MISSING_ALT_TEXT: "a11y/alt-text",
+  MISSING_ARIA_LABEL: "a11y/aria-label",
+  MISSING_FORM_LABEL: "a11y/form-label",
+  // Security
+  HARDCODED_SECRET: "security/hardcoded-secret",
+  CONSOLE_LOG_IN_PROD: "security/console-log",
+  // SEO
+  MISSING_META_DESCRIPTION: "seo/meta-description",
+  MISSING_TITLE_TAG: "seo/title-tag",
+  // Quality
+  TODO_IN_CODE: "quality/todo",
+  EMPTY_CATCH: "quality/empty-catch",
+  NO_TESTS: "quality/no-tests"
+};
+async function scanDirectory(dir) {
+  const results = [];
+  const ignore = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "runs", "coverage"]);
+  const extensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".html", ".css"]);
+  const walk = async (current) => {
+    let entries;
+    try {
+      entries = await fs10.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (ignore.has(entry.name)) continue;
+      const fullPath = path10.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile() && extensions.has(path10.extname(entry.name))) {
+        results.push(fullPath);
+      }
+    }
+  };
+  await walk(dir);
+  return results;
 }
-async function copyTargetPaths(sourceRepo, targetRoot) {
-  for (const target of DIRECTORY_COPY_TARGETS) {
-    const sourcePath = join6(sourceRepo, target.source);
-    const targetPath = join6(targetRoot, target.target);
-    if (!await fsExtra.pathExists(sourcePath)) {
-      continue;
+function analyzeFile(filePath, content, strict) {
+  const issues = [];
+  const lines = content.split("\n");
+  const ext = path10.extname(filePath);
+  const isReact = ext === ".tsx" || ext === ".jsx";
+  const isHTML = ext === ".html";
+  const relPath = filePath;
+  if (isReact) {
+    if (strict && content.includes("export default") && !content.includes("ErrorBoundary") && !content.includes("error-boundary")) {
+      issues.push({
+        file: relPath,
+        severity: "warning",
+        rule: RULES.MISSING_ERROR_BOUNDARY,
+        message: "Component lacks an ErrorBoundary wrapper. Unhandled errors will crash the entire app."
+      });
     }
-    await fsExtra.ensureDir(targetPath);
-    await fsExtra.copy(sourcePath, targetPath, {
-      overwrite: true,
-      filter: (source) => shouldIncludePath(source)
+    lines.forEach((line, idx) => {
+      if (line.includes(".map(") && !content.includes("key={") && !content.includes("key=")) {
+        issues.push({
+          file: relPath,
+          line: idx + 1,
+          severity: "warning",
+          rule: RULES.MISSING_KEY_PROP,
+          message: "Array .map() rendered in JSX may be missing a `key` prop."
+        });
+      }
     });
   }
-  for (const target of FILE_COPY_TARGETS) {
-    const sourcePath = join6(sourceRepo, target.source);
-    const targetPath = join6(targetRoot, target.target);
-    if (!await fsExtra.pathExists(sourcePath)) {
-      continue;
+  if (isReact || isHTML) {
+    lines.forEach((line, idx) => {
+      if (/<img\s/.test(line) && !/alt\s*=/.test(line)) {
+        issues.push({
+          file: relPath,
+          line: idx + 1,
+          severity: strict ? "error" : "warning",
+          rule: RULES.MISSING_ALT_TEXT,
+          message: "<img> element missing `alt` attribute (WCAG 1.1.1)."
+        });
+      }
+      if (/<button\s/.test(line) && !/aria-label/.test(line) && />(\s*)<\/button>/.test(line)) {
+        issues.push({
+          file: relPath,
+          line: idx + 1,
+          severity: "warning",
+          rule: RULES.MISSING_ARIA_LABEL,
+          message: "<button> with no visible text needs `aria-label` (WCAG 4.1.2)."
+        });
+      }
+      if (/<input\s/.test(line) && !/aria-label/.test(line) && !/id\s*=/.test(line)) {
+        issues.push({
+          file: relPath,
+          line: idx + 1,
+          severity: strict ? "error" : "warning",
+          rule: RULES.MISSING_FORM_LABEL,
+          message: "<input> missing `aria-label` or associated <label> (WCAG 1.3.1)."
+        });
+      }
+    });
+  }
+  lines.forEach((line, idx) => {
+    const secretPatterns = [
+      /(?:api[_-]?key|secret|password|token)\s*[:=]\s*['"][A-Za-z0-9_-]{20,}['"]/i,
+      /sk-[a-zA-Z0-9]{20,}/,
+      /ghp_[a-zA-Z0-9]{20,}/
+    ];
+    for (const pattern of secretPatterns) {
+      if (pattern.test(line)) {
+        issues.push({
+          file: relPath,
+          line: idx + 1,
+          severity: "error",
+          rule: RULES.HARDCODED_SECRET,
+          message: "Possible hardcoded secret detected. Use environment variables instead."
+        });
+        break;
+      }
+    }
+    if (strict && /console\.(log|debug|info)\s*\(/.test(line) && !filePath.includes("test") && !filePath.includes("spec")) {
+      issues.push({
+        file: relPath,
+        line: idx + 1,
+        severity: "info",
+        rule: RULES.CONSOLE_LOG_IN_PROD,
+        message: "console.log found in production code. Consider removing or using a logger."
+      });
+    }
+  });
+  lines.forEach((line, idx) => {
+    if (/\/\/\s*(TODO|FIXME|HACK|XXX)/i.test(line)) {
+      issues.push({
+        file: relPath,
+        line: idx + 1,
+        severity: "info",
+        rule: RULES.TODO_IN_CODE,
+        message: `Unresolved ${line.match(/(TODO|FIXME|HACK|XXX)/i)?.[0]} comment.`
+      });
+    }
+    if (/catch\s*\([^)]*\)\s*\{\s*\}/.test(line)) {
+      issues.push({
+        file: relPath,
+        line: idx + 1,
+        severity: "warning",
+        rule: RULES.EMPTY_CATCH,
+        message: "Empty catch block swallows errors. At minimum, log the error."
+      });
+    }
+  });
+  if (isHTML) {
+    if (!content.includes("<title")) {
+      issues.push({
+        file: relPath,
+        severity: "warning",
+        rule: RULES.MISSING_TITLE_TAG,
+        message: "HTML page missing <title> tag."
+      });
+    }
+    if (!content.includes("meta") || !content.includes("description")) {
+      issues.push({
+        file: relPath,
+        severity: strict ? "error" : "warning",
+        rule: RULES.MISSING_META_DESCRIPTION,
+        message: 'HTML page missing <meta name="description"> tag.'
+      });
     }
-    await fsExtra.ensureDir(join6(targetPath, ".."));
-    await fsExtra.copy(sourcePath, targetPath, { overwrite: true });
   }
+  return issues;
 }
-function shouldIncludeAllPath(filePath) {
-  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-  const segments = normalized.split("/");
-  return !segments.some((segment) => EXCLUDED_ALL_PATH_SEGMENTS.has(segment));
-}
-async function copyAllTargetPaths(sourceRepo, targetRoot) {
-  for (const target of ALL_DIRECTORY_COPY_TARGETS) {
-    const sourcePath = join6(sourceRepo, target.source);
-    const targetPath = join6(targetRoot, target.target);
-    if (!await fsExtra.pathExists(sourcePath)) {
-      continue;
+async function runAuditCommand(options = {}) {
+  const cwd = options.output || process.cwd();
+  const strict = options.prod ?? false;
+  console.log(chalk16.cyan.bold(`
+\u{1F50D} Agdi Audit${strict ? " \u2014 Production Mode" : ""}
+`));
+  console.log(chalk16.gray(`  Scanning: ${cwd}`));
+  console.log(chalk16.gray(`  Mode:     ${strict ? chalk16.yellow("STRICT (--prod)") : "Standard"}
+`));
+  const spinner = ora6("Scanning files...").start();
+  const files = await scanDirectory(cwd);
+  spinner.text = `Analyzing ${files.length} files...`;
+  const allIssues = [];
+  for (const file of files) {
+    try {
+      const content = await fs10.readFile(file, "utf-8");
+      const relPath = path10.relative(cwd, file);
+      const issues = analyzeFile(relPath, content, strict);
+      allIssues.push(...issues);
+    } catch {
     }
-    await fsExtra.ensureDir(targetPath);
-    await fsExtra.copy(sourcePath, targetPath, {
-      overwrite: true,
-      filter: (source) => shouldIncludeAllPath(source)
+  }
+  const srcFiles = files.filter((f) => !f.includes("test") && !f.includes("spec") && !f.includes("__tests__"));
+  const testFiles = files.filter((f) => f.includes("test") || f.includes("spec") || f.includes("__tests__"));
+  if (strict && testFiles.length === 0 && srcFiles.length > 5) {
+    allIssues.push({
+      file: "(project)",
+      severity: "error",
+      rule: RULES.NO_TESTS,
+      message: `No test files found. Production apps must have tests.`
     });
   }
-  for (const target of ALL_FILE_COPY_TARGETS) {
-    const sourcePath = join6(sourceRepo, target.source);
-    const targetPath = join6(targetRoot, target.target);
-    if (!await fsExtra.pathExists(sourcePath)) {
-      continue;
+  const errors = allIssues.filter((i) => i.severity === "error").length;
+  const warnings = allIssues.filter((i) => i.severity === "warning").length;
+  const info = allIssues.filter((i) => i.severity === "info").length;
+  const passed = errors === 0;
+  spinner.stop();
+  if (allIssues.length === 0) {
+    console.log(chalk16.green.bold("  \u2705 No issues found! Your code looks production-ready.\n"));
+  } else {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const issue of allIssues) {
+      const key = issue.severity;
+      if (!grouped.has(key)) grouped.set(key, []);
+      grouped.get(key).push(issue);
+    }
+    for (const severity of ["error", "warning", "info"]) {
+      const items = grouped.get(severity);
+      if (!items || items.length === 0) continue;
+      const icon = severity === "error" ? "\u274C" : severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+      const color = severity === "error" ? chalk16.red : severity === "warning" ? chalk16.yellow : chalk16.gray;
+      console.log(color.bold(`
+  ${icon} ${severity.toUpperCase()} (${items.length})
+`));
+      items.slice(0, 15).forEach((issue) => {
+        const loc = issue.line ? `:${issue.line}` : "";
+        console.log(color(`    ${issue.file}${loc}`));
+        console.log(chalk16.gray(`      [${issue.rule}] ${issue.message}`));
+      });
+      if (items.length > 15) {
+        console.log(color(`    ... and ${items.length - 15} more`));
+      }
     }
-    await fsExtra.ensureDir(join6(targetPath, ".."));
-    await fsExtra.copy(sourcePath, targetPath, { overwrite: true });
   }
+  console.log("");
+  console.log(chalk16.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk16.gray(`  Files scanned : ${files.length}`));
+  console.log(chalk16.red(`  Errors        : ${errors}`));
+  console.log(chalk16.yellow(`  Warnings      : ${warnings}`));
+  console.log(chalk16.gray(`  Info          : ${info}`));
+  console.log(chalk16.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk16.gray(`  Verdict       : ${passed ? chalk16.green.bold("PASS \u2713") : chalk16.red.bold("FAIL \u2717")}`));
+  console.log("");
+  if (!passed && strict) {
+    console.log(chalk16.yellow("  \u{1F4A1} Run `agdi audit --fix` to auto-fix issues with the QA agent.\n"));
+  }
+  return {
+    issues: allIssues,
+    passed,
+    summary: {
+      errors,
+      warnings,
+      info,
+      filesScanned: files.length
+    }
+  };
 }
-async function writeMirrorPackageJson(targetRoot) {
-  const packageJsonPath = join6(targetRoot, "package.json");
-  const packageJson = {
-    name: "agdi-upstream-mirror",
+
+// src/commands/api-sandbox.ts
+import chalk17 from "chalk";
+import ora7 from "ora";
+var RATE_LIMIT_DEFAULTS = {
+  /** Delay between consecutive endpoint tests (ms) */
+  delayMs: 500,
+  /** Maximum concurrent requests */
+  maxConcurrent: 1,
+  /** Timeout per request (ms) */
+  timeoutMs: 5e3,
+  /** Max endpoints to test in a single run */
+  maxTestEndpoints: 5
+};
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function fetchAndParse(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "Agdi-Sandbox/1.0",
+      Accept: "text/html, application/json, text/plain"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  const body = await response.text();
+  if (contentType.includes("json") || body.trim().startsWith("{")) {
+    return { title: "OpenAPI Spec", body };
+  }
+  const stripped = body.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<[^>]+>/g, "\n").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\n{3,}/g, "\n\n").trim();
+  const titleMatch = body.match(/<title[^>]*>([^<]+)<\/title>/i);
+  const title = titleMatch ? titleMatch[1].trim() : url;
+  return { title, body: stripped };
+}
+function extractEndpoints(text) {
+  const endpoints = [];
+  const seen = /* @__PURE__ */ new Set();
+  const patterns = [
+    // REST patterns: GET /api/users, POST /v1/items
+    /\b(GET|POST|PUT|DELETE|PATCH)\s+(\/[a-zA-Z0-9_\-/:{}?&=.]+)/gi,
+    // curl examples
+    /curl\s+.*?(GET|POST|PUT|DELETE|PATCH)\s+['"]?(https?:\/\/[^\s'"]+)/gi
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const method = match[1].toUpperCase();
+      const path20 = match[2];
+      const key = `${method} ${path20}`;
+      if (!seen.has(key) && path20.length > 1) {
+        seen.add(key);
+        const idx = text.indexOf(match[0]);
+        const context = text.substring(Math.max(0, idx - 200), Math.min(text.length, idx + 200));
+        const descLine = context.split("\n").find((l) => l.length > 20 && !l.includes(method)) || "";
+        endpoints.push({
+          method,
+          path: path20,
+          description: descLine.trim().substring(0, 120)
+        });
+      }
+    }
+  }
+  try {
+    const json = JSON.parse(text);
+    if (json.paths) {
+      for (const [apiPath, methods] of Object.entries(json.paths)) {
+        for (const [method, spec] of Object.entries(methods)) {
+          if (["get", "post", "put", "delete", "patch"].includes(method)) {
+            const key = `${method.toUpperCase()} ${apiPath}`;
+            if (!seen.has(key)) {
+              seen.add(key);
+              endpoints.push({
+                method: method.toUpperCase(),
+                path: apiPath,
+                description: spec.summary || spec.description || "",
+                parameters: spec.parameters?.map((p) => p.name) || []
+              });
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return endpoints;
+}
+async function testEndpoint(baseUrl, endpoint, apiKey) {
+  const url = `${baseUrl}${endpoint.path}`.replace(/{[^}]+}/g, "test");
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": "Agdi-Sandbox/1.0"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  try {
+    const response = await fetch(url, {
+      method: endpoint.method === "GET" ? "GET" : "HEAD",
+      headers,
+      signal: AbortSignal.timeout(RATE_LIMIT_DEFAULTS.timeoutMs)
+    });
+    let shape = `HTTP ${response.status}`;
+    if (response.ok) {
+      try {
+        const json = await response.json();
+        shape = describeShape(json);
+      } catch {
+        shape = `HTTP ${response.status} (non-JSON)`;
+      }
+    }
+    return { status: response.status, shape };
+  } catch {
+    return { status: 0, shape: "unreachable" };
+  }
+}
+function describeShape(obj, depth = 0) {
+  if (depth > 2) return "...";
+  if (obj === null) return "null";
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return `[${describeShape(obj[0], depth + 1)}]`;
+  }
+  if (typeof obj === "object") {
+    const keys = Object.keys(obj).slice(0, 6);
+    const fields = keys.map((k) => `${k}: ${typeof obj[k]}`).join(", ");
+    const extra = Object.keys(obj).length > 6 ? ", ..." : "";
+    return `{ ${fields}${extra} }`;
+  }
+  return typeof obj;
+}
+async function runSandboxCommand(url, options = {}) {
+  console.log(chalk17.cyan.bold(`
+\u{1F9EA} Agdi API Sandbox Reader
+`));
+  console.log(chalk17.gray(`  Target: ${url}`));
+  console.log(chalk17.gray(`  Test:   ${options.test ? chalk17.yellow("YES") : "no"}
+`));
+  const spinner = ora7("Fetching API documentation...").start();
+  const { title, body } = await fetchAndParse(url);
+  spinner.text = "Extracting endpoints...";
+  const endpoints = extractEndpoints(body);
+  spinner.stop();
+  console.log(chalk17.green(`  \u2713 Found ${endpoints.length} endpoint(s) from "${title}"
+`));
+  if (endpoints.length > 0) {
+    console.log(chalk17.cyan.bold("  Discovered Endpoints:\n"));
+    endpoints.slice(0, 20).forEach((ep, i) => {
+      const methodColor = ep.method === "GET" ? chalk17.green : ep.method === "POST" ? chalk17.yellow : ep.method === "DELETE" ? chalk17.red : chalk17.blue;
+      console.log(`    ${chalk17.gray(`${i + 1}.`)} ${methodColor(ep.method.padEnd(7))} ${chalk17.white(ep.path)}`);
+      if (ep.description) {
+        console.log(chalk17.gray(`       ${ep.description}`));
+      }
+    });
+    if (endpoints.length > 20) {
+      console.log(chalk17.gray(`    ... and ${endpoints.length - 20} more`));
+    }
+  } else {
+    console.log(chalk17.yellow("  \u26A0 No API endpoints detected. The page may not be API documentation."));
+  }
+  let testResults;
+  if (options.test && endpoints.length > 0) {
+    console.log(chalk17.cyan.bold("\n  Live Testing:\n"));
+    const baseUrl = new URL(url).origin;
+    testResults = [];
+    for (const ep of endpoints.slice(0, RATE_LIMIT_DEFAULTS.maxTestEndpoints)) {
+      if (testResults.length > 0) {
+        await sleep(RATE_LIMIT_DEFAULTS.delayMs);
+      }
+      const result = await testEndpoint(baseUrl, ep, options.apiKey);
+      testResults.push({
+        endpoint: `${ep.method} ${ep.path}`,
+        status: result.status,
+        shape: result.shape
+      });
+      const statusColor = result.status >= 200 && result.status < 300 ? chalk17.green : result.status === 0 ? chalk17.red : chalk17.yellow;
+      console.log(`    ${statusColor(`${result.status}`)} ${ep.method} ${ep.path}`);
+      console.log(chalk17.gray(`       Shape: ${result.shape}`));
+    }
+  }
+  const rawMarkdown = [
+    `# API Documentation: ${title}`,
+    `Source: ${url}`,
+    "",
+    "## Endpoints",
+    ...endpoints.map((ep) => `- **${ep.method}** \`${ep.path}\` \u2014 ${ep.description || "No description"}`),
+    ...testResults ? [
+      "",
+      "## Live Test Results",
+      ...testResults.map((r) => `- \`${r.endpoint}\` \u2192 ${r.status} \u2014 Shape: \`${r.shape}\``)
+    ] : []
+  ].join("\n");
+  console.log("");
+  console.log(chalk17.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk17.gray(`  Title      : ${title}`));
+  console.log(chalk17.gray(`  Endpoints  : ${endpoints.length}`));
+  console.log(chalk17.gray(`  Tested     : ${testResults?.length || 0}`));
+  console.log(chalk17.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log("");
+  if (options.inject) {
+    console.log(chalk17.green("  \u{1F489} Endpoint summary ready for Squad injection.\n"));
+  }
+  return {
+    url,
+    title,
+    endpoints,
+    rawMarkdown,
+    testResults
+  };
+}
+
+// src/commands/visual-test.ts
+import chalk18 from "chalk";
+import ora8 from "ora";
+import * as fs11 from "fs/promises";
+import * as path11 from "path";
+import { exec as execCb2 } from "child_process";
+import { promisify as promisify4 } from "util";
+import crypto3 from "crypto";
+var execAsync3 = promisify4(execCb2);
+async function discoverRoutes(cwd) {
+  const routes = ["/"];
+  const routePatterns = [
+    // Next.js app router
+    { glob: "src/app/**/page.tsx", transform: (p) => "/" + p.replace("src/app/", "").replace("/page.tsx", "").replace("page.tsx", "") },
+    { glob: "app/**/page.tsx", transform: (p) => "/" + p.replace("app/", "").replace("/page.tsx", "").replace("page.tsx", "") },
+    // Next.js pages router
+    { glob: "src/pages/**/*.tsx", transform: (p) => "/" + p.replace("src/pages/", "").replace(".tsx", "").replace("/index", "").replace("index", "") },
+    { glob: "pages/**/*.tsx", transform: (p) => "/" + p.replace("pages/", "").replace(".tsx", "").replace("/index", "").replace("index", "") }
+  ];
+  for (const pattern of routePatterns) {
+    try {
+      const { stdout } = await execAsync3(`npx -y glob "${pattern.glob}" --cwd "${cwd}" 2>nul`, { cwd });
+      const files = stdout.trim().split("\n").filter(Boolean);
+      for (const file of files) {
+        const route = pattern.transform(file).replace(/\\/g, "/");
+        if (route && !route.includes("_app") && !route.includes("_document") && !route.includes("api/")) {
+          routes.push(route === "/" ? route : route.replace(/\/$/, ""));
+        }
+      }
+    } catch {
+    }
+  }
+  return [...new Set(routes)];
+}
+async function hashFile(filePath) {
+  try {
+    const content = await fs11.readFile(filePath);
+    return crypto3.createHash("md5").update(content).digest("hex");
+  } catch {
+    return "";
+  }
+}
+async function takeScreenshot(url, outputPath) {
+  try {
+    await execAsync3(
+      `npx -y playwright screenshot --browser chromium --full-page "${url}" "${outputPath}"`,
+      { timeout: 3e4 }
+    );
+    return true;
+  } catch {
+  }
+  try {
+    const script = `
+            const puppeteer = require('puppeteer');
+            (async () => {
+                const browser = await puppeteer.launch({ headless: 'new' });
+                const page = await browser.newPage();
+                await page.setViewport({ width: 1280, height: 720 });
+                await page.goto('${url}', { waitUntil: 'networkidle0', timeout: 15000 });
+                await page.screenshot({ path: '${outputPath.replace(/\\/g, "\\\\")}', fullPage: true });
+                await browser.close();
+            })();
+        `;
+    await execAsync3(`node -e "${script.replace(/"/g, '\\"').replace(/\n/g, " ")}"`, { timeout: 3e4 });
+    return true;
+  } catch {
+  }
+  return false;
+}
+async function runVisualTestCommand(options = {}) {
+  const cwd = options.output || process.cwd();
+  const port = options.port || 3e3;
+  const baseUrl = `http://localhost:${port}`;
+  const baselineDir = path11.join(cwd, ".agdi", "visual-baselines");
+  const currentDir = path11.join(cwd, ".agdi", "visual-current");
+  console.log(chalk18.cyan.bold("\n\u{1F4F8} Agdi Visual Regression Testing\n"));
+  console.log(chalk18.gray(`  Base URL : ${baseUrl}`));
+  console.log(chalk18.gray(`  Baselines: ${path11.relative(cwd, baselineDir)}`));
+  console.log(chalk18.gray(`  Mode     : ${options.update ? chalk18.yellow("UPDATE BASELINES") : "Compare"}
+`));
+  await fs11.mkdir(baselineDir, { recursive: true });
+  await fs11.mkdir(currentDir, { recursive: true });
+  const spinner = ora8("Discovering routes...").start();
+  let routes;
+  if (options.routes) {
+    routes = options.routes.split(",").map((r) => r.trim());
+  } else {
+    routes = await discoverRoutes(cwd);
+  }
+  spinner.stop();
+  console.log(chalk18.gray(`  Routes   : ${routes.join(", ")}
+`));
+  let serverRunning = false;
+  try {
+    const response = await fetch(baseUrl, { signal: AbortSignal.timeout(3e3) });
+    serverRunning = response.ok || response.status < 500;
+  } catch {
+  }
+  if (!serverRunning) {
+    console.log(chalk18.yellow("  \u26A0 Dev server not detected. Start it with `npm run dev` first."));
+    console.log(chalk18.gray(`    Expected at: ${baseUrl}
+`));
+    return {
+      results: [{ route: "*", status: "error", error: "Dev server not running" }],
+      passed: 0,
+      failed: 0,
+      newBaselines: 0,
+      errors: 1
+    };
+  }
+  const results = [];
+  let canScreenshot = false;
+  try {
+    await execAsync3("npx -y playwright --version", { timeout: 1e4 });
+    canScreenshot = true;
+  } catch {
+    try {
+      await execAsync3(`node -e "require('puppeteer')"`, { timeout: 5e3 });
+      canScreenshot = true;
+    } catch {
+    }
+  }
+  for (const route of routes) {
+    const safeName = route.replace(/\//g, "_").replace(/^_/, "root") || "root";
+    const currentPath = path11.join(currentDir, `${safeName}.png`);
+    const baselinePath = path11.join(baselineDir, `${safeName}.png`);
+    const url = `${baseUrl}${route}`;
+    process.stdout.write(chalk18.gray(`  \u{1F4F7} ${route.padEnd(30)}`));
+    if (canScreenshot) {
+      const success = await takeScreenshot(url, currentPath);
+      if (!success) {
+        console.log(chalk18.red("\u2717 Screenshot failed"));
+        results.push({ route, status: "error", error: "Screenshot capture failed" });
+        continue;
+      }
+    } else {
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+        const html = await response.text();
+        const htmlHash = crypto3.createHash("md5").update(html).digest("hex");
+        await fs11.writeFile(currentPath.replace(".png", ".hash"), htmlHash, "utf-8");
+        try {
+          const baselineHash = await fs11.readFile(baselinePath.replace(".png", ".hash"), "utf-8");
+          if (options.update) {
+            await fs11.writeFile(baselinePath.replace(".png", ".hash"), htmlHash, "utf-8");
+            console.log(chalk18.blue("\u2B06 Updated"));
+            results.push({ route, status: "updated" });
+          } else if (htmlHash === baselineHash) {
+            console.log(chalk18.green("\u2713 Pass"));
+            results.push({ route, status: "pass" });
+          } else {
+            console.log(chalk18.red("\u2717 Changed"));
+            results.push({ route, status: "fail", diffPercentage: 100 });
+          }
+        } catch {
+          await fs11.writeFile(baselinePath.replace(".png", ".hash"), htmlHash, "utf-8");
+          console.log(chalk18.cyan("\u2605 New baseline"));
+          results.push({ route, status: "new", screenshotPath: currentPath });
+        }
+        continue;
+      } catch (err) {
+        console.log(chalk18.red("\u2717 Unreachable"));
+        results.push({ route, status: "error", error: `Route unreachable: ${route}` });
+        continue;
+      }
+    }
+    try {
+      await fs11.access(baselinePath);
+      const currentHash = await hashFile(currentPath);
+      const baselineHash = await hashFile(baselinePath);
+      if (options.update) {
+        await fs11.copyFile(currentPath, baselinePath);
+        console.log(chalk18.blue("\u2B06 Updated"));
+        results.push({ route, status: "updated", screenshotPath: currentPath, baselinePath });
+      } else if (currentHash === baselineHash) {
+        console.log(chalk18.green("\u2713 Pass"));
+        results.push({ route, status: "pass", screenshotPath: currentPath, baselinePath });
+      } else {
+        console.log(chalk18.red("\u2717 Visual diff detected"));
+        results.push({ route, status: "fail", screenshotPath: currentPath, baselinePath, diffPercentage: 100 });
+      }
+    } catch {
+      await fs11.copyFile(currentPath, baselinePath);
+      console.log(chalk18.cyan("\u2605 New baseline"));
+      results.push({ route, status: "new", screenshotPath: currentPath, baselinePath });
+    }
+  }
+  const passed = results.filter((r) => r.status === "pass").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const newBaselines = results.filter((r) => r.status === "new" || r.status === "updated").length;
+  const errors = results.filter((r) => r.status === "error").length;
+  console.log("");
+  console.log(chalk18.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk18.green(`  Passed       : ${passed}`));
+  console.log(chalk18.red(`  Failed       : ${failed}`));
+  console.log(chalk18.blue(`  New/Updated  : ${newBaselines}`));
+  console.log(chalk18.gray(`  Errors       : ${errors}`));
+  console.log(chalk18.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk18.gray(`  Verdict      : ${failed === 0 && errors === 0 ? chalk18.green.bold("PASS \u2713") : chalk18.red.bold("FAIL \u2717")}`));
+  console.log("");
+  if (failed > 0) {
+    console.log(chalk18.yellow("  \u{1F4A1} Run `agdi visual-test --update` to accept current screenshots as new baselines.\n"));
+  }
+  if (!canScreenshot) {
+    console.log(chalk18.gray("  \u2139 Install Playwright for full screenshot support: npx playwright install\n"));
+  }
+  return { results, passed, failed, newBaselines, errors };
+}
+
+// src/commands/git-memory.ts
+import chalk19 from "chalk";
+import ora9 from "ora";
+import { exec as execCb3 } from "child_process";
+import { promisify as promisify5 } from "util";
+import * as path12 from "path";
+var execAsync4 = promisify5(execCb3);
+async function parseGitLog(cwd, depth) {
+  const sep2 = "---AGDI_SEP---";
+  const format = `%H${sep2}%ai${sep2}%an${sep2}%s${sep2}%b${sep2}`;
+  try {
+    const { stdout } = await execAsync4(
+      `git log -${depth} --pretty=format:"${format}" --shortstat`,
+      { cwd, maxBuffer: 10 * 1024 * 1024 }
+    );
+    const commits = [];
+    const entries = stdout.split(format.replace(/%[A-Za-z]+/g, "")).filter(Boolean);
+    const lines = stdout.split("\n");
+    let current = null;
+    for (const line of lines) {
+      if (line.includes(sep2)) {
+        if (current?.hash) {
+          commits.push(current);
+        }
+        const parts = line.split(sep2);
+        current = {
+          hash: (parts[0] || "").trim().slice(0, 8),
+          date: (parts[1] || "").trim(),
+          author: (parts[2] || "").trim(),
+          subject: (parts[3] || "").trim(),
+          body: (parts[4] || "").trim(),
+          filesChanged: 0
+        };
+      } else if (current && /\d+ file/.test(line)) {
+        const match = line.match(/(\d+) file/);
+        if (match) {
+          current.filesChanged = parseInt(match[1], 10);
+        }
+      }
+    }
+    if (current?.hash) {
+      commits.push(current);
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+async function getHotFiles(cwd, depth) {
+  try {
+    const { stdout } = await execAsync4(
+      `git log -${depth} --name-only --pretty=format: | sort | uniq -c | sort -rn`,
+      { cwd, maxBuffer: 5 * 1024 * 1024 }
+    );
+    const fileCounts = /* @__PURE__ */ new Map();
+    const { stdout: winStdout } = await execAsync4(
+      `git log -${depth} --name-only --pretty=format:`,
+      { cwd, maxBuffer: 5 * 1024 * 1024 }
+    );
+    winStdout.split("\n").filter(Boolean).forEach((f) => {
+      const file = f.trim();
+      if (file) {
+        fileCounts.set(file, (fileCounts.get(file) || 0) + 1);
+      }
+    });
+    return [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15).map(([file, changes]) => ({ file, changes }));
+  } catch {
+    return [];
+  }
+}
+async function getContributors(cwd) {
+  try {
+    const { stdout } = await execAsync4(
+      'git log --format="%an" | sort -u',
+      { cwd }
+    );
+    const { stdout: winStdout } = await execAsync4(
+      'git log --format="%an"',
+      { cwd }
+    );
+    return [...new Set(winStdout.split("\n").map((s) => s.trim()).filter(Boolean))];
+  } catch {
+    return [];
+  }
+}
+function detectPatterns(commits) {
+  const patterns = [];
+  const subjects = commits.map((c) => c.subject.toLowerCase());
+  const conventional = subjects.filter((s) => /^(feat|fix|chore|docs|style|refactor|test|ci)\(/.test(s));
+  if (conventional.length > commits.length * 0.3) {
+    patterns.push("Uses Conventional Commits");
+  }
+  const fixes = subjects.filter((s) => s.includes("fix"));
+  if (fixes.length > commits.length * 0.3) {
+    patterns.push(`High fix ratio (${Math.round(fixes.length / commits.length * 100)}%) \u2014 code may need stabilization`);
+  }
+  const refactors = subjects.filter((s) => s.includes("refactor"));
+  if (refactors.length > 3) {
+    patterns.push("Active refactoring \u2014 check for deprecated patterns");
+  }
+  const features = subjects.filter((s) => s.includes("feat") || s.includes("add"));
+  if (features.length > 5) {
+    patterns.push(`Rapid feature development (${features.length} features in last ${commits.length} commits)`);
+  }
+  return patterns;
+}
+async function runMemoryCommand(options = {}) {
+  const cwd = options.output || process.cwd();
+  const depth = options.depth || 30;
+  console.log(chalk19.cyan.bold("\n\u{1F9E0} Agdi Git Memory\n"));
+  console.log(chalk19.gray(`  Workspace: ${cwd}`));
+  console.log(chalk19.gray(`  Depth    : last ${depth} commits
+`));
+  const spinner = ora9("Reading git history...").start();
+  try {
+    await execAsync4("git rev-parse --is-inside-work-tree", { cwd });
+  } catch {
+    spinner.stop();
+    console.log(chalk19.red("  \u2717 Not a git repository.\n"));
+    return {
+      repoName: path12.basename(cwd),
+      totalCommits: 0,
+      contributors: [],
+      recentCommits: [],
+      hotFiles: [],
+      patterns: [],
+      summary: "Not a git repository."
+    };
+  }
+  let repoName = path12.basename(cwd);
+  try {
+    const { stdout } = await execAsync4("git remote get-url origin", { cwd });
+    const match = stdout.trim().match(/\/([^/]+?)(?:\.git)?$/);
+    if (match) repoName = match[1];
+  } catch {
+  }
+  spinner.text = "Parsing commits...";
+  const commits = await parseGitLog(cwd, depth);
+  spinner.text = "Analyzing file activity...";
+  const hotFiles = await getHotFiles(cwd, depth);
+  spinner.text = "Identifying contributors...";
+  const contributors = await getContributors(cwd);
+  spinner.text = "Detecting patterns...";
+  const patterns = detectPatterns(commits);
+  spinner.stop();
+  let totalCommits = commits.length;
+  try {
+    const { stdout } = await execAsync4("git rev-list --count HEAD", { cwd });
+    totalCommits = parseInt(stdout.trim(), 10) || commits.length;
+  } catch {
+  }
+  console.log(chalk19.green(`  \u2713 Analyzed ${commits.length} commits from "${repoName}"
+`));
+  console.log(chalk19.cyan.bold("  Contributors:"));
+  contributors.slice(0, 8).forEach((c) => console.log(chalk19.gray(`    \u2022 ${c}`)));
+  if (contributors.length > 8) console.log(chalk19.gray(`    ... and ${contributors.length - 8} more`));
+  if (hotFiles.length > 0) {
+    console.log(chalk19.cyan.bold("\n  Hot Files (most changed):"));
+    hotFiles.slice(0, 10).forEach((f) => {
+      console.log(chalk19.gray(`    ${String(f.changes).padStart(3)} changes  ${f.file}`));
+    });
+  }
+  if (patterns.length > 0) {
+    console.log(chalk19.cyan.bold("\n  Detected Patterns:"));
+    patterns.forEach((p) => console.log(chalk19.yellow(`    \u26A1 ${p}`)));
+  }
+  console.log(chalk19.cyan.bold("\n  Recent Commits:"));
+  commits.slice(0, 8).forEach((c) => {
+    console.log(chalk19.gray(`    ${c.hash} ${c.subject}`));
+  });
+  const summary = [
+    `Project: ${repoName}`,
+    `Total commits: ${totalCommits}`,
+    `Contributors: ${contributors.join(", ")}`,
+    `Patterns: ${patterns.join("; ") || "none detected"}`,
+    "",
+    "Recent activity:",
+    ...commits.slice(0, 10).map((c) => `  - ${c.subject} (${c.author}, ${c.date})`),
+    "",
+    "Most active files:",
+    ...hotFiles.slice(0, 10).map((f) => `  - ${f.file} (${f.changes} changes)`)
+  ].join("\n");
+  console.log("");
+  console.log(chalk19.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk19.gray(`  Total Commits  : ${totalCommits}`));
+  console.log(chalk19.gray(`  Contributors   : ${contributors.length}`));
+  console.log(chalk19.gray(`  Hot Files      : ${hotFiles.length}`));
+  console.log(chalk19.gray(`  Patterns       : ${patterns.length}`));
+  console.log(chalk19.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log("");
+  if (options.inject) {
+    console.log(chalk19.green("  \u{1F489} Memory context ready for Squad injection.\n"));
+  }
+  return {
+    repoName,
+    totalCommits,
+    contributors,
+    recentCommits: commits,
+    hotFiles,
+    patterns,
+    summary
+  };
+}
+
+// src/commands/deps-scan.ts
+import chalk20 from "chalk";
+import ora10 from "ora";
+import { exec as execCb4 } from "child_process";
+import { promisify as promisify6 } from "util";
+import * as fs12 from "fs/promises";
+import * as path13 from "path";
+var execAsync5 = promisify6(execCb4);
+async function runNpmAudit(cwd) {
+  try {
+    const { stdout } = await execAsync5("npm audit --json 2>nul", {
+      cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const audit = JSON.parse(stdout);
+    const vulns = [];
+    if (audit.vulnerabilities) {
+      for (const [name, info] of Object.entries(audit.vulnerabilities)) {
+        const vuln = info;
+        vulns.push({
+          name,
+          severity: vuln.severity || "info",
+          title: vuln.via?.[0]?.title || vuln.via?.[0] || "Unknown vulnerability",
+          fixAvailable: !!vuln.fixAvailable
+        });
+      }
+    }
+    return vulns;
+  } catch (err) {
+    try {
+      const output = err.stdout || "";
+      const audit = JSON.parse(output);
+      const vulns = [];
+      if (audit.vulnerabilities) {
+        for (const [name, info] of Object.entries(audit.vulnerabilities)) {
+          const vuln = info;
+          vulns.push({
+            name,
+            severity: vuln.severity || "info",
+            title: typeof vuln.via?.[0] === "string" ? vuln.via[0] : vuln.via?.[0]?.title || "Unknown",
+            fixAvailable: !!vuln.fixAvailable
+          });
+        }
+      }
+      return vulns;
+    } catch {
+      return [];
+    }
+  }
+}
+async function runNpmOutdated(cwd) {
+  try {
+    const { stdout } = await execAsync5("npm outdated --json 2>nul", {
+      cwd,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    const outdated = JSON.parse(stdout || "{}");
+    return Object.entries(outdated).map(([name, info]) => {
+      const pkg = info;
+      return {
+        name,
+        current: pkg.current || "unknown",
+        wanted: pkg.wanted || "unknown",
+        latest: pkg.latest || "unknown",
+        type: pkg.type || "dependencies"
+      };
+    });
+  } catch (err) {
+    try {
+      const output = err.stdout || "{}";
+      const outdated = JSON.parse(output);
+      return Object.entries(outdated).map(([name, info]) => {
+        const pkg = info;
+        return {
+          name,
+          current: pkg.current || "unknown",
+          wanted: pkg.wanted || "unknown",
+          latest: pkg.latest || "unknown",
+          type: pkg.type || "dependencies"
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+}
+async function countDeps(cwd) {
+  try {
+    const pkgJson = await fs12.readFile(path13.join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(pkgJson);
+    const deps = Object.keys(pkg.dependencies || {}).length;
+    const devDeps = Object.keys(pkg.devDependencies || {}).length;
+    return deps + devDeps;
+  } catch {
+    return 0;
+  }
+}
+async function runDepsScanCommand(options = {}) {
+  const cwd = options.output || process.cwd();
+  console.log(chalk20.cyan.bold("\n\u{1F6E1}\uFE0F  Agdi Dependency Scanner\n"));
+  console.log(chalk20.gray(`  Workspace: ${cwd}`));
+  console.log(chalk20.gray(`  Mode     : ${options.full ? chalk20.yellow("FULL") : "Quick"}
+`));
+  try {
+    await fs12.access(path13.join(cwd, "package.json"));
+  } catch {
+    console.log(chalk20.red("  \u2717 No package.json found in workspace.\n"));
+    return {
+      vulnerabilities: [],
+      outdated: [],
+      totalDeps: 0,
+      summary: { critical: 0, high: 0, moderate: 0, low: 0, outdatedCount: 0, fixableCount: 0 },
+      passed: true
+    };
+  }
+  const spinner = ora10("Running vulnerability scan...").start();
+  const vulns = await runNpmAudit(cwd);
+  const totalDeps = await countDeps(cwd);
+  let outdated = [];
+  if (options.full) {
+    spinner.text = "Checking for outdated packages...";
+    outdated = await runNpmOutdated(cwd);
+  }
+  spinner.stop();
+  const critical = vulns.filter((v) => v.severity === "critical").length;
+  const high = vulns.filter((v) => v.severity === "high").length;
+  const moderate = vulns.filter((v) => v.severity === "moderate").length;
+  const low = vulns.filter((v) => v.severity === "low").length;
+  const fixable = vulns.filter((v) => v.fixAvailable).length;
+  if (vulns.length > 0) {
+    console.log(chalk20.red.bold(`  \u26A0 Found ${vulns.length} vulnerabilit${vulns.length === 1 ? "y" : "ies"}:
+`));
+    for (const severity of ["critical", "high", "moderate", "low"]) {
+      const items = vulns.filter((v) => v.severity === severity);
+      if (items.length === 0) continue;
+      const color = severity === "critical" ? chalk20.red.bold : severity === "high" ? chalk20.red : severity === "moderate" ? chalk20.yellow : chalk20.gray;
+      console.log(color(`    ${severity.toUpperCase()} (${items.length}):`));
+      items.slice(0, 5).forEach((v) => {
+        const fix = v.fixAvailable ? chalk20.green(" [fixable]") : chalk20.gray(" [manual]");
+        console.log(chalk20.gray(`      \u2022 ${v.name} \u2014 ${v.title}${fix}`));
+      });
+      if (items.length > 5) {
+        console.log(chalk20.gray(`      ... and ${items.length - 5} more`));
+      }
+    }
+  } else {
+    console.log(chalk20.green("  \u2705 No known vulnerabilities found!\n"));
+  }
+  if (options.full && outdated.length > 0) {
+    console.log(chalk20.yellow.bold(`
+  \u{1F4E6} Outdated Packages (${outdated.length}):
+`));
+    outdated.slice(0, 10).forEach((pkg) => {
+      const isMajor = pkg.current.split(".")[0] !== pkg.latest.split(".")[0];
+      const urgency = isMajor ? chalk20.red("MAJOR") : chalk20.yellow("minor");
+      console.log(chalk20.gray(`    ${pkg.name.padEnd(30)} ${pkg.current} \u2192 ${chalk20.green(pkg.latest)} ${urgency}`));
+    });
+    if (outdated.length > 10) {
+      console.log(chalk20.gray(`    ... and ${outdated.length - 10} more`));
+    }
+  }
+  if (options.fix && fixable > 0) {
+    console.log(chalk20.cyan.bold("\n  \u{1F527} Running npm audit fix...\n"));
+    try {
+      const { stdout } = await execAsync5("npm audit fix", { cwd });
+      console.log(chalk20.gray(`    ${stdout.trim().split("\n").slice(0, 5).join("\n    ")}`));
+      console.log(chalk20.green("\n  \u2713 Auto-fix complete.\n"));
+    } catch (err) {
+      console.log(chalk20.yellow("  \u26A0 Some fixes require manual intervention.\n"));
+    }
+  }
+  const passed = critical === 0 && high === 0;
+  console.log("");
+  console.log(chalk20.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk20.gray(`  Total Deps     : ${totalDeps}`));
+  console.log(chalk20.red(`  Critical       : ${critical}`));
+  console.log(chalk20.red(`  High           : ${high}`));
+  console.log(chalk20.yellow(`  Moderate       : ${moderate}`));
+  console.log(chalk20.gray(`  Low            : ${low}`));
+  if (options.full) {
+    console.log(chalk20.yellow(`  Outdated       : ${outdated.length}`));
+  }
+  console.log(chalk20.green(`  Fixable        : ${fixable}`));
+  console.log(chalk20.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk20.gray(`  Verdict        : ${passed ? chalk20.green.bold("PASS \u2713") : chalk20.red.bold("FAIL \u2717")}`));
+  console.log("");
+  if (!passed) {
+    console.log(chalk20.yellow("  \u{1F4A1} Run `agdi deps --fix` to auto-fix vulnerabilities.\n"));
+  }
+  return {
+    vulnerabilities: vulns,
+    outdated,
+    totalDeps,
+    summary: { critical, high, moderate, low, outdatedCount: outdated.length, fixableCount: fixable },
+    passed
+  };
+}
+
+// src/commands/plugin-loader.ts
+import chalk21 from "chalk";
+import * as fs13 from "fs/promises";
+import * as path14 from "path";
+import { exec as execCb5 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execAsync6 = promisify7(execCb5);
+async function discoverLocalPlugins(cwd) {
+  const pluginDir = path14.join(cwd, ".agdi", "plugins");
+  const plugins = [];
+  try {
+    const entries = await fs13.readdir(pluginDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginPath = path14.join(pluginDir, entry.name);
+      const manifestPath = path14.join(pluginPath, "agdi-plugin.json");
+      try {
+        const raw = await fs13.readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(raw);
+        const entryExists = await fs13.access(path14.join(pluginPath, manifest.entryPoint)).then(() => true).catch(() => false);
+        plugins.push({
+          manifest,
+          path: pluginPath,
+          source: "local",
+          healthy: entryExists
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return plugins;
+}
+async function discoverNpmPlugins(cwd) {
+  const plugins = [];
+  try {
+    const nodeModules = path14.join(cwd, "node_modules");
+    const entries = await fs13.readdir(nodeModules, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith("agdi-plugin-")) continue;
+      const pluginPath = path14.join(nodeModules, entry.name);
+      const manifestPath = path14.join(pluginPath, "agdi-plugin.json");
+      try {
+        const raw = await fs13.readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(raw);
+        plugins.push({
+          manifest,
+          path: pluginPath,
+          source: "npm",
+          healthy: true
+        });
+      } catch {
+        try {
+          const pkgRaw = await fs13.readFile(path14.join(pluginPath, "package.json"), "utf-8");
+          const pkg = JSON.parse(pkgRaw);
+          if (pkg.agdiPlugin) {
+            plugins.push({
+              manifest: {
+                name: pkg.name,
+                version: pkg.version,
+                description: pkg.description || "",
+                entryPoint: pkg.main || "index.js",
+                capabilities: pkg.agdiPlugin.capabilities || [],
+                author: pkg.author || "unknown"
+              },
+              path: pluginPath,
+              source: "npm",
+              healthy: true
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return plugins;
+}
+async function createPluginTemplate(cwd) {
+  const pluginDir = path14.join(cwd, ".agdi", "plugins", "my-custom-agent");
+  await fs13.mkdir(pluginDir, { recursive: true });
+  const manifest = {
+    name: "agdi-plugin-custom",
+    version: "1.0.0",
+    description: "My custom Agdi plugin",
+    agent: "custom",
+    entryPoint: "./index.js",
+    capabilities: ["frontend"],
+    author: "developer"
+  };
+  await fs13.writeFile(
+    path14.join(pluginDir, "agdi-plugin.json"),
+    JSON.stringify(manifest, null, 2),
+    "utf-8"
+  );
+  const entryPoint = `/**
+ * Agdi Custom Plugin
+ *
+ * This plugin adds a custom agent capability to Agdi.
+ * Modify the \`execute\` function to define your agent's behavior.
+ */
+
+module.exports = {
+    name: 'custom',
+
+    /**
+     * Called when the Squad assigns a task to this agent.
+     * @param {object} task - The task object { id, title, description, ... }
+     * @param {object} context - The shared context { projectSpec, workspaceRoot, ... }
+     * @returns {object} - Agent output { success, content, files, errors }
+     */
+    async execute(task, context) {
+        return {
+            success: true,
+            content: 'Custom agent executed successfully!',
+            files: [],
+            errors: [],
+        };
+    },
+
+    /**
+     * System prompt for the LLM when this agent is active.
+     */
+    getSystemPrompt() {
+        return 'You are a custom agent. Follow the project architecture rules.';
+    },
+};
+`;
+  await fs13.writeFile(path14.join(pluginDir, "index.js"), entryPoint, "utf-8");
+  return pluginDir;
+}
+async function runPluginsCommand(options = {}) {
+  const cwd = options.output || process.cwd();
+  console.log(chalk21.cyan.bold("\n\u{1F50C} Agdi Plugin Manager\n"));
+  if (options.init) {
+    const pluginPath = await createPluginTemplate(cwd);
+    console.log(chalk21.green(`  \u2713 Plugin template created at:`));
+    console.log(chalk21.gray(`    ${path14.relative(cwd, pluginPath)}/
+`));
+    console.log(chalk21.gray("  Files created:"));
+    console.log(chalk21.gray("    \u2022 agdi-plugin.json  (manifest)"));
+    console.log(chalk21.gray("    \u2022 index.js          (entry point)\n"));
+    console.log(chalk21.yellow("  Next steps:"));
+    console.log(chalk21.gray("    1. Edit agdi-plugin.json with your plugin details"));
+    console.log(chalk21.gray("    2. Implement your agent logic in index.js"));
+    console.log(chalk21.gray("    3. Run `agdi plugins` to verify it loads\n"));
+    return;
+  }
+  if (options.install) {
+    const pkgName = options.install.startsWith("agdi-plugin-") ? options.install : `agdi-plugin-${options.install}`;
+    console.log(chalk21.gray(`  Installing ${pkgName}...`));
+    try {
+      await execAsync6(`npm install ${pkgName}`, { cwd });
+      console.log(chalk21.green(`  \u2713 ${pkgName} installed successfully.
+`));
+    } catch (err) {
+      console.log(chalk21.red(`  \u2717 Failed to install ${pkgName}.`));
+      console.log(chalk21.gray(`    ${err.message?.split("\n")[0]}
+`));
+    }
+    return;
+  }
+  const localPlugins = await discoverLocalPlugins(cwd);
+  const npmPlugins = await discoverNpmPlugins(cwd);
+  const allPlugins = [...localPlugins, ...npmPlugins];
+  if (allPlugins.length === 0) {
+    console.log(chalk21.gray("  No plugins installed.\n"));
+    console.log(chalk21.yellow("  Get started:"));
+    console.log(chalk21.gray("    \u2022 Create a plugin: agdi plugins --init"));
+    console.log(chalk21.gray("    \u2022 Install from npm: agdi plugins --install <name>\n"));
+    return;
+  }
+  console.log(chalk21.gray(`  Found ${allPlugins.length} plugin(s):
+`));
+  for (const plugin of allPlugins) {
+    const status = plugin.healthy ? chalk21.green("\u2713") : chalk21.red("\u2717");
+    const source = plugin.source === "local" ? chalk21.blue("local") : chalk21.magenta("npm");
+    console.log(`  ${status} ${chalk21.white.bold(plugin.manifest.name)} ${chalk21.gray(`v${plugin.manifest.version}`)} ${source}`);
+    console.log(chalk21.gray(`    ${plugin.manifest.description}`));
+    if (plugin.manifest.capabilities.length > 0) {
+      console.log(chalk21.gray(`    Capabilities: ${plugin.manifest.capabilities.join(", ")}`));
+    }
+  }
+  console.log("");
+  console.log(chalk21.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk21.gray(`  Local    : ${localPlugins.length}`));
+  console.log(chalk21.gray(`  NPM      : ${npmPlugins.length}`));
+  console.log(chalk21.gray(`  Healthy  : ${allPlugins.filter((p) => p.healthy).length}/${allPlugins.length}`));
+  console.log(chalk21.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log("");
+}
+
+// src/commands/features.ts
+import chalk22 from "chalk";
+import ora11 from "ora";
+import fsExtra from "fs-extra";
+import { resolve as resolve2, join as join10 } from "path";
+var DIRECTORY_COPY_TARGETS = [
+  { source: "skills", target: "skills" },
+  { source: "extensions", target: "extensions" },
+  { source: "src/routing", target: "src/routing" },
+  { source: "src/pairing", target: "src/pairing" },
+  { source: "src/channels/plugins", target: "src/channels/plugins" },
+  { source: "src/channels/allowlists", target: "src/channels/allowlists" }
+];
+var FILE_COPY_TARGETS = [
+  { source: "src/channels/allowlist-match.ts", target: "src/channels/allowlist-match.ts" },
+  { source: "src/channels/channel-config.ts", target: "src/channels/channel-config.ts" }
+];
+var ALL_DIRECTORY_COPY_TARGETS = [
+  { source: "dist", target: "dist" },
+  { source: "skills", target: "skills" },
+  { source: "extensions", target: "extensions" },
+  { source: "src", target: "src" },
+  { source: "scripts", target: "scripts" },
+  { source: "docs", target: "docs" },
+  { source: "test", target: "test" },
+  { source: "apps", target: "apps" },
+  { source: "assets", target: "assets" },
+  { source: "prisma", target: "prisma" },
+  { source: "ui", target: "ui" },
+  { source: "vendor", target: "vendor" },
+  { source: "website", target: "website" }
+];
+var ALL_FILE_COPY_TARGETS = [
+  { source: "agdi.mjs", target: "agdi.mjs" },
+  { source: "README.md", target: "README.md" },
+  { source: "LICENSE", target: "LICENSE" },
+  { source: "CHANGELOG.md", target: "CHANGELOG.md" },
+  { source: "SECURITY.md", target: "SECURITY.md" },
+  { source: "CONTRIBUTING.md", target: "CONTRIBUTING.md" },
+  { source: "pnpm-lock.yaml", target: "pnpm-lock.yaml" },
+  { source: "pnpm-workspace.yaml", target: "pnpm-workspace.yaml" },
+  { source: "tsconfig.json", target: "tsconfig.json" },
+  { source: "tsconfig.test.json", target: "tsconfig.test.json" },
+  { source: "vitest.config.ts", target: "vitest.config.ts" },
+  { source: "vitest.e2e.config.ts", target: "vitest.e2e.config.ts" },
+  { source: "vitest.unit.config.ts", target: "vitest.unit.config.ts" }
+];
+var EXCLUDED_PATH_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"]);
+var EXCLUDED_ALL_PATH_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", ".next"]);
+function shouldIncludePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const segments = normalized.split("/");
+  return !segments.some((segment) => EXCLUDED_PATH_SEGMENTS.has(segment));
+}
+async function copyTargetPaths(sourceRepo, targetRoot) {
+  for (const target of DIRECTORY_COPY_TARGETS) {
+    const sourcePath = join10(sourceRepo, target.source);
+    const targetPath = join10(targetRoot, target.target);
+    if (!await fsExtra.pathExists(sourcePath)) {
+      continue;
+    }
+    await fsExtra.ensureDir(targetPath);
+    await fsExtra.copy(sourcePath, targetPath, {
+      overwrite: true,
+      filter: (source) => shouldIncludePath(source)
+    });
+  }
+  for (const target of FILE_COPY_TARGETS) {
+    const sourcePath = join10(sourceRepo, target.source);
+    const targetPath = join10(targetRoot, target.target);
+    if (!await fsExtra.pathExists(sourcePath)) {
+      continue;
+    }
+    await fsExtra.ensureDir(join10(targetPath, ".."));
+    await fsExtra.copy(sourcePath, targetPath, { overwrite: true });
+  }
+}
+function shouldIncludeAllPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const segments = normalized.split("/");
+  return !segments.some((segment) => EXCLUDED_ALL_PATH_SEGMENTS.has(segment));
+}
+async function copyAllTargetPaths(sourceRepo, targetRoot) {
+  for (const target of ALL_DIRECTORY_COPY_TARGETS) {
+    const sourcePath = join10(sourceRepo, target.source);
+    const targetPath = join10(targetRoot, target.target);
+    if (!await fsExtra.pathExists(sourcePath)) {
+      continue;
+    }
+    await fsExtra.ensureDir(targetPath);
+    await fsExtra.copy(sourcePath, targetPath, {
+      overwrite: true,
+      filter: (source) => shouldIncludeAllPath(source)
+    });
+  }
+  for (const target of ALL_FILE_COPY_TARGETS) {
+    const sourcePath = join10(sourceRepo, target.source);
+    const targetPath = join10(targetRoot, target.target);
+    if (!await fsExtra.pathExists(sourcePath)) {
+      continue;
+    }
+    await fsExtra.ensureDir(join10(targetPath, ".."));
+    await fsExtra.copy(sourcePath, targetPath, { overwrite: true });
+  }
+}
+async function writeMirrorPackageJson(targetRoot) {
+  const packageJsonPath = join10(targetRoot, "package.json");
+  const packageJson = {
+    name: "agdi-upstream-mirror",
     private: true,
     type: "module",
     description: "Mirrored upstream Agdi feature/runtime surface for Agdi-dev"
@@ -5761,8 +7278,8 @@ async function writeMirrorPackageJson(targetRoot) {
   await fsExtra.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
 async function ensureMirrorNodeModules(sourceRepo, targetRoot) {
-  const sourceNodeModules = join6(sourceRepo, "node_modules");
-  const targetNodeModules = join6(targetRoot, "node_modules");
+  const sourceNodeModules = join10(sourceRepo, "node_modules");
+  const targetNodeModules = join10(targetRoot, "node_modules");
   if (!await fsExtra.pathExists(sourceNodeModules)) {
     return "missing";
   }
@@ -5785,7 +7302,7 @@ async function ensureMirrorNodeModules(sourceRepo, targetRoot) {
   }
 }
 async function listSkills(targetRoot) {
-  const skillsRoot = join6(targetRoot, "skills");
+  const skillsRoot = join10(targetRoot, "skills");
   if (!await fsExtra.pathExists(skillsRoot)) {
     return [];
   }
@@ -5796,7 +7313,7 @@ async function listSkills(targetRoot) {
       continue;
     }
     const skillName = entry.name;
-    const skillFile = join6(skillsRoot, skillName, "SKILL.md");
+    const skillFile = join10(skillsRoot, skillName, "SKILL.md");
     if (await fsExtra.pathExists(skillFile)) {
       result.push(skillName);
     }
@@ -5804,7 +7321,7 @@ async function listSkills(targetRoot) {
   return result.sort();
 }
 async function listExtensions(targetRoot) {
-  const extensionsRoot = join6(targetRoot, "extensions");
+  const extensionsRoot = join10(targetRoot, "extensions");
   if (!await fsExtra.pathExists(extensionsRoot)) {
     return [];
   }
@@ -5814,7 +7331,7 @@ async function listExtensions(targetRoot) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const manifestPath = join6(extensionsRoot, entry.name, "agdi.plugin.json");
+    const manifestPath = join10(extensionsRoot, entry.name, "agdi.plugin.json");
     if (!await fsExtra.pathExists(manifestPath)) {
       continue;
     }
@@ -5831,7 +7348,7 @@ async function listExtensions(targetRoot) {
   return result.sort();
 }
 async function listTypeScriptFiles(targetRoot, relativePath) {
-  const root = join6(targetRoot, relativePath);
+  const root = join10(targetRoot, relativePath);
   if (!await fsExtra.pathExists(root)) {
     return 0;
   }
@@ -5844,7 +7361,7 @@ async function listTypeScriptFiles(targetRoot, relativePath) {
     }
     const entries = await fsExtra.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = join6(current, entry.name);
+      const absolutePath = join10(current, entry.name);
       if (!shouldIncludePath(absolutePath)) {
         continue;
       }
@@ -5864,17 +7381,17 @@ async function runFeaturesCommand(options) {
   const sourceRepo = resolve2(cwd, options.from ?? "../Agdi");
   const targetRoot = resolve2(cwd, options.to ?? "./upstream/agdi");
   console.log("");
-  console.log(chalk16.cyan.bold(options.all ? "Feature Mirror" : "Feature Packs"));
-  console.log(chalk16.gray(`  Source: ${sourceRepo}`));
-  console.log(chalk16.gray(`  Target: ${targetRoot}`));
+  console.log(chalk22.cyan.bold(options.all ? "Feature Mirror" : "Feature Packs"));
+  console.log(chalk22.gray(`  Source: ${sourceRepo}`));
+  console.log(chalk22.gray(`  Target: ${targetRoot}`));
   console.log("");
   if (options.sync) {
-    const spinner = ora6(
+    const spinner = ora11(
       options.all ? "Syncing full upstream Agdi mirror..." : "Syncing feature packs from Agdi..."
     ).start();
     if (!await fsExtra.pathExists(sourceRepo)) {
       spinner.fail("Source Agdi repository not found");
-      console.log(chalk16.red(`Expected source path: ${sourceRepo}`));
+      console.log(chalk22.red(`Expected source path: ${sourceRepo}`));
       return;
     }
     try {
@@ -5890,17 +7407,17 @@ async function runFeaturesCommand(options) {
       spinner.succeed("Sync completed");
       if (options.all && nodeModulesStatus !== null) {
         if (nodeModulesStatus === "linked") {
-          console.log(chalk16.gray("  Mirror node_modules: linked to source repo"));
+          console.log(chalk22.gray("  Mirror node_modules: linked to source repo"));
         } else if (nodeModulesStatus === "missing") {
-          console.log(chalk16.yellow("  Mirror node_modules: source node_modules missing"));
+          console.log(chalk22.yellow("  Mirror node_modules: source node_modules missing"));
         } else {
-          console.log(chalk16.yellow("  Mirror node_modules: failed to link (proxy commands may fail)"));
+          console.log(chalk22.yellow("  Mirror node_modules: failed to link (proxy commands may fail)"));
         }
       }
     } catch (error) {
       spinner.fail("Sync failed");
       const message = error instanceof Error ? error.message : String(error);
-      console.log(chalk16.red(message));
+      console.log(chalk22.red(message));
       return;
     }
   }
@@ -5911,53 +7428,53 @@ async function runFeaturesCommand(options) {
     listTypeScriptFiles(targetRoot, "src/pairing"),
     listTypeScriptFiles(targetRoot, "src/channels")
   ]);
-  console.log(chalk16.white.bold("Imported capabilities:"));
-  console.log(chalk16.gray(`  Skills: ${skills.length}`));
-  console.log(chalk16.gray(`  Channel extensions: ${extensions.length}`));
-  console.log(chalk16.gray(`  Routing TS files: ${routingTs}`));
-  console.log(chalk16.gray(`  Pairing TS files: ${pairingTs}`));
-  console.log(chalk16.gray(`  Channel policy TS files: ${channelPolicyTs}`));
+  console.log(chalk22.white.bold("Imported capabilities:"));
+  console.log(chalk22.gray(`  Skills: ${skills.length}`));
+  console.log(chalk22.gray(`  Channel extensions: ${extensions.length}`));
+  console.log(chalk22.gray(`  Routing TS files: ${routingTs}`));
+  console.log(chalk22.gray(`  Pairing TS files: ${pairingTs}`));
+  console.log(chalk22.gray(`  Channel policy TS files: ${channelPolicyTs}`));
   console.log("");
   if (options.all) {
-    const hasRuntimeEntry = await fsExtra.pathExists(join6(targetRoot, "agdi.mjs"));
-    const hasRuntimeDist = await fsExtra.pathExists(join6(targetRoot, "dist/entry.js"));
-    console.log(chalk16.white.bold("Mirror runtime:"));
-    console.log(chalk16.gray(`  agdi.mjs present: ${hasRuntimeEntry ? "yes" : "no"}`));
-    console.log(chalk16.gray(`  dist/entry.js present: ${hasRuntimeDist ? "yes" : "no"}`));
+    const hasRuntimeEntry = await fsExtra.pathExists(join10(targetRoot, "agdi.mjs"));
+    const hasRuntimeDist = await fsExtra.pathExists(join10(targetRoot, "dist/entry.js"));
+    console.log(chalk22.white.bold("Mirror runtime:"));
+    console.log(chalk22.gray(`  agdi.mjs present: ${hasRuntimeEntry ? "yes" : "no"}`));
+    console.log(chalk22.gray(`  dist/entry.js present: ${hasRuntimeDist ? "yes" : "no"}`));
     console.log("");
   }
   if (extensions.length > 0) {
-    console.log(chalk16.white.bold("Top extensions:"));
-    console.log(chalk16.gray(`  ${extensions.slice(0, 16).join(", ")}`));
+    console.log(chalk22.white.bold("Top extensions:"));
+    console.log(chalk22.gray(`  ${extensions.slice(0, 16).join(", ")}`));
     console.log("");
   }
   if (skills.length > 0) {
-    console.log(chalk16.white.bold("Top skills:"));
-    console.log(chalk16.gray(`  ${skills.slice(0, 16).join(", ")}`));
+    console.log(chalk22.white.bold("Top skills:"));
+    console.log(chalk22.gray(`  ${skills.slice(0, 16).join(", ")}`));
     console.log("");
   }
 }
 
 // src/commands/channels.ts
-import chalk17 from "chalk";
-import fs12 from "fs-extra";
-import path13 from "path";
+import chalk23 from "chalk";
+import fs16 from "fs-extra";
+import path18 from "path";
 
 // src/extensions/channel-runtime.ts
 import os3 from "os";
-import path12 from "path";
+import path17 from "path";
 
 // src/extensions/registry.ts
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs14 from "fs-extra";
+import path15 from "path";
 function resolveUpstreamExtensionsRoot(startDir = process.cwd()) {
-  let current = path10.resolve(startDir);
+  let current = path15.resolve(startDir);
   while (true) {
-    const candidate = path10.join(current, "upstream", "agdi", "extensions");
-    if (fs10.existsSync(candidate)) {
+    const candidate = path15.join(current, "upstream", "agdi", "extensions");
+    if (fs14.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path10.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) {
       break;
     }
@@ -5966,22 +7483,22 @@ function resolveUpstreamExtensionsRoot(startDir = process.cwd()) {
   return null;
 }
 async function discoverExtensions(extensionsRoot) {
-  if (!await fs10.pathExists(extensionsRoot)) {
+  if (!await fs14.pathExists(extensionsRoot)) {
     return [];
   }
-  const entries = await fs10.readdir(extensionsRoot, { withFileTypes: true });
+  const entries = await fs14.readdir(extensionsRoot, { withFileTypes: true });
   const discovered = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const extensionDir = path10.join(extensionsRoot, entry.name);
-    const manifestPath = path10.join(extensionDir, "agdi.plugin.json");
-    if (!await fs10.pathExists(manifestPath)) {
+    const extensionDir = path15.join(extensionsRoot, entry.name);
+    const manifestPath = path15.join(extensionDir, "agdi.plugin.json");
+    if (!await fs14.pathExists(manifestPath)) {
       continue;
     }
     try {
-      const manifest = await fs10.readJson(manifestPath);
+      const manifest = await fs14.readJson(manifestPath);
       if (!manifest || typeof manifest.id !== "string" || manifest.id.trim().length === 0) {
         continue;
       }
@@ -6017,12 +7534,12 @@ function discoverChannels(extensions) {
 }
 
 // src/extensions/whatsapp-runtime.ts
-import fs11 from "fs-extra";
+import fs15 from "fs-extra";
 import os2 from "os";
-import path11 from "path";
+import path16 from "path";
 function expandHomeDir(input6) {
   if (input6.startsWith("~/") || input6 === "~") {
-    return path11.join(os2.homedir(), input6.slice(2));
+    return path16.join(os2.homedir(), input6.slice(2));
   }
   return input6;
 }
@@ -6045,10 +7562,10 @@ async function closeSocket(socket) {
 }
 async function sendWhatsAppTextMessage(options) {
   const targetJid = normalizeWhatsAppJid(options.to);
-  const authDir = path11.resolve(expandHomeDir(options.authDir ?? path11.join(os2.homedir(), ".agdi", "whatsapp-auth")));
+  const authDir = path16.resolve(expandHomeDir(options.authDir ?? path16.join(os2.homedir(), ".agdi", "whatsapp-auth")));
   const timeoutMs = options.timeoutMs ?? 9e4;
   const printQr = options.printQr ?? true;
-  await fs11.ensureDir(authDir);
+  await fs15.ensureDir(authDir);
   const baileys = await import("./lib-2XISBYT3.js");
   const makeWASocket = baileys.makeWASocket;
   const useMultiFileAuthState = baileys.useMultiFileAuthState;
@@ -6152,7 +7669,7 @@ function expandHomeDir2(input6) {
     return os3.homedir();
   }
   if (input6.startsWith("~/")) {
-    return path12.join(os3.homedir(), input6.slice(2));
+    return path17.join(os3.homedir(), input6.slice(2));
   }
   return input6;
 }
@@ -6164,8 +7681,8 @@ function normalizeBaseUrl(url) {
   return cleaned.replace(/\/+$/, "");
 }
 function resolveChannelRuntimeConfig(config) {
-  const whatsappAuthDirRaw = cleanValue(process.env.AGDI_WHATSAPP_AUTH_DIR) || cleanValue(config.channelRuntime?.whatsapp?.authDir) || path12.join(os3.homedir(), ".agdi", "whatsapp-auth");
-  const whatsappAuthDir = path12.resolve(expandHomeDir2(whatsappAuthDirRaw));
+  const whatsappAuthDirRaw = cleanValue(process.env.AGDI_WHATSAPP_AUTH_DIR) || cleanValue(config.channelRuntime?.whatsapp?.authDir) || path17.join(os3.homedir(), ".agdi", "whatsapp-auth");
+  const whatsappAuthDir = path17.resolve(expandHomeDir2(whatsappAuthDirRaw));
   return {
     slackWebhook: cleanValue(process.env.AGDI_WEBHOOK_SLACK) || cleanValue(config.channelRuntime?.slack?.webhookUrl),
     discordWebhook: cleanValue(process.env.AGDI_WEBHOOK_DISCORD) || cleanValue(config.channelRuntime?.discord?.webhookUrl),
@@ -6373,31 +7890,31 @@ async function sendChannelMessage(request, config) {
 async function runChannelsListCommand() {
   const { root, statuses } = await getChannelRuntimeStatuses();
   console.log("");
-  console.log(chalk17.cyan.bold("Channel Runtime"));
+  console.log(chalk23.cyan.bold("Channel Runtime"));
   if (!root) {
-    console.log(chalk17.yellow("No synced upstream extensions found."));
-    console.log(chalk17.gray("Run: pnpm features:sync"));
+    console.log(chalk23.yellow("No synced upstream extensions found."));
+    console.log(chalk23.gray("Run: pnpm features:sync"));
     console.log("");
     return;
   }
-  console.log(chalk17.gray(`  Source: ${root}`));
+  console.log(chalk23.gray(`  Source: ${root}`));
   console.log("");
   if (statuses.length === 0) {
-    console.log(chalk17.yellow("No channel manifests discovered."));
+    console.log(chalk23.yellow("No channel manifests discovered."));
     console.log("");
     return;
   }
   const executable = statuses.filter((s) => s.executable).length;
   const nonExecutable = statuses.length - executable;
-  console.log(chalk17.white(`Channels discovered: ${statuses.length}`));
-  console.log(chalk17.green(`Executable now: ${executable}`));
-  console.log(chalk17.gray(`Manifest-only: ${nonExecutable}`));
+  console.log(chalk23.white(`Channels discovered: ${statuses.length}`));
+  console.log(chalk23.green(`Executable now: ${executable}`));
+  console.log(chalk23.gray(`Manifest-only: ${nonExecutable}`));
   console.log("");
   for (const status of statuses) {
-    const marker = status.executable ? chalk17.green("ready") : chalk17.yellow("manifest");
-    const reason = status.reason ? chalk17.gray(` (${status.reason})`) : "";
+    const marker = status.executable ? chalk23.green("ready") : chalk23.yellow("manifest");
+    const reason = status.reason ? chalk23.gray(` (${status.reason})`) : "";
     console.log(
-      `${marker} ${status.channelId} ${chalk17.gray(`[${status.extensionId}]`)}${reason}`
+      `${marker} ${status.channelId} ${chalk23.gray(`[${status.extensionId}]`)}${reason}`
     );
   }
   console.log("");
@@ -6421,37 +7938,37 @@ async function runChannelsSendCommand(options) {
     config
   );
   console.log("");
-  console.log(chalk17.green.bold("Channel Message Sent"));
-  console.log(chalk17.gray(`  Channel: ${result.channel}`));
-  console.log(chalk17.gray(`  Extension: ${result.extensionId}`));
-  console.log(chalk17.gray(`  Detail: ${result.detail}`));
+  console.log(chalk23.green.bold("Channel Message Sent"));
+  console.log(chalk23.gray(`  Channel: ${result.channel}`));
+  console.log(chalk23.gray(`  Extension: ${result.extensionId}`));
+  console.log(chalk23.gray(`  Detail: ${result.detail}`));
   if (typeof result.responseStatus === "number") {
-    console.log(chalk17.gray(`  HTTP status: ${result.responseStatus}`));
+    console.log(chalk23.gray(`  HTTP status: ${result.responseStatus}`));
   }
   console.log("");
 }
 function renderLevel(level) {
   if (level === "ok") {
-    return chalk17.green("ok");
+    return chalk23.green("ok");
   }
   if (level === "warn") {
-    return chalk17.yellow("warn");
+    return chalk23.yellow("warn");
   }
-  return chalk17.red("error");
+  return chalk23.red("error");
 }
 async function runChannelsDoctorCommand() {
   const config = loadConfig();
   const runtime = resolveChannelRuntimeConfig(config);
   const { root, statuses } = await getChannelRuntimeStatuses();
   console.log("");
-  console.log(chalk17.cyan.bold("Channel Doctor"));
+  console.log(chalk23.cyan.bold("Channel Doctor"));
   if (!root) {
-    console.log(chalk17.red("upstream/agdi/extensions not found."));
-    console.log(chalk17.gray("Run: pnpm features:sync"));
+    console.log(chalk23.red("upstream/agdi/extensions not found."));
+    console.log(chalk23.gray("Run: pnpm features:sync"));
     console.log("");
     return;
   }
-  console.log(chalk17.gray(`  Source: ${root}`));
+  console.log(chalk23.gray(`  Source: ${root}`));
   console.log("");
   const executable = /* @__PURE__ */ new Map();
   for (const status of statuses) {
@@ -6461,7 +7978,7 @@ async function runChannelsDoctorCommand() {
     executable.set(status.channelId, { extensionId: status.extensionId });
   }
   if (executable.size === 0) {
-    console.log(chalk17.yellow("No executable channels found."));
+    console.log(chalk23.yellow("No executable channels found."));
     console.log("");
     return;
   }
@@ -6524,8 +8041,8 @@ async function runChannelsDoctorCommand() {
       continue;
     }
     if (channelId === "whatsapp") {
-      const credsPath = path13.join(runtime.whatsappAuthDir, "creds.json");
-      const hasCreds = await fs12.pathExists(credsPath);
+      const credsPath = path18.join(runtime.whatsappAuthDir, "creds.json");
+      const hasCreds = await fs16.pathExists(credsPath);
       if (!hasCreds && !runtime.whatsappPrintQr) {
         items.push({
           channelId,
@@ -6571,20 +8088,20 @@ async function runChannelsDoctorCommand() {
   const errorCount = items.filter((item) => item.level === "error").length;
   for (const item of items) {
     console.log(
-      `${renderLevel(item.level)} ${item.channelId} ${chalk17.gray(`[${item.extensionId}]`)} ${chalk17.gray("-")} ${item.detail}`
+      `${renderLevel(item.level)} ${item.channelId} ${chalk23.gray(`[${item.extensionId}]`)} ${chalk23.gray("-")} ${item.detail}`
     );
   }
   console.log("");
-  console.log(chalk17.white(`Checked: ${items.length}`));
-  console.log(chalk17.green(`OK: ${okCount}`));
-  console.log(chalk17.yellow(`Warnings: ${warnCount}`));
-  console.log(chalk17.red(`Errors: ${errorCount}`));
+  console.log(chalk23.white(`Checked: ${items.length}`));
+  console.log(chalk23.green(`OK: ${okCount}`));
+  console.log(chalk23.yellow(`Warnings: ${warnCount}`));
+  console.log(chalk23.red(`Errors: ${errorCount}`));
   console.log("");
 }
 
 // src/commands/gateway.ts
 import net from "net";
-import chalk18 from "chalk";
+import chalk24 from "chalk";
 function resolveGatewayTarget(options) {
   const host = options.host?.trim() || process.env.AGDI_GATEWAY_HOST || "127.0.0.1";
   const rawPort = options.port ?? process.env.AGDI_GATEWAY_PORT ?? "18789";
@@ -6628,17 +8145,17 @@ async function runGatewayStatusCommand(options) {
   const open = await checkPortOpen(target);
   const health = open ? await fetchGatewayHealth(target) : { ok: false };
   console.log("");
-  console.log(chalk18.cyan.bold("Gateway Status (native Agdi-dev)"));
-  console.log(chalk18.gray(`  Target: ws://${target.host}:${target.port}`));
-  console.log(chalk18.gray(`  Port open: ${open ? "yes" : "no"}`));
+  console.log(chalk24.cyan.bold("Gateway Status (native Agdi-dev)"));
+  console.log(chalk24.gray(`  Target: ws://${target.host}:${target.port}`));
+  console.log(chalk24.gray(`  Port open: ${open ? "yes" : "no"}`));
   if (health.status !== void 0) {
-    console.log(chalk18.gray(`  Health HTTP: ${health.status}`));
+    console.log(chalk24.gray(`  Health HTTP: ${health.status}`));
   } else {
-    console.log(chalk18.gray("  Health HTTP: unreachable"));
+    console.log(chalk24.gray("  Health HTTP: unreachable"));
   }
   if (health.body && health.body.trim().length > 0) {
     const trimmed = health.body.length > 240 ? `${health.body.slice(0, 240)}...` : health.body;
-    console.log(chalk18.gray(`  Health body: ${trimmed}`));
+    console.log(chalk24.gray(`  Health body: ${trimmed}`));
   }
   console.log("");
 }
@@ -6647,55 +8164,55 @@ async function runGatewayHealthCommand(options) {
   const health = await fetchGatewayHealth(target);
   if (!health.ok) {
     console.log("");
-    console.log(chalk18.red("Gateway health check failed."));
-    console.log(chalk18.gray(`  Target: http://${target.host}:${target.port}/health`));
+    console.log(chalk24.red("Gateway health check failed."));
+    console.log(chalk24.gray(`  Target: http://${target.host}:${target.port}/health`));
     if (health.status !== void 0) {
-      console.log(chalk18.gray(`  Status: ${health.status}`));
+      console.log(chalk24.gray(`  Status: ${health.status}`));
     }
     console.log("");
     process.exitCode = 1;
     return;
   }
   console.log("");
-  console.log(chalk18.green.bold("Gateway healthy"));
-  console.log(chalk18.gray(`  Target: http://${target.host}:${target.port}/health`));
-  console.log(chalk18.gray(`  Status: ${health.status}`));
+  console.log(chalk24.green.bold("Gateway healthy"));
+  console.log(chalk24.gray(`  Target: http://${target.host}:${target.port}/health`));
+  console.log(chalk24.gray(`  Status: ${health.status}`));
   if (health.body && health.body.trim().length > 0) {
     const trimmed = health.body.length > 240 ? `${health.body.slice(0, 240)}...` : health.body;
-    console.log(chalk18.gray(`  Body: ${trimmed}`));
+    console.log(chalk24.gray(`  Body: ${trimmed}`));
   }
   console.log("");
 }
 
 // src/commands/upstream-proxy.ts
 import { spawn as spawn2 } from "child_process";
-import path14 from "path";
-import fs13 from "fs";
-import chalk19 from "chalk";
+import path19 from "path";
+import fs17 from "fs";
+import chalk25 from "chalk";
 var DEFAULT_UPSTREAM_CANDIDATES = (cwd) => {
   const envRepo = process.env.AGDI_UPSTREAM_REPO?.trim();
   const envBin = process.env.AGDI_UPSTREAM_BIN?.trim();
   const candidates = /* @__PURE__ */ new Set();
   if (envBin) {
-    candidates.add(path14.resolve(cwd, envBin));
+    candidates.add(path19.resolve(cwd, envBin));
   }
   if (envRepo) {
-    candidates.add(path14.resolve(cwd, envRepo, "agdi.mjs"));
-  }
-  candidates.add(path14.resolve(cwd, "upstream/agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../upstream/agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../../upstream/agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../../../upstream/agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../Agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "Agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../../Agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../../../Agdi/agdi.mjs"));
-  candidates.add(path14.resolve(cwd, "../../../../Agdi/agdi.mjs"));
+    candidates.add(path19.resolve(cwd, envRepo, "agdi.mjs"));
+  }
+  candidates.add(path19.resolve(cwd, "upstream/agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../upstream/agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../../upstream/agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../../../upstream/agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../Agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "Agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../../Agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../../../Agdi/agdi.mjs"));
+  candidates.add(path19.resolve(cwd, "../../../../Agdi/agdi.mjs"));
   return [...candidates];
 };
 function resolveUpstreamBin(cwd = process.cwd()) {
   for (const candidate of DEFAULT_UPSTREAM_CANDIDATES(cwd)) {
-    if (fs13.existsSync(candidate)) {
+    if (fs17.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -6719,12 +8236,12 @@ async function runUpstreamProxy(spec) {
   const upstreamBin = resolveUpstreamBin(process.cwd());
   if (!upstreamBin) {
     console.log("");
-    console.log(chalk19.red("Upstream Agdi CLI not found."));
-    console.log(chalk19.gray("Expected one of:"));
+    console.log(chalk25.red("Upstream Agdi CLI not found."));
+    console.log(chalk25.gray("Expected one of:"));
     for (const candidate of DEFAULT_UPSTREAM_CANDIDATES(process.cwd())) {
-      console.log(chalk19.gray(`  - ${candidate}`));
+      console.log(chalk25.gray(`  - ${candidate}`));
     }
-    console.log(chalk19.gray("Set AGDI_UPSTREAM_REPO or AGDI_UPSTREAM_BIN to override."));
+    console.log(chalk25.gray("Set AGDI_UPSTREAM_REPO or AGDI_UPSTREAM_BIN to override."));
     console.log("");
     process.exitCode = 1;
     return;
@@ -6737,7 +8254,7 @@ async function runUpstreamProxy(spec) {
       env: process.env
     });
     child.on("error", (error) => {
-      console.log(chalk19.red(`Failed to run upstream command: ${error.message}`));
+      console.log(chalk25.red(`Failed to run upstream command: ${error.message}`));
       process.exitCode = 1;
       resolve3();
     });
@@ -6745,7 +8262,7 @@ async function runUpstreamProxy(spec) {
       if (typeof code === "number") {
         process.exitCode = code;
       } else if (signal) {
-        console.log(chalk19.red(`Upstream command terminated by signal: ${signal}`));
+        console.log(chalk25.red(`Upstream command terminated by signal: ${signal}`));
         process.exitCode = 1;
       }
       resolve3();
@@ -6760,7 +8277,6 @@ var UPSTREAM_PROXY_COMMANDS = [
   { name: "reset", description: "Reset upstream local state/config" },
   { name: "uninstall", description: "Uninstall upstream local service/data" },
   { name: "message", description: "Upstream message operations (send/read/manage)" },
-  { name: "memory", description: "Upstream memory commands" },
   { name: "agent", aliases: ["agents"], description: "Upstream agent management commands" },
   { name: "status", description: "Upstream gateway status" },
   { name: "health", description: "Upstream health checks" },
@@ -6776,7 +8292,6 @@ var UPSTREAM_PROXY_COMMANDS = [
   { name: "nodes", description: "Upstream node commands" },
   { name: "devices", description: "Upstream device pairing + token management" },
   { name: "node", description: "Upstream node control" },
-  { name: "sandbox", description: "Upstream sandbox tooling" },
   { name: "tui", description: "Upstream terminal UI" },
   { name: "cron", description: "Upstream cron scheduler" },
   { name: "dns", description: "Upstream DNS helpers" },
@@ -6784,7 +8299,6 @@ var UPSTREAM_PROXY_COMMANDS = [
   { name: "hooks", description: "Upstream hooks tooling" },
   { name: "webhooks", description: "Upstream webhook helpers" },
   { name: "pairing", description: "Upstream pairing helpers" },
-  { name: "plugins", description: "Upstream plugin management" },
   { name: "directory", description: "Upstream directory commands" },
   { name: "security", description: "Upstream security helpers" },
   { name: "skills", description: "Upstream skills management" },
@@ -6807,7 +8321,7 @@ function visibleWidth(input6) {
 }
 
 // src/cli/theme.ts
-import chalk20, { Chalk } from "chalk";
+import chalk26, { Chalk } from "chalk";
 var LOBSTER_PALETTE = {
   accent: "#00d5ff",
   accentBright: "#38bdf8",
@@ -6821,7 +8335,7 @@ var LOBSTER_PALETTE = {
 var hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
 var hasNoColorArg = process.argv.includes("--no-color");
 var disableColor = (process.env.NO_COLOR || hasNoColorArg) && !hasForceColor;
-var baseChalk = disableColor ? new Chalk({ level: 0 }) : chalk20;
+var baseChalk = disableColor ? new Chalk({ level: 0 }) : chalk26;
 var hex = (value) => baseChalk.hex(value);
 var theme = {
   accent: hex(LOBSTER_PALETTE.accent),
@@ -7091,8 +8605,8 @@ function formatTerminalLink(label, url, opts) {
   }
   return `\x1B]8;;${safeUrl}\x07${safeLabel}\x1B]8;;\x07`;
 }
-function formatDocsLink(path15, label) {
-  const trimmed = path15.trim();
+function formatDocsLink(path20, label) {
+  const trimmed = path20.trim();
   const url = trimmed.startsWith("http") ? trimmed : `${DOCS_ROOT}${trimmed.startsWith("/") ? trimmed : `/${trimmed}`}`;
   return formatTerminalLink(label ?? url, url, { fallback: url });
 }
@@ -7183,7 +8697,7 @@ program.action(async () => {
     await runWizard();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Goodbye!\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Goodbye!\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7205,7 +8719,7 @@ program.command("auth").description("Configure API keys").option("--status", "Sh
     }
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7223,7 +8737,7 @@ program.command("model").alias("models").description("Change AI model").action(a
     await selectModel();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7244,7 +8758,7 @@ program.command("chat").description("Start a chat session").action(async () => {
     await startChat();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Goodbye!\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Goodbye!\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7262,7 +8776,7 @@ program.command("run [directory]").description("Run a generated project").action
     await runProject(directory);
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7285,10 +8799,10 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
     }
     const activeConfig = getActiveProvider();
     if (!activeConfig) {
-      console.log(chalk21.red("\u274C No API key configured. Run: agdi auth"));
+      console.log(chalk27.red("\u274C No API key configured. Run: agdi auth"));
       return;
     }
-    const spinner = ora7("Generating application...").start();
+    const spinner = ora12("Generating application...").start();
     try {
       const llm = createLLMProvider(activeConfig.provider, {
         apiKey: activeConfig.apiKey,
@@ -7297,52 +8811,52 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
       const pm = new ProjectManager();
       pm.create(options.output.replace("./", ""), prompt);
       const { plan, files } = await generateApp(prompt, llm, (step, file) => {
-        spinner.text = file ? `${step} ${chalk21.gray(file)}` : step;
+        spinner.text = file ? `${step} ${chalk27.gray(file)}` : step;
       });
       pm.updateFiles(files);
       pm.updateDependencies(plan.dependencies);
       if (options.dryRun || ui.flags.dryRun) {
         spinner.stop();
-        console.log(chalk21.cyan.bold("\n\u{1F6A7} DRY RUN SUMMARY\n"));
-        console.log(chalk21.gray(`Project: ${plan.name}
+        console.log(chalk27.cyan.bold("\n\u{1F6A7} DRY RUN SUMMARY\n"));
+        console.log(chalk27.gray(`Project: ${plan.name}
 `));
-        console.log(chalk21.cyan("Files to be created:"));
-        files.forEach((f) => console.log(chalk21.gray(`  \u{1F4C4} ${f.path}`)));
-        console.log(chalk21.cyan("\nDependencies:"));
-        console.log(chalk21.gray(`  \u{1F4E6} ${plan.dependencies.join(", ")}`));
-        console.log(chalk21.green("\n\u2713 Dry run complete. No files written.\n"));
+        console.log(chalk27.cyan("Files to be created:"));
+        files.forEach((f) => console.log(chalk27.gray(`  \u{1F4C4} ${f.path}`)));
+        console.log(chalk27.cyan("\nDependencies:"));
+        console.log(chalk27.gray(`  \u{1F4E6} ${plan.dependencies.join(", ")}`));
+        console.log(chalk27.green("\n\u2713 Dry run complete. No files written.\n"));
         return;
       }
       await writeProject(pm.get(), options.output);
-      spinner.succeed(chalk21.green("App generated!"));
-      console.log(chalk21.gray(`
-\u{1F4C1} Created ${files.length} files in ${chalk21.cyan(options.output)}`));
+      spinner.succeed(chalk27.green("App generated!"));
+      console.log(chalk27.gray(`
+\u{1F4C1} Created ${files.length} files in ${chalk27.cyan(options.output)}`));
       if (ui.flags.saas || options.saas) {
-        console.log(chalk21.cyan("\nSaaS Quick Start:"));
-        console.log(chalk21.gray(`  1) cd ${options.output}`));
-        console.log(chalk21.gray("  2) npm install"));
-        console.log(chalk21.gray("  3) cp .env.example .env"));
-        console.log(chalk21.gray("  4) npx prisma generate"));
-        console.log(chalk21.gray("  5) npx prisma db push"));
-        console.log(chalk21.gray("  6) npm run dev\n"));
+        console.log(chalk27.cyan("\nSaaS Quick Start:"));
+        console.log(chalk27.gray(`  1) cd ${options.output}`));
+        console.log(chalk27.gray("  2) npm install"));
+        console.log(chalk27.gray("  3) cp .env.example .env"));
+        console.log(chalk27.gray("  4) npx prisma generate"));
+        console.log(chalk27.gray("  5) npx prisma db push"));
+        console.log(chalk27.gray("  6) npm run dev\n"));
       } else {
-        console.log(chalk21.gray("\nNext: cd " + options.output + " && npm install && npm run dev\n"));
+        console.log(chalk27.gray("\nNext: cd " + options.output + " && npm install && npm run dev\n"));
       }
     } catch (error) {
       spinner.fail("Generation failed");
       const msg = error instanceof Error ? error.message : String(error);
       if (msg.includes("429") || msg.includes("quota")) {
-        console.log(chalk21.yellow("\n\u26A0\uFE0F  Quota exceeded. Run: agdi model\n"));
+        console.log(chalk27.yellow("\n\u26A0\uFE0F  Quota exceeded. Run: agdi model\n"));
       } else if (msg.includes("401") || msg.includes("403")) {
-        console.log(chalk21.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+        console.log(chalk27.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
       } else {
-        console.error(chalk21.red("\n" + msg + "\n"));
+        console.error(chalk27.red("\n" + msg + "\n"));
       }
       ui.safeExit(1);
     }
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7358,11 +8872,11 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
 program.command("config").description("Show configuration").action(async () => {
   const config = loadConfig();
   const active = getActiveProvider();
-  console.log(chalk21.cyan.bold("\n\u2699\uFE0F  Configuration\n"));
-  console.log(chalk21.gray("  Provider: ") + chalk21.cyan(config.defaultProvider || "not set"));
-  console.log(chalk21.gray("  Model:    ") + chalk21.cyan(config.defaultModel || "not set"));
-  console.log(chalk21.gray("  Config:   ") + chalk21.gray("~/.agdi/config.json"));
-  console.log(chalk21.cyan.bold("\n\u{1F510} API Keys\n"));
+  console.log(chalk27.cyan.bold("\n\u2699\uFE0F  Configuration\n"));
+  console.log(chalk27.gray("  Provider: ") + chalk27.cyan(config.defaultProvider || "not set"));
+  console.log(chalk27.gray("  Model:    ") + chalk27.cyan(config.defaultModel || "not set"));
+  console.log(chalk27.gray("  Config:   ") + chalk27.gray("~/.agdi/config.json"));
+  console.log(chalk27.cyan.bold("\n\u{1F510} API Keys\n"));
   const keys = [
     ["Gemini", config.geminiApiKey],
     ["OpenRouter", config.openrouterApiKey],
@@ -7371,13 +8885,13 @@ program.command("config").description("Show configuration").action(async () => {
     ["DeepSeek", config.deepseekApiKey]
   ];
   for (const [name, key] of keys) {
-    const status = key ? chalk21.green("\u2713") : chalk21.gray("\u2717");
+    const status = key ? chalk27.green("\u2713") : chalk27.gray("\u2717");
     console.log(`  ${status} ${name}`);
   }
-  console.log(chalk21.cyan.bold("\n\u{1F4CA} Telemetry\n"));
+  console.log(chalk27.cyan.bold("\n\u{1F4CA} Telemetry\n"));
   const telemetryEnabled = config.telemetry?.enabled ?? false;
-  console.log(`  ${telemetryEnabled ? chalk21.green("\u2713 Enabled") : chalk21.gray("\u2717 Disabled")}`);
-  console.log(chalk21.gray("  Change with: agdi config telemetry --enable | --disable"));
+  console.log(`  ${telemetryEnabled ? chalk27.green("\u2713 Enabled") : chalk27.gray("\u2717 Disabled")}`);
+  console.log(chalk27.gray("  Change with: agdi config telemetry --enable | --disable"));
   console.log("");
   console.log("");
 });
@@ -7385,59 +8899,59 @@ program.command("config:telemetry").alias("telemetry").description("Manage telem
   const { isTelemetryEnabled, setTelemetryConsent, getTelemetryConfig } = await import("./config-K2XM6D4Z.js");
   const { generateSampleEvent, generateSanitizationDemo } = await import("./telemetry-service-76YPOPDM.js");
   if (options.dryRun || options.test) {
-    console.log(chalk21.cyan.bold("\n\u{1F50D} TELEMETRY TRANSPARENCY MODE\n"));
-    console.log(chalk21.gray("This is exactly what Agdi sends. Notice there is"));
-    console.log(chalk21.green.bold("NO source code, file paths, or API keys.\n"));
-    console.log(chalk21.white.bold('\u{1F4CA} Sample "Build Failed" Event:\n'));
+    console.log(chalk27.cyan.bold("\n\u{1F50D} TELEMETRY TRANSPARENCY MODE\n"));
+    console.log(chalk27.gray("This is exactly what Agdi sends. Notice there is"));
+    console.log(chalk27.green.bold("NO source code, file paths, or API keys.\n"));
+    console.log(chalk27.white.bold('\u{1F4CA} Sample "Build Failed" Event:\n'));
     const sample = generateSampleEvent();
-    console.log(chalk21.gray(JSON.stringify(sample, null, 2)));
-    console.log(chalk21.white.bold("\n\u{1F6E1}\uFE0F  Sanitization Demo:\n"));
-    console.log(chalk21.gray("Even if sensitive data accidentally enters an error message,"));
-    console.log(chalk21.gray("our sanitization layer strips it before transmission:\n"));
+    console.log(chalk27.gray(JSON.stringify(sample, null, 2)));
+    console.log(chalk27.white.bold("\n\u{1F6E1}\uFE0F  Sanitization Demo:\n"));
+    console.log(chalk27.gray("Even if sensitive data accidentally enters an error message,"));
+    console.log(chalk27.gray("our sanitization layer strips it before transmission:\n"));
     const demo = generateSanitizationDemo();
-    console.log(chalk21.red.bold("BEFORE sanitization (never sent):"));
-    console.log(chalk21.gray(JSON.stringify({
+    console.log(chalk27.red.bold("BEFORE sanitization (never sent):"));
+    console.log(chalk27.gray(JSON.stringify({
       errorCode: demo.before.errorCode,
       feedback: demo.before.feedback
     }, null, 2)));
-    console.log(chalk21.green.bold("\nAFTER sanitization (what we actually send):"));
-    console.log(chalk21.gray(JSON.stringify({
+    console.log(chalk27.green.bold("\nAFTER sanitization (what we actually send):"));
+    console.log(chalk27.gray(JSON.stringify({
       errorCode: demo.after.errorCode,
       feedback: demo.after.feedback
     }, null, 2)));
-    console.log(chalk21.cyan("\n\u2705 Your code and secrets are NEVER transmitted."));
-    console.log(chalk21.gray("   Learn more: https://agdi-dev.vercel.app/privacy\n"));
+    console.log(chalk27.cyan("\n\u2705 Your code and secrets are NEVER transmitted."));
+    console.log(chalk27.gray("   Learn more: https://agdi-dev.vercel.app/privacy\n"));
     return;
   }
   if (options.enable) {
     setTelemetryConsent(true);
-    console.log(chalk21.green("\n\u2705 Telemetry enabled"));
-    console.log(chalk21.gray("   We collect: success/fail, error types, model used"));
-    console.log(chalk21.gray("   We NEVER collect: source code, API keys, file paths"));
-    console.log(chalk21.gray("   Verify anytime: agdi config telemetry --dry-run\n"));
+    console.log(chalk27.green("\n\u2705 Telemetry enabled"));
+    console.log(chalk27.gray("   We collect: success/fail, error types, model used"));
+    console.log(chalk27.gray("   We NEVER collect: source code, API keys, file paths"));
+    console.log(chalk27.gray("   Verify anytime: agdi config telemetry --dry-run\n"));
   } else if (options.disable) {
     setTelemetryConsent(false);
-    console.log(chalk21.yellow("\n\u{1F4CA} Telemetry disabled"));
-    console.log(chalk21.gray("   You can re-enable anytime with: agdi config telemetry --enable\n"));
+    console.log(chalk27.yellow("\n\u{1F4CA} Telemetry disabled"));
+    console.log(chalk27.gray("   You can re-enable anytime with: agdi config telemetry --enable\n"));
   } else {
     const config = getTelemetryConfig();
-    console.log(chalk21.cyan.bold("\n\u{1F4CA} Telemetry Status\n"));
-    console.log(chalk21.gray("  Enabled:  ") + (config.enabled ? chalk21.green("Yes") : chalk21.gray("No")));
-    console.log(chalk21.gray("  Consent:  ") + (config.consentAsked ? chalk21.green("Asked") : chalk21.gray("Not asked")));
+    console.log(chalk27.cyan.bold("\n\u{1F4CA} Telemetry Status\n"));
+    console.log(chalk27.gray("  Enabled:  ") + (config.enabled ? chalk27.green("Yes") : chalk27.gray("No")));
+    console.log(chalk27.gray("  Consent:  ") + (config.consentAsked ? chalk27.green("Asked") : chalk27.gray("Not asked")));
     if (config.anonymousId) {
-      console.log(chalk21.gray("  ID:       ") + chalk21.gray(config.anonymousId.slice(0, 8) + "..."));
+      console.log(chalk27.gray("  ID:       ") + chalk27.gray(config.anonymousId.slice(0, 8) + "..."));
     }
     console.log("");
-    console.log(chalk21.gray("  Enable:   agdi config telemetry --enable"));
-    console.log(chalk21.gray("  Disable:  agdi config telemetry --disable"));
-    console.log(chalk21.gray("  Verify:   agdi config telemetry --dry-run\n"));
+    console.log(chalk27.gray("  Enable:   agdi config telemetry --enable"));
+    console.log(chalk27.gray("  Disable:  agdi config telemetry --disable"));
+    console.log(chalk27.gray("  Verify:   agdi config telemetry --dry-run\n"));
   }
 });
 program.command("doctor").alias("doc").description("Run self-diagnosis checks").action(async () => {
   try {
     await runDoctor();
   } catch (error) {
-    console.error(chalk21.red("Diagnostic failed: " + error));
+    console.error(chalk27.red("Diagnostic failed: " + error));
     ui.safeExit(1);
   }
 });
@@ -7446,7 +8960,7 @@ program.command("features").description("List or sync upstream Agdi feature pack
     await runFeaturesCommand(options);
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7465,7 +8979,7 @@ channelsCommand.command("list").description("List discovered channel extensions
     await runChannelsListCommand();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7483,7 +8997,7 @@ channelsCommand.command("send").description("Send a message through a supported
     await runChannelsSendCommand(options);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(chalk21.red(`
+    console.log(chalk27.red(`
 ${message}
 `));
     try {
@@ -7497,7 +9011,7 @@ channelsCommand.command("doctor").description("Validate tokens/webhooks/session
     await runChannelsDoctorCommand();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(chalk21.red(`
+    console.log(chalk27.red(`
 ${message}
 `));
     try {
@@ -7526,7 +9040,7 @@ function registerUpstreamProxyCommand(spec) {
   if (requestedNames.some((name) => existingNames.has(name))) {
     return;
   }
-  const command = program.command(`${spec.name} [args...]`).description(`${spec.description} ${chalk21.gray("(proxied to upstream Agdi)")}`).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).action(async () => {
+  const command = program.command(`${spec.name} [args...]`).description(`${spec.description} ${chalk27.gray("(proxied to upstream Agdi)")}`).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).action(async () => {
     await runUpstreamProxy(spec);
   });
   for (const alias of spec.aliases ?? []) {
@@ -7536,14 +9050,135 @@ function registerUpstreamProxyCommand(spec) {
 for (const spec of UPSTREAM_PROXY_COMMANDS) {
   registerUpstreamProxyCommand(spec);
 }
-program.command("squad [prompt]").alias("s").description("\u{1F9B8} Autonomous multi-agent app builder").option("-d, --deploy", "Auto-deploy to Vercel after build").option("-o, --output <dir>", "Output directory", "./").option("-v, --verbose", "Show detailed agent logs", true).action(async (prompt, options) => {
+program.command("audit").description("\u{1F50D} Scan codebase for production-readiness issues").option("--prod", "Strict production mode (errors on a11y/security/test gaps)").option("--fix", "Auto-fix issues using the QA agent").option("-o, --output <dir>", "Directory to scan", "./").action(async (options) => {
+  try {
+    const result = await runAuditCommand({
+      prod: options.prod,
+      fix: options.fix,
+      output: options.output
+    });
+    if (!result.passed && options.prod) {
+      ui.safeExit(1);
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("sandbox <url>").description("\u{1F9EA} Read live API docs and extract endpoints").option("--test", "Ping discovered endpoints to verify response shape").option("--inject", "Prepare endpoint summary for Squad context injection").option("--api-key <key>", "API key for authenticated endpoints").action(async (url, options) => {
+  try {
+    await runSandboxCommand(url, {
+      test: options.test,
+      inject: options.inject,
+      apiKey: options.apiKey
+    });
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("visual-test").alias("vt").description("\u{1F4F8} Run visual regression tests on your app").option("--routes <routes>", "Comma-separated routes to test (default: auto-discover)").option("--update", "Update baseline screenshots").option("--port <port>", "Dev server port", "3000").option("-o, --output <dir>", "Workspace directory", "./").action(async (options) => {
+  try {
+    await runVisualTestCommand({
+      routes: options.routes,
+      update: options.update,
+      port: parseInt(options.port, 10),
+      output: options.output
+    });
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("memory").alias("mem").description("\u{1F9E0} Analyze git history for project context").option("--depth <n>", "Number of commits to analyze", "30").option("--inject", "Prepare context for Squad injection").option("-o, --output <dir>", "Workspace directory", "./").action(async (options) => {
+  try {
+    await runMemoryCommand({
+      depth: parseInt(options.depth, 10),
+      inject: options.inject,
+      output: options.output
+    });
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("deps").description("\u{1F6E1}\uFE0F Scan dependencies for vulnerabilities").option("--full", "Full audit including outdated packages").option("--fix", "Auto-fix vulnerabilities with npm audit fix").option("-o, --output <dir>", "Workspace directory", "./").action(async (options) => {
+  try {
+    const result = await runDepsScanCommand({
+      full: options.full,
+      fix: options.fix,
+      output: options.output
+    });
+    if (!result.passed) {
+      ui.safeExit(1);
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("plugins").alias("plug").description("\u{1F50C} Manage Agdi plugins and extensions").option("--install <name>", "Install a plugin from npm").option("--init", "Create a new plugin template").option("-o, --output <dir>", "Workspace directory", "./").action(async (options) => {
+  try {
+    await runPluginsCommand({
+      install: options.install,
+      init: options.init,
+      output: options.output
+    });
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
+      try {
+        ui.safeExit(0);
+      } catch {
+      }
+      return;
+    }
+    throw error;
+  }
+});
+program.command("squad [prompt]").alias("s").description("\u{1F9B8} Autonomous multi-agent app builder").option("-d, --deploy", "Auto-deploy to Vercel after build").option("-o, --output <dir>", "Output directory", "./").option("-v, --verbose", "Show detailed agent logs", true).option("--breakpoints", "Pause after each agent task for review (AI Breakpoints)").action(async (prompt, options) => {
   try {
     if (needsOnboarding()) {
       await runOnboarding();
     }
     const activeConfig = getActiveProvider();
     if (!activeConfig) {
-      console.log(chalk21.red("\u274C No API key configured. Run: agdi auth"));
+      console.log(chalk27.red("\u274C No API key configured. Run: agdi auth"));
       return;
     }
     const llm = createLLMProvider(activeConfig.provider, {
@@ -7553,11 +9188,12 @@ program.command("squad [prompt]").alias("s").description("\u{1F9B8} Autonomous m
     await runSquadCommand(prompt, llm, {
       deploy: options.deploy,
       output: options.output,
-      verbose: options.verbose
+      verbose: options.verbose,
+      breakpoints: options.breakpoints
     });
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7585,7 +9221,7 @@ program.command("replay <runId>").description("\u{1F501} Replay a previous squad
     }
     const activeConfig = getActiveProvider();
     if (!activeConfig) {
-      console.log(chalk21.red("\u274C No API key configured. Run: agdi auth"));
+      console.log(chalk27.red("\u274C No API key configured. Run: agdi auth"));
       return;
     }
     const llm = createLLMProvider(activeConfig.provider, {
@@ -7599,7 +9235,7 @@ program.command("replay <runId>").description("\u{1F501} Replay a previous squad
     });
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7617,7 +9253,7 @@ program.command("import <url>").alias("i").description("\u{1F4E6} Import a GitHu
     await runImportCommand(url, options.output);
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
       try {
         ui.safeExit(0);
       } catch {
@@ -7631,7 +9267,7 @@ program.command("wizard").alias("w").description("\u{1F9D9} Start the Agdi Setup
   try {
     await runWizard();
   } catch (error) {
-    console.log(chalk21.gray("\n\n\u{1F44B} Cancelled.\n"));
+    console.log(chalk27.gray("\n\n\u{1F44B} Cancelled.\n"));
     try {
       ui.safeExit(0);
     } catch {