@arvoretech/hub 0.13.4 → 0.17.0

package/dist/index.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 import {
   checkAndAutoRegenerate,
-  generateCommand
-} from "./chunk-VE7RLHHJ.js";
+  colors,
+  generateCommand,
+  horizontalLine,
+  personaCommand,
+  symbols
+} from "./chunk-Z4AZNX6V.js";
 import {
   loadHubConfig,
   resolveConfigPath
 } from "./chunk-VMN4KGAK.js";
 
 // src/index.ts
-import { Command as Command20 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/commands/init.ts
 import { Command as Command2 } from "commander";
@@ -23,38 +27,6 @@ import { Box as Box10, useStdout as useStdout4 } from "ink";
 
 // src/tui/components/WelcomeStep.tsx
 import { Box, Text, useInput } from "ink";
-
-// src/tui/theme.ts
-var colors = {
-  brand: "#22c55e",
-  brandDim: "#16a34a",
-  blue: "#3b82f6",
-  purple: "#a78bfa",
-  muted: "#6b7280",
-  dim: "#4b5563",
-  warning: "#eab308",
-  error: "#ef4444",
-  white: "#ffffff"
-};
-var symbols = {
-  check: "\u2713",
-  cross: "\u2717",
-  arrow: "\u276F",
-  dot: "\u25CF",
-  circle: "\u25CB",
-  tree: "\u{1F333}",
-  line: "\u2500",
-  corner: "\u256D",
-  cornerEnd: "\u2570",
-  vertical: "\u2502",
-  cornerRight: "\u256E",
-  cornerEndRight: "\u256F"
-};
-function horizontalLine(width) {
-  return symbols.line.repeat(width);
-}
-
-// src/tui/components/WelcomeStep.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var LOGO = [
   "              \u{1F33F}              ",
@@ -763,7 +735,8 @@ var AVAILABLE_MCPS = [
   { name: "tempmail", description: "Temporary email for testing" },
   { name: "agent-teams-lead", description: "Spawn AI teammate teams that work in parallel on tasks" },
   { name: "agent-teams-chat", description: "Cross-developer agent communication via Slack threads" },
-  { name: "mcp-proxy", description: "Proxy gateway that reduces token usage via mcp_search/mcp_call" }
+  { name: "mcp-proxy", description: "Proxy gateway that reduces token usage via mcp_search/mcp_call" },
+  { name: "kanban", description: "Kanban board for managing agent tasks across sessions" }
 ];
 
 // src/tui/App.tsx
@@ -1279,6 +1252,7 @@ var MCP_HELPER_MAP = {
   context7: { helper: "mcp.context7", hasNameArg: false },
   "agent-teams-lead": { helper: "mcp.agentTeamsLead", hasNameArg: false },
   "agent-teams-chat": { helper: "mcp.agentTeamsChat", hasNameArg: false },
+  kanban: { helper: "mcp.kanban", hasNameArg: false },
   "mcp-proxy": { helper: "mcp.proxy", hasNameArg: true }
 };
 function buildTypeScriptConfig(state) {
@@ -1563,12 +1537,38 @@ import chalk3 from "chalk";
 
 // src/core/docker-compose.ts
 import { stringify as stringify3 } from "yaml";
-function generateDockerCompose(services) {
+import { resolve } from "path";
+var SANDBOX_IMAGE = "ghcr.io/agent-infra/sandbox:latest";
+var SANDBOX_PORT = 8080;
+function buildSandboxEntry(svc, hubDir) {
+  const port = svc.port ?? SANDBOX_PORT;
+  const workspacePath = resolve(hubDir, svc.workspace ?? ".");
+  return {
+    image: SANDBOX_IMAGE,
+    container_name: svc.name,
+    restart: "unless-stopped",
+    security_opt: ["seccomp:unconfined"],
+    shm_size: "2gb",
+    extra_hosts: ["host.docker.internal:host-gateway"],
+    ports: [`${port}:8080`],
+    volumes: [`${workspacePath}:/workspace`],
+    environment: {
+      WORKSPACE: "/workspace",
+      ...svc.env ?? {}
+    }
+  };
+}
+function generateDockerCompose(services, hubDir = process.cwd()) {
   const compose = {
     services: {}
   };
   const svcMap = compose.services;
+  const volumes = {};
   for (const svc of services) {
+    if (svc.type === "sandbox") {
+      svcMap[svc.name] = buildSandboxEntry(svc, hubDir);
+      continue;
+    }
     const entry = {
       image: svc.image,
       restart: "unless-stopped"
@@ -1581,14 +1581,14 @@ function generateDockerCompose(services) {
     if (svc.env) {
       entry.environment = svc.env;
     }
-    entry.volumes = [`${svc.name}_data:/var/lib/${guessDataDir(svc.image)}`];
+    const dataDir = guessDataDir(svc.image ?? svc.name);
+    entry.volumes = [`${svc.name}_data:/var/lib/${dataDir}`];
+    volumes[`${svc.name}_data`] = null;
     svcMap[svc.name] = entry;
   }
-  const volumes = {};
-  for (const svc of services) {
-    volumes[`${svc.name}_data`] = null;
+  if (Object.keys(volumes).length > 0) {
+    compose.volumes = volumes;
   }
-  compose.volumes = volumes;
   return stringify3(compose, { lineWidth: 120 });
 }
 function guessDataDir(image) {
@@ -1982,7 +1982,7 @@ async function ensureCompose(hubDir) {
       console.log(chalk5.yellow("No services defined in hub.yaml"));
       process.exit(1);
     }
-    const content = generateDockerCompose(config.services);
+    const content = generateDockerCompose(config.services, hubDir);
     await writeFile6(composePath, content, "utf-8");
     console.log(chalk5.green("Generated docker-compose.yml"));
   }
@@ -2061,7 +2061,7 @@ var servicesCommand = new Command6("services").description("Manage Docker develo
 import { Command as Command7 } from "commander";
 import { existsSync as existsSync5, statSync } from "fs";
 import { mkdir as mkdir3, readdir, readFile as readFile3, rm, cp } from "fs/promises";
-import { join as join8, resolve } from "path";
+import { join as join8, resolve as resolve2 } from "path";
 import { execSync as execSync4 } from "child_process";
 import chalk6 from "chalk";
 var DEFAULT_REGISTRY_REPO2 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
@@ -2252,7 +2252,7 @@ async function listRemoteSkills(owner, repo) {
   }
 }
 async function addFromLocalPath(localPath, hubDir, opts) {
-  const absPath = resolve(localPath);
+  const absPath = resolve2(localPath);
   if (!existsSync5(absPath)) {
     console.log(chalk6.red(`  Path not found: ${absPath}`));
     return;
@@ -2401,7 +2401,7 @@ Removed skill: ${name}
 import { Command as Command8 } from "commander";
 import { existsSync as existsSync6, statSync as statSync2 } from "fs";
 import { mkdir as mkdir4, readdir as readdir2, readFile as readFile4, rm as rm2, copyFile, writeFile as writeFile7 } from "fs/promises";
-import { join as join9, resolve as resolve2 } from "path";
+import { join as join9, resolve as resolve3 } from "path";
 import { execSync as execSync5 } from "child_process";
 import chalk7 from "chalk";
 var DEFAULT_REGISTRY_REPO3 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
@@ -2449,7 +2449,7 @@ async function addFromRegistry2(agentName, hubDir, opts) {
   }
 }
 async function addFromLocalPath2(localPath, hubDir, opts) {
-  const absPath = resolve2(localPath);
+  const absPath = resolve3(localPath);
   if (!existsSync6(absPath)) {
     console.log(chalk7.red(`  Path not found: ${absPath}`));
     return;
@@ -2658,7 +2658,7 @@ Removed agent: ${name}
 import { Command as Command9 } from "commander";
 import { existsSync as existsSync7, statSync as statSync3 } from "fs";
 import { mkdir as mkdir5, readdir as readdir3, readFile as readFile5, rm as rm3, copyFile as copyFile2, cp as cp2 } from "fs/promises";
-import { join as join10, resolve as resolve3 } from "path";
+import { join as join10, resolve as resolve4 } from "path";
 import { execSync as execSync6 } from "child_process";
 import chalk8 from "chalk";
 var DEFAULT_REGISTRY_REPO4 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
@@ -2671,10 +2671,10 @@ async function listLocalHooks(hooksDir) {
   const entries = await readdir3(hooksDir);
   for (const entry of entries) {
     const entryPath = join10(hooksDir, entry);
-    const stat = statSync3(entryPath);
-    if (stat.isFile() && entry.endsWith(".sh")) {
+    const stat2 = statSync3(entryPath);
+    if (stat2.isFile() && entry.endsWith(".sh")) {
       hooks.push({ name: entry.replace(/\.sh$/, ""), description: "" });
-    } else if (stat.isDirectory()) {
+    } else if (stat2.isDirectory()) {
       const readmePath = join10(entryPath, "README.md");
       let description = "";
       if (existsSync7(readmePath)) {
@@ -2706,13 +2706,13 @@ async function addFromRegistry3(hookName, hubDir, opts) {
   }
 }
 async function addFromLocalPath3(localPath, hubDir, opts) {
-  const absPath = resolve3(localPath);
+  const absPath = resolve4(localPath);
   if (!existsSync7(absPath)) {
     console.log(chalk8.red(`  Path not found: ${absPath}`));
     return;
   }
-  const stat = statSync3(absPath);
-  const sourceHooksDir = stat.isDirectory() ? existsSync7(join10(absPath, "hooks")) ? join10(absPath, "hooks") : absPath : absPath;
+  const stat2 = statSync3(absPath);
+  const sourceHooksDir = stat2.isDirectory() ? existsSync7(join10(absPath, "hooks")) ? join10(absPath, "hooks") : absPath : absPath;
   await installHooksFromDir(sourceHooksDir, hubDir, opts);
 }
 async function installHooksFromDir(sourceDir, hubDir, opts) {
@@ -2739,8 +2739,8 @@ async function installHooksFromDir(sourceDir, hubDir, opts) {
   await mkdir5(targetBase, { recursive: true });
   for (const entry of toInstall) {
     const src = join10(sourceDir, entry);
-    const stat = statSync3(src);
-    if (stat.isDirectory()) {
+    const stat2 = statSync3(src);
+    if (stat2.isDirectory()) {
       await cp2(src, join10(targetBase, entry), { recursive: true });
     } else {
       await copyFile2(src, join10(targetBase, entry));
@@ -2852,7 +2852,7 @@ Hook '${name}' not found in hooks/
 import { Command as Command10 } from "commander";
 import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 import { mkdir as mkdir6, readdir as readdir4, readFile as readFile6, rm as rm4, copyFile as copyFile3, writeFile as writeFile8 } from "fs/promises";
-import { join as join11, resolve as resolve4 } from "path";
+import { join as join11, resolve as resolve5 } from "path";
 import { execSync as execSync7 } from "child_process";
 import chalk9 from "chalk";
 var DEFAULT_REGISTRY_REPO5 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
@@ -2901,13 +2901,13 @@ async function addFromRegistry4(commandName, hubDir, opts) {
   }
 }
 async function addFromLocalPath4(localPath, hubDir, opts) {
-  const absPath = resolve4(localPath);
+  const absPath = resolve5(localPath);
   if (!existsSync8(absPath)) {
     console.log(chalk9.red(`  Path not found: ${absPath}`));
     return;
   }
-  const stat = statSync4(absPath);
-  if (stat.isFile() && absPath.endsWith(".md")) {
+  const stat2 = statSync4(absPath);
+  if (stat2.isFile() && absPath.endsWith(".md")) {
     const targetDir = join11(hubDir, "commands");
     await mkdir6(targetDir, { recursive: true });
     const fileName = absPath.split("/").pop();
@@ -2918,7 +2918,7 @@ async function addFromLocalPath4(localPath, hubDir, opts) {
 `));
     return;
   }
-  const sourceDir = stat.isDirectory() ? existsSync8(join11(absPath, "commands")) ? join11(absPath, "commands") : absPath : absPath;
+  const sourceDir = stat2.isDirectory() ? existsSync8(join11(absPath, "commands")) ? join11(absPath, "commands") : absPath : absPath;
   await installCommandsFromDir(sourceDir, hubDir, opts);
 }
 async function installCommandsFromDir(sourceDir, hubDir, opts) {
@@ -3636,7 +3636,7 @@ function extractVersion(s) {
 import { Command as Command15 } from "commander";
 import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir8, readdir as readdir5, readFile as readFile7, writeFile as writeFile10, rm as rm5, appendFile as appendFile2 } from "fs/promises";
-import { join as join16, resolve as resolve5, basename as basename2 } from "path";
+import { join as join16, resolve as resolve6, basename as basename2 } from "path";
 import chalk14 from "chalk";
 async function ensureLanceDbIgnored(memoriesDir, hubDir) {
   const relative = memoriesDir.replace(hubDir + "/", "");
@@ -3663,7 +3663,7 @@ var VALID_CATEGORIES = [
   "gotchas"
 ];
 function getMemoriesPath(hubDir, configPath) {
-  return resolve5(hubDir, configPath || "memories");
+  return resolve6(hubDir, configPath || "memories");
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -4400,14 +4400,683 @@ var cloneCommand = new Command19("clone").description("Clone all repositories wi
   console.log();
 });
 
+// src/commands/consolidate.ts
+import { Command as Command20 } from "commander";
+import { existsSync as existsSync16 } from "fs";
+import { mkdir as mkdir10, readdir as readdir7, readFile as readFile9, writeFile as writeFile12, stat } from "fs/promises";
+import { join as join20 } from "path";
+import { homedir } from "os";
+import { spawn } from "child_process";
+import { execSync as execSync15 } from "child_process";
+import chalk19 from "chalk";
+var STATE_FILE = ".hub/consolidation-state.json";
+var BATCH_DIR = ".hub/consolidation";
+async function readState(hubDir) {
+  const filePath = join20(hubDir, STATE_FILE);
+  if (!existsSync16(filePath)) return { indexed: {} };
+  try {
+    return JSON.parse(await readFile9(filePath, "utf-8"));
+  } catch {
+    return { indexed: {} };
+  }
+}
+async function writeState(hubDir, state) {
+  const dir = join20(hubDir, ".hub");
+  await mkdir10(dir, { recursive: true });
+  await writeFile12(
+    join20(hubDir, STATE_FILE),
+    JSON.stringify(state, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function detectEditorCli() {
+  const candidates = ["kiro-cli", "claude", "opencode"];
+  for (const cli of candidates) {
+    try {
+      execSync15(`which ${cli}`, { stdio: "pipe" });
+      return cli;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getKiroSessionsDir() {
+  const base = join20(
+    homedir(),
+    "Library",
+    "Application Support",
+    "Kiro",
+    "User",
+    "globalStorage",
+    "kiro.kiroagent",
+    "workspace-sessions"
+  );
+  if (!existsSync16(base)) return null;
+  return base;
+}
+function getClaudeProjectsDir() {
+  const base = join20(homedir(), ".claude", "projects");
+  if (!existsSync16(base)) return null;
+  return base;
+}
+function getOpenCodeStorageDir() {
+  const base = join20(homedir(), ".local", "share", "opencode", "storage");
+  if (!existsSync16(base)) return null;
+  return base;
+}
+async function parseKiroSession(filePath) {
+  try {
+    const raw = JSON.parse(await readFile9(filePath, "utf-8"));
+    const messages = [];
+    if (!raw.history || !Array.isArray(raw.history)) return messages;
+    for (const entry of raw.history) {
+      const msg = entry.message;
+      if (!msg || !msg.role) continue;
+      if (msg.role !== "user" && msg.role !== "assistant") continue;
+      let content = "";
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        content = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      }
+      if (!content || content.length < 5) continue;
+      const isToolOutput = content.startsWith("[") || content.startsWith("{") || content.includes("```\n") && content.length > 2e3;
+      if (msg.role === "assistant" && isToolOutput && content.length > 3e3)
+        continue;
+      messages.push({
+        role: msg.role,
+        content: content.length > 800 ? content.substring(0, 800) + "..." : content
+      });
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+async function parseClaudeSession(filePath) {
+  try {
+    const raw = await readFile9(filePath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (!entry.message || !entry.message.role) continue;
+        if (entry.type === "file-history-snapshot") continue;
+        const role = entry.message.role;
+        if (role !== "user" && role !== "assistant") continue;
+        let content = "";
+        if (typeof entry.message.content === "string") {
+          content = entry.message.content;
+        } else if (Array.isArray(entry.message.content)) {
+          content = entry.message.content.filter(
+            (c) => c.type === "text" || c.type === "thinking"
+          ).map((c) => c.text || "").filter(Boolean).join("\n");
+        }
+        if (!content || content.length < 5) continue;
+        if (role === "assistant" && content.length > 3e3) continue;
+        messages.push({
+          role,
+          content: content.length > 800 ? content.substring(0, 800) + "..." : content
+        });
+      } catch {
+        continue;
+      }
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+async function parseOpenCodeSession(storageDir, sessionId) {
+  try {
+    const messagesDir = join20(storageDir, "message", sessionId);
+    if (!existsSync16(messagesDir)) return [];
+    const msgFiles = await readdir7(messagesDir);
+    const messages = [];
+    for (const msgFile of msgFiles.sort()) {
+      const msgData = JSON.parse(
+        await readFile9(join20(messagesDir, msgFile), "utf-8")
+      );
+      if (msgData.role !== "user" && msgData.role !== "assistant") continue;
+      const partsDir = join20(storageDir, "part", msgData.id);
+      if (!existsSync16(partsDir)) continue;
+      const partFiles = await readdir7(partsDir);
+      let content = "";
+      for (const partFile of partFiles.sort()) {
+        const part = JSON.parse(
+          await readFile9(join20(partsDir, partFile), "utf-8")
+        );
+        if (part.type === "text" && part.text) {
+          content += part.text;
+        }
+      }
+      if (!content || content.length < 5) continue;
+      if (msgData.role === "assistant" && content.length > 3e3) continue;
+      messages.push({
+        role: msgData.role,
+        content: content.length > 800 ? content.substring(0, 800) + "..." : content
+      });
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+async function collectKiroSessions(hubDir, indexed, limit, since) {
+  const sessionsBase = getKiroSessionsDir();
+  if (!sessionsBase) return [];
+  const workspaceDirs = await readdir7(sessionsBase);
+  const candidates = [];
+  for (const wsDir of workspaceDirs) {
+    const wsPath = join20(sessionsBase, wsDir);
+    const wsStat = await stat(wsPath);
+    if (!wsStat.isDirectory()) continue;
+    const files = await readdir7(wsPath);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    for (const file of jsonFiles) {
+      const id = file.replace(".json", "");
+      if (indexed.has(`kiro:${id}`)) continue;
+      const fileStat = await stat(join20(wsPath, file));
+      if (since && fileStat.mtime < new Date(since)) continue;
+      candidates.push({ file, wsPath, mtime: fileStat.mtime });
+    }
+  }
+  candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const sessions = [];
+  for (const { file, wsPath, mtime } of candidates) {
+    if (sessions.length >= limit) break;
+    const messages = await parseKiroSession(join20(wsPath, file));
+    if (messages.length < 2) continue;
+    sessions.push({
+      id: file.replace(".json", ""),
+      editor: "kiro",
+      date: mtime.toISOString().split("T")[0],
+      messages
+    });
+  }
+  return sessions;
+}
+async function collectClaudeSessions(hubDir, indexed, limit, since) {
+  const projectsDir = getClaudeProjectsDir();
+  if (!projectsDir) return [];
+  const projects = await readdir7(projectsDir);
+  const candidates = [];
+  for (const project of projects) {
+    const projectPath = join20(projectsDir, project);
+    const projectStat = await stat(projectPath);
+    if (!projectStat.isDirectory()) continue;
+    const files = await readdir7(projectPath);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    for (const file of jsonlFiles) {
+      const id = file.replace(".jsonl", "");
+      if (indexed.has(`claude:${id}`)) continue;
+      const fileStat = await stat(join20(projectPath, file));
+      if (since && fileStat.mtime < new Date(since)) continue;
+      candidates.push({ file, projectPath, mtime: fileStat.mtime });
+    }
+  }
+  candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const sessions = [];
+  for (const { file, projectPath, mtime } of candidates) {
+    if (sessions.length >= limit) break;
+    const messages = await parseClaudeSession(join20(projectPath, file));
+    if (messages.length < 2) continue;
+    sessions.push({
+      id: file.replace(".jsonl", ""),
+      editor: "claude",
+      date: mtime.toISOString().split("T")[0],
+      messages
+    });
+  }
+  return sessions;
+}
+async function collectOpenCodeSessions(hubDir, indexed, limit, since) {
+  const storageDir = getOpenCodeStorageDir();
+  if (!storageDir) return [];
+  const sessionDirs = join20(storageDir, "session");
+  if (!existsSync16(sessionDirs)) return [];
+  const projects = await readdir7(sessionDirs);
+  const candidates = [];
+  for (const project of projects) {
+    const projectPath = join20(sessionDirs, project);
+    const projectStat = await stat(projectPath);
+    if (!projectStat.isDirectory()) continue;
+    const files = await readdir7(projectPath);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    for (const file of jsonFiles) {
+      const sessionId = file.replace(".json", "");
+      if (indexed.has(`opencode:${sessionId}`)) continue;
+      const fileStat = await stat(join20(projectPath, file));
+      if (since && fileStat.mtime < new Date(since)) continue;
+      candidates.push({ sessionId, mtime: fileStat.mtime });
+    }
+  }
+  candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const sessions = [];
+  for (const { sessionId, mtime } of candidates) {
+    if (sessions.length >= limit) break;
+    const messages = await parseOpenCodeSession(storageDir, sessionId);
+    if (messages.length < 2) continue;
+    sessions.push({
+      id: sessionId,
+      editor: "opencode",
+      date: mtime.toISOString().split("T")[0],
+      messages
+    });
+  }
+  return sessions;
+}
+function buildBatchContent(sessions) {
+  const parts = [];
+  for (let i = 0; i < sessions.length; i++) {
+    const session = sessions[i];
+    parts.push(`## Session ${i + 1} (${session.date}, ${session.editor})
+`);
+    for (const msg of session.messages) {
+      const label = msg.role === "user" ? "User" : "Assistant";
+      parts.push(`${label}: ${msg.content}
+`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function buildConsolidationPrompt(batchPath, memoriesPath) {
+  return [
+    "You are a knowledge extractor. Your task is to read transcripts of chat sessions between developers and AI agents, and extract information that would be useful for future sessions.",
+    "",
+    `Read the file ${batchPath}`,
+    "",
+    "For each useful piece of information you find, create a file in the appropriate category folder:",
+    "",
+    `- ${memoriesPath}/decisions/ \u2014 technical choices (e.g. "use Drizzle instead of TypeORM")`,
+    `- ${memoriesPath}/conventions/ \u2014 patterns defined (e.g. "API errors return { code, message }")`,
+    `- ${memoriesPath}/gotchas/ \u2014 problems to avoid (e.g. "Sentry v8 leak with NestJS")`,
+    `- ${memoriesPath}/domain/ \u2014 business knowledge (e.g. "enrollment can stay pending for 30 days")`,
+    "",
+    "File format:",
+    "---",
+    "title: <short title>",
+    "category: <category>",
+    "date: <today's date>",
+    "status: active",
+    "tags: [tag1, tag2]",
+    "source:",
+    "  type: consolidation",
+    "---",
+    "",
+    "## Context",
+    "<2-3 sentences of context>",
+    "",
+    "## Details",
+    "<specific details>",
+    "",
+    "Rules:",
+    "- Ignore specific implementation, generated code, compilation errors, tool call outputs",
+    "- Focus on DECISIONS, PATTERNS, DISCOVERIES, and BUSINESS KNOWLEDGE",
+    "- If a session has nothing useful, skip it",
+    `- Before creating a file, read existing files in ${memoriesPath}/ to avoid duplicates`,
+    "- If a similar memory already exists, do NOT create another one",
+    "- Use kebab-case for filenames with today's date prefix (e.g. 2026-04-03-use-drizzle.md)",
+    "- Write memory content in the same language the developers used in the chat"
+  ].join("\n");
+}
+function spawnEditorCli(cli, prompt, cwd) {
+  return new Promise((resolve7) => {
+    let args;
+    switch (cli) {
+      case "kiro-cli":
+        args = ["chat", "--no-interactive", "--trust-all-tools", prompt];
+        break;
+      case "claude":
+        args = [
+          "-p",
+          "--dangerously-skip-permissions",
+          "--allowedTools",
+          "Read,Write,Edit,Glob,Grep",
+          prompt
+        ];
+        break;
+      case "opencode":
+        args = ["--non-interactive", prompt];
+        break;
+    }
+    const proc = spawn(cli, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("exit", (code) => {
+      resolve7({ code: code ?? 1, stdout, stderr });
+    });
+    proc.on("error", (err) => {
+      resolve7({ code: 1, stdout, stderr: err.message });
+    });
+  });
+}
+var consolidateCommand = new Command20("consolidate").description(
+  "Extract knowledge from chat sessions across editors into team memories"
+).option("-n, --last <count>", "Number of recent sessions to process", "20").option("-s, --since <date>", "Only process sessions after this date (YYYY-MM-DD)").option(
+  "-e, --editor <editor>",
+  "Editor to collect from (kiro, claude, opencode, all)",
+  "all"
+).option(
+  "--cli <cli>",
+  "Editor CLI to use for extraction (kiro-cli, claude, opencode)"
+).option("--dry-run", "Show batch content without running extraction").option("--reset", "Reset consolidation state and reprocess all sessions").action(
+  async (opts) => {
+    const hubDir = process.cwd();
+    const limit = parseInt(opts.last, 10);
+    console.log(chalk19.blue("\nConsolidating chat sessions into memories\n"));
+    let state = await readState(hubDir);
+    if (opts.reset) {
+      state = { indexed: {} };
+      await writeState(hubDir, state);
+      console.log(chalk19.yellow("  Reset consolidation state\n"));
+    }
+    const indexed = /* @__PURE__ */ new Set();
+    for (const [editor, data] of Object.entries(state.indexed)) {
+      for (const sessionId of data.sessions) {
+        indexed.add(`${editor}:${sessionId}`);
+      }
+    }
+    console.log(chalk19.dim(`  Already indexed: ${indexed.size} sessions`));
+    const allSessions = [];
+    if (opts.editor === "all" || opts.editor === "kiro") {
+      const kiroSessions = await collectKiroSessions(
+        hubDir,
+        indexed,
+        limit,
+        opts.since
+      );
+      allSessions.push(...kiroSessions);
+      if (kiroSessions.length > 0) {
+        console.log(
+          chalk19.green(`  Found ${kiroSessions.length} new Kiro sessions`)
+        );
+      }
+    }
+    if (opts.editor === "all" || opts.editor === "claude") {
+      const claudeSessions = await collectClaudeSessions(
+        hubDir,
+        indexed,
+        limit,
+        opts.since
+      );
+      allSessions.push(...claudeSessions);
+      if (claudeSessions.length > 0) {
+        console.log(
+          chalk19.green(
+            `  Found ${claudeSessions.length} new Claude Code sessions`
+          )
+        );
+      }
+    }
+    if (opts.editor === "all" || opts.editor === "opencode") {
+      const openCodeSessions = await collectOpenCodeSessions(
+        hubDir,
+        indexed,
+        limit,
+        opts.since
+      );
+      allSessions.push(...openCodeSessions);
+      if (openCodeSessions.length > 0) {
+        console.log(
+          chalk19.green(
+            `  Found ${openCodeSessions.length} new OpenCode sessions`
+          )
+        );
+      }
+    }
+    if (allSessions.length === 0) {
+      console.log(chalk19.yellow("\n  No new sessions to process.\n"));
+      return;
+    }
+    allSessions.sort(
+      (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+    );
+    const toProcess = allSessions.slice(0, limit);
+    console.log(
+      chalk19.blue(`
+  Processing ${toProcess.length} sessions...
+`)
+    );
+    const batchContent = buildBatchContent(toProcess);
+    const batchDir = join20(hubDir, BATCH_DIR);
+    await mkdir10(batchDir, { recursive: true });
+    const batchFile = `batch-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.md`;
+    const batchPath = join20(batchDir, batchFile);
+    await writeFile12(batchPath, batchContent, "utf-8");
+    console.log(chalk19.dim(`  Batch written to ${BATCH_DIR}/${batchFile}`));
+    if (opts.dryRun) {
+      console.log(chalk19.yellow("\n  Dry run \u2014 batch content:\n"));
+      const preview = batchContent.length > 3e3 ? batchContent.substring(0, 3e3) + "\n\n... (truncated)" : batchContent;
+      console.log(chalk19.dim(preview));
+      console.log(
+        chalk19.yellow(
+          `
+  Would process ${toProcess.length} sessions. Run without --dry-run to extract.
+`
+        )
+      );
+      return;
+    }
+    let memoriesPath = "./memories";
+    try {
+      const config = await loadHubConfig(hubDir);
+      if (config.memory?.path) memoriesPath = config.memory.path;
+    } catch {
+    }
+    for (const cat of ["decisions", "conventions", "gotchas", "domain"]) {
+      await mkdir10(join20(hubDir, memoriesPath, cat), { recursive: true });
+    }
+    let cli = opts.cli;
+    if (!cli) {
+      const detected = detectEditorCli();
+      if (!detected) {
+        console.log(
+          chalk19.red(
+            "\n  No editor CLI found (kiro-cli, claude, opencode)."
+          )
+        );
+        console.log(
+          chalk19.dim(
+            "  Install one or specify with --cli <kiro-cli|claude|opencode>\n"
+          )
+        );
+        return;
+      }
+      cli = detected;
+    }
+    console.log(chalk19.blue(`  Using ${cli} for extraction...
+`));
+    const relativeBatchPath = `.hub/consolidation/${batchFile}`;
+    const prompt = buildConsolidationPrompt(relativeBatchPath, memoriesPath);
+    const result = await spawnEditorCli(cli, prompt, hubDir);
+    if (result.code !== 0) {
+      console.log(chalk19.red(`
+  Extraction failed (exit code ${result.code})`));
+      if (result.stderr) {
+        console.log(chalk19.dim(`  stderr: ${result.stderr.substring(0, 500)}`));
+      }
+      return;
+    }
+    console.log(chalk19.green("\n  Extraction complete!"));
+    const processedIds = toProcess.map((s) => s.id);
+    for (const session of toProcess) {
+      const editorKey = session.editor;
+      if (!state.indexed[editorKey]) {
+        state.indexed[editorKey] = { sessions: [] };
+      }
+      state.indexed[editorKey].sessions.push(session.id);
+      state.indexed[editorKey].last_session_date = session.date;
+    }
+    state.last_run = (/* @__PURE__ */ new Date()).toISOString();
+    await writeState(hubDir, state);
+    console.log(
+      chalk19.dim(`  Marked ${processedIds.length} sessions as indexed`)
+    );
+    let newMemories = 0;
+    for (const cat of ["decisions", "conventions", "gotchas", "domain"]) {
+      const catDir = join20(hubDir, memoriesPath, cat);
+      if (existsSync16(catDir)) {
+        const files = await readdir7(catDir);
+        newMemories += files.filter((f) => f.endsWith(".md")).length;
+      }
+    }
+    console.log(chalk19.green(`  Total memories: ${newMemories}`));
+    console.log(chalk19.green("\nDone!\n"));
+  }
+);
+
+// src/commands/sandbox.ts
+import { Command as Command21 } from "commander";
+import { execSync as execSync16, exec } from "child_process";
+import { existsSync as existsSync17 } from "fs";
+import { writeFile as writeFile13 } from "fs/promises";
+import { join as join21 } from "path";
+import { promisify } from "util";
+import chalk20 from "chalk";
+var execAsync = promisify(exec);
+function getSandboxConfig(config) {
+  return config.services?.find((s) => s.type === "sandbox") ?? null;
+}
+async function ensureComposeFile(hubDir) {
+  const composePath = join21(hubDir, "docker-compose.yml");
+  if (!existsSync17(composePath)) {
+    const config = await loadHubConfig(hubDir);
+    const content = generateDockerCompose(config.services ?? [], hubDir);
+    await writeFile13(composePath, content, "utf-8");
+  }
+  return composePath;
+}
+function isDockerRunning2() {
+  try {
+    execSync16("docker info", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isSandboxRunning(name) {
+  try {
+    const { stdout } = await execAsync(`docker inspect --format='{{.State.Running}}' ${name} 2>/dev/null`);
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+var sandboxCommand = new Command21("sandbox").description("Manage the AIO Sandbox environment").argument("[action]", "up, down, status, open, logs", "status").action(async (action) => {
+  if (!isDockerRunning2()) {
+    console.log(chalk20.red("\nDocker daemon is not running."));
+    console.log(chalk20.dim("Start Docker Desktop or the Docker daemon and try again.\n"));
+    return;
+  }
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  const svc = getSandboxConfig(config);
+  if (!svc) {
+    console.log(chalk20.red("\nNo sandbox service found in hub.yaml."));
+    console.log(chalk20.dim("Add a service with type: sandbox to your hub.yaml:\n"));
+    console.log(chalk20.dim("  services:"));
+    console.log(chalk20.dim("    - name: sandbox"));
+    console.log(chalk20.dim("      type: sandbox"));
+    console.log(chalk20.dim("      port: 8080\n"));
+    return;
+  }
+  const port = svc.port ?? 8080;
+  const name = svc.name;
+  switch (action) {
+    case "up":
+    case "start": {
+      const running = await isSandboxRunning(name);
+      if (running) {
+        console.log(chalk20.yellow(`
+Sandbox is already running.`));
+        printUrls(port);
+        return;
+      }
+      console.log(chalk20.blue(`
+Starting sandbox...
+`));
+      const composePath = await ensureComposeFile(hubDir);
+      execSync16(`docker compose -f ${composePath} up -d ${name}`, { stdio: "inherit", cwd: hubDir });
+      console.log(chalk20.green("\nSandbox started."));
+      printUrls(port);
+      break;
+    }
+    case "down":
+    case "stop": {
+      console.log(chalk20.blue(`
+Stopping sandbox...
+`));
+      const composePath = await ensureComposeFile(hubDir);
+      execSync16(`docker compose -f ${composePath} stop ${name}`, { stdio: "inherit", cwd: hubDir });
+      console.log(chalk20.green("\nSandbox stopped.\n"));
+      break;
+    }
+    case "logs": {
+      const composePath = await ensureComposeFile(hubDir);
+      execSync16(`docker compose -f ${composePath} logs -f ${name}`, { stdio: "inherit", cwd: hubDir });
+      break;
+    }
+    case "open": {
+      const running = await isSandboxRunning(name);
+      if (!running) {
+        console.log(chalk20.red("\nSandbox is not running. Start it first with: hub sandbox up\n"));
+        return;
+      }
+      const url = `http://localhost:${port}/code-server/`;
+      console.log(chalk20.blue(`
+Opening VSCode Server at ${url}
+`));
+      execSync16(`open "${url}"`, { stdio: "inherit" });
+      break;
+    }
+    case "status":
+    default: {
+      const running = await isSandboxRunning(name);
+      if (running) {
+        console.log(chalk20.green(`
+Sandbox is running.`));
+        printUrls(port);
+      } else {
+        console.log(chalk20.yellow(`
+Sandbox is not running.`));
+        console.log(chalk20.dim(`  Start it with: hub sandbox up
+`));
+      }
+      break;
+    }
+  }
+});
+function printUrls(port) {
+  console.log();
+  console.log(chalk20.dim(`  MCP:     `) + chalk20.cyan(`http://localhost:${port}/mcp`));
+  console.log(chalk20.dim(`  VSCode:  `) + chalk20.cyan(`http://localhost:${port}/code-server/`));
+  console.log(chalk20.dim(`  Browser: `) + chalk20.cyan(`http://localhost:${port}/vnc/index.html?autoconnect=true`));
+  console.log(chalk20.dim(`  Docs:    `) + chalk20.cyan(`http://localhost:${port}/v1/docs`));
+  console.log();
+}
+
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join20 } from "path";
+import { dirname as dirname2, join as join22 } from "path";
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname2(__filename);
-var pkg = JSON.parse(readFileSync2(join20(__dirname, "..", "package.json"), "utf-8"));
-var program = new Command20();
+var pkg = JSON.parse(readFileSync2(join22(__dirname, "..", "package.json"), "utf-8"));
+var program = new Command22();
 program.name("hub").description(
   "Give your AI coding assistant the full picture. Multi-repo context, agent orchestration, and end-to-end workflows."
 ).version(pkg.version).enablePositionalOptions();
@@ -4433,4 +5102,7 @@ program.addCommand(updateCommand);
 program.addCommand(directoryCommand);
 program.addCommand(scanCommand);
 program.addCommand(cloneCommand);
+program.addCommand(consolidateCommand);
+program.addCommand(personaCommand);
+program.addCommand(sandboxCommand);
 program.parse();