@arvoretech/hub 0.13.3 → 0.16.0

package/dist/{chunk-H6BAEWCZ.js → chunk-ALJAZQ33.js}

@@ -5,7 +5,7 @@ import {
 // src/commands/generate.ts
 import { Command } from "commander";
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile3, readdir as readdir2, copyFile, readFile as readFile3, cp } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3, readdir as readdir2, copyFile, readFile as readFile3, cp, rm } from "fs/promises";
 import { join as join3, resolve as resolve2 } from "path";
 import chalk3 from "chalk";
 import inquirer from "inquirer";
@@ -117,7 +117,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-YSMMXJNC.js");
+    const { generators: generators2 } = await import("./generate-YJEPLTSQ.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -666,6 +666,11 @@ async function generateCursor(config, hubDir) {
   const orchestratorRule = buildOrchestratorRule(config);
   await writeFile3(join3(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
   console.log(chalk3.green("  Generated .cursor/rules/orchestrator.mdc"));
+  const cleanedOrchestratorForAgents = orchestratorRule.replace(/^---[\s\S]*?---\n/m, "").trim();
+  const skillsSectionCursor = await buildSkillsSection(hubDir, config);
+  const agentsMdCursor = skillsSectionCursor ? cleanedOrchestratorForAgents + "\n" + skillsSectionCursor : cleanedOrchestratorForAgents;
+  await writeFile3(join3(hubDir, "AGENTS.md"), agentsMdCursor + "\n", "utf-8");
+  console.log(chalk3.green("  Generated AGENTS.md"));
   const hubSteeringDirCursor = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDirCursor);
@@ -903,24 +908,32 @@ ${rawContent}`;
   return `${lines.join("\n")}
 ${body}`;
 }
+function stripDollarPrefix(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = value.replace(/\$\{env:(\w+)\}/g, "{env:$1}").replace(/\$\{(\w+)\}/g, "{env:$1}");
+  }
+  return result;
+}
 function buildOpenCodeMcpEntry(mcp) {
+  const env = mcp.env ? stripDollarPrefix(mcp.env) : void 0;
   if (mcp.url) {
     return { type: "remote", url: mcp.url };
   }
   if (mcp.image) {
     const cmd = ["docker", "run", "-i", "--rm"];
-    if (mcp.env) {
-      for (const [key, value] of Object.entries(mcp.env)) {
+    if (env) {
+      for (const [key, value] of Object.entries(env)) {
         cmd.push("-e", `${key}=${value}`);
       }
     }
     cmd.push(mcp.image);
-    return { type: "local", command: cmd, ...mcp.env && { environment: mcp.env } };
+    return { type: "local", command: cmd, ...env && { environment: env } };
   }
   return {
     type: "local",
     command: ["npx", "-y", mcp.package],
-    ...mcp.env && { environment: mcp.env }
+    ...env && { environment: env }
   };
 }
 function buildOpenCodeHooksPlugin(hooks) {
@@ -965,6 +978,22 @@ tools:
   bash: true
 ---
 
+${body.trim()}
+`;
+}
+function buildOpenCodePrimaryAgentMarkdown(description, body) {
+  return `---
+description: "${description}"
+mode: primary
+tools:
+  write: true
+  edit: true
+  bash: true
+permission:
+  task:
+    "*": allow
+---
+
 ${body.trim()}
 `;
 }
@@ -1050,6 +1079,49 @@ You can communicate with agents from other developers on the team via the \`agen
 - Read the thread before replying to avoid repeating what others said
 - When starting a task that touches shared code, check recent threads for relevant context`;
 }
+function hasKanbanMcp(mcps) {
+  if (!mcps) return false;
+  const proxyMcp = mcps.find((m) => m.upstreams && m.upstreams.length > 0);
+  const directMatch = mcps.some((m) => m.name === "kanban" || m.package === "@arvoretech/kanban-mcp");
+  const upstreamMatch = proxyMcp?.upstreams?.includes("kanban") ?? false;
+  return directMatch || upstreamMatch;
+}
+function buildKanbanSection(mcps) {
+  if (!hasKanbanMcp(mcps)) return "";
+  return `
+## Kanban Board
+
+This workspace has a persistent kanban board via the \`kanban\` MCP. Use it to organize work, track progress across sessions, and coordinate with other chats.
+
+**When to use the kanban:**
+- At the start of a task, check the board for existing cards and active sessions
+- Break complex features into cards before starting implementation
+- Claim cards you're working on so other sessions can see
+- Release cards when done (default status: review)
+- Search for related cards before creating duplicates
+
+**Workflow:**
+1. \`list_boards\` / \`get_board\` \u2014 See what's on the board and who's working on what
+2. \`create_card\` \u2014 Add new tasks to the appropriate column
+3. \`claim_card\` \u2014 Mark a card as being worked on by this session
+4. \`move_card\` \u2014 Move cards between columns as work progresses
+5. \`release_card\` \u2014 Release when done, with status and detail (e.g. "PR #123 created")
+6. \`search_cards\` \u2014 Find cards by meaning (semantic search)
+
+**Available tools:** \`list_boards\`, \`create_board\`, \`get_board\`, \`get_card\`, \`create_card\`, \`update_card\`, \`move_card\`, \`claim_card\`, \`release_card\`, \`search_cards\`, \`archive_card\`, \`delete_card\`.
+
+**Multi-session coordination:**
+- Always \`claim_card\` before starting work \u2014 other sessions will see it's taken
+- If a card is already claimed, pick another or use \`force: true\` to override stale sessions
+- Use \`get_board\` to see active sessions with duration (helps identify abandoned claims)
+- When finishing, \`release_card\` with a meaningful detail so the next session has context
+
+**Best practices:**
+- Use subtasks (\`parent_card_id\`) to break down large cards
+- Tag cards consistently for easy filtering
+- Set priority to help triage (urgent > high > medium > low)
+- Check the board at the start of every session \u2014 don't start from zero`;
+}
 function buildMcpToolsSection(mcps) {
   if (!mcps || mcps.length === 0) return "";
   const proxyMcp = mcps.find((m) => m.upstreams && m.upstreams.length > 0);
@@ -1101,6 +1173,141 @@ ${mcp.instructions.trim()}`);
   }
   return lines.join("\n");
 }
+async function buildSkillsSection(hubDir, config) {
+  const skillsDir = resolve2(hubDir, "skills");
+  const skillEntries = [];
+  try {
+    const folders = await readdir2(skillsDir);
+    for (const folder of folders) {
+      const skillPath = join3(skillsDir, folder, "SKILL.md");
+      try {
+        const content = await readFile3(skillPath, "utf-8");
+        const fm = parseFrontMatter(content);
+        if (fm?.name) {
+          skillEntries.push({
+            name: fm.name,
+            description: fm.description || ""
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (skillEntries.length === 0) return null;
+  const repoSkillMap = /* @__PURE__ */ new Map();
+  for (const repo of config.repos) {
+    if (repo.skills?.length) {
+      for (const skill of repo.skills) {
+        const repos = repoSkillMap.get(skill) || [];
+        repos.push(repo.path);
+        repoSkillMap.set(skill, repos);
+      }
+    }
+  }
+  const parts = [];
+  parts.push(`
+## Skills
+
+This workspace has skills that provide specialized knowledge for specific domains and repositories.
+Consult the relevant skill before working in an unfamiliar area \u2014 they contain patterns, conventions, and project-specific guidance.
+
+| Skill | Description | Repositories |
+|-------|-------------|--------------|`);
+  for (const entry of skillEntries) {
+    const repos = repoSkillMap.get(entry.name);
+    const repoCol = repos ? repos.map((r) => `\`${r}\``).join(", ") : "\u2014";
+    const desc = entry.description.replace(/\|/g, "\\|").split(".")[0].trim();
+    parts.push(`| \`${entry.name}\` | ${desc} | ${repoCol} |`);
+  }
+  parts.push(`
+When to consult a skill:
+- Before writing code in a repository that has an associated skill
+- When making architecture or pattern decisions in a specific domain
+- When unsure about project conventions, libraries, or testing approaches
+- When the user's request touches a domain covered by an available skill
+
+Additional context sources:
+- Use documentation MCPs to check library and framework docs before implementing
+- Use database MCPs to understand schema, query data, and verify state
+- Use package registry MCPs to verify security and versions before installing dependencies
+- Use the repository CLI commands (build, test, lint) to validate changes after implementation
+- Use monitoring MCPs for production debugging and log analysis when available`);
+  return parts.join("\n");
+}
+function buildCoreBehaviorSections() {
+  const sections = [];
+  sections.push(`
+## Core Behavior
+
+Be concise, clear, direct, and useful.
+Prefer technical accuracy over reassurance.
+Do not use hype, flattery, or exaggerated validation.
+Do not repeatedly apologize when something unexpected happens \u2014 explain what happened and continue.
+Do not claim actions were performed unless they were actually performed.
+Never invent facts, code behavior, file contents, tool capabilities, or execution outcomes.
+Focus on completing the user's task, not on narrating unnecessary process.`);
+  sections.push(`
+## Working Style
+
+Prefer the simplest solution that fully satisfies the request.
+Avoid over-engineering, speculative abstractions, premature generalization, and cleanup outside the requested scope.
+Prefer editing existing files over creating new files.
+Prefer minimal, reversible changes over broad rewrites unless the task explicitly requires a rewrite.
+Ask the user questions only when a real ambiguity materially affects the solution.
+Bias toward finding the answer yourself when the available context and tools are sufficient.`);
+  sections.push(`
+## Search, Reading, and Investigation
+
+If you are unsure how to satisfy the user's request, gather more information before answering.
+Prefer discovering answers yourself over asking the user for information that is likely available in the workspace, files, memories, or tools.
+
+When reading code or documents:
+- Read enough surrounding context to avoid missing critical behavior
+- Do not propose modifications to code you have not inspected
+- If partial views may hide important logic, continue reading before deciding
+
+For broader exploration:
+- Use lightweight search first
+- Escalate to deeper exploration or subagents only when the task is broad, ambiguous, or likely to require several search passes`);
+  sections.push(`
+## Code Changes
+
+When making code changes:
+- Ensure the produced code is runnable and internally consistent
+- Add required imports, wiring, dependencies, and integration points
+- Preserve the project's existing patterns unless there is a strong reason to change them
+- Read the relevant files or sections before modifying existing code
+- Understand the surrounding code paths and conventions
+- Prefer small, precise edits
+
+If you introduce errors:
+- Try to fix them
+- Do not get stuck in unbounded retry loops (max 3 attempts on the same issue)
+- If repeated fixes fail, explain the remaining problem clearly
+
+Never assume a library is available \u2014 check the dependency file or neighboring code first.
+When creating a new component, look at existing components to understand conventions.`);
+  sections.push(`
+## Security and Safety
+
+Never hardcode secrets, credentials, tokens, or API keys.
+Flag security risks when noticed.
+Avoid introducing vulnerabilities such as command injection, SQL injection, XSS, insecure secret handling, broken auth flows, unsafe deserialization, SSRF, or privilege escalation.
+Do not expose secrets in code, tests, examples, or logs.`);
+  sections.push(`
+## Git and Operational Discipline
+
+Do not commit, push, open pull requests, or notify external systems unless the user asked for it or the workspace flow explicitly requires it.
+
+When handling git work:
+- Inspect status and diff before committing
+- Follow existing repository commit conventions
+- Prefer specific file staging over indiscriminate staging
+- Do not use destructive git commands without explicit user authorization`);
+  return sections;
+}
 function buildOpenCodeOrchestratorRule(config) {
   const taskFolder = config.workflow?.task_folder || "./tasks/<TASK_ID>/";
   const steps = config.workflow?.pipeline || [];
@@ -1194,6 +1401,8 @@ Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_mem
   if (agentTeamsSectionOpenCode) sections.push(agentTeamsSectionOpenCode);
   const agentTeamsChatSectionOpenCode = buildAgentTeamsChatSection(config.mcps);
   if (agentTeamsChatSectionOpenCode) sections.push(agentTeamsChatSectionOpenCode);
+  const kanbanSectionOpenCode = buildKanbanSection(config.mcps);
+  if (kanbanSectionOpenCode) sections.push(kanbanSectionOpenCode);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -1204,6 +1413,7 @@ It will:
 3. Form and test hypotheses systematically
 4. Identify the root cause
 5. Propose a solution or call coding agents to implement the fix`);
+  sections.push(...buildCoreBehaviorSections());
   if (prompt?.sections) {
     const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
     for (const [name, content] of Object.entries(prompt.sections)) {
@@ -1303,9 +1513,24 @@ async function generateOpenCode(config, hubDir) {
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
-  const orchestratorRule = buildOpenCodeOrchestratorRule(config);
-  await writeFile3(join3(opencodeDir, "rules", "orchestrator.md"), orchestratorRule + "\n", "utf-8");
-  console.log(chalk3.green("  Generated .opencode/rules/orchestrator.md"));
+  if (config.repos.length > 0) {
+    const ignoreContent = config.repos.map((r) => `!${r.name}`).join("\n") + "\n";
+    await writeFile3(join3(hubDir, ".ignore"), ignoreContent, "utf-8");
+    console.log(chalk3.green("  Generated .ignore"));
+  }
+  const orchestratorContent = buildOpenCodeOrchestratorRule(config);
+  const orchestratorAgent = buildOpenCodePrimaryAgentMarkdown(
+    "Development orchestrator. Delegates specialized work to subagents following a structured pipeline: refinement, coding, review, QA, and delivery.",
+    orchestratorContent
+  );
+  await writeFile3(join3(opencodeDir, "agents", "orchestrator.md"), orchestratorAgent, "utf-8");
+  console.log(chalk3.green("  Generated .opencode/agents/orchestrator.md (primary agent)"));
+  await rm(join3(opencodeDir, "rules", "orchestrator.md")).catch(() => {
+  });
+  const skillsSectionOC = await buildSkillsSection(hubDir, config);
+  const agentsMdOC = skillsSectionOC ? orchestratorContent + "\n" + skillsSectionOC : orchestratorContent;
+  await writeFile3(join3(hubDir, "AGENTS.md"), agentsMdOC + "\n", "utf-8");
+  console.log(chalk3.green("  Generated AGENTS.md"));
   const hubSteeringDirOC = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDirOC);
@@ -1321,7 +1546,8 @@ async function generateOpenCode(config, hubDir) {
   } catch {
   }
   const opencodeConfig = {
-    $schema: "https://opencode.ai/config.json"
+    $schema: "https://opencode.ai/config.json",
+    default_agent: "orchestrator"
   };
   if (config.mcps?.length) {
     const mcpConfig = {};
@@ -1348,6 +1574,7 @@ async function generateOpenCode(config, hubDir) {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
+      if (file === "orchestrator.md") continue;
       const content = await readFile3(join3(agentsDir, file), "utf-8");
       const agentName = file.replace(/\.md$/, "");
       const converted = buildOpenCodeAgentMarkdown(agentName, content);
@@ -1491,6 +1718,8 @@ Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_mem
   if (agentTeamsSectionKiro) sections.push(agentTeamsSectionKiro);
   const agentTeamsChatSectionKiro = buildAgentTeamsChatSection(config.mcps);
   if (agentTeamsChatSectionKiro) sections.push(agentTeamsChatSectionKiro);
+  const kanbanSectionKiro = buildKanbanSection(config.mcps);
+  if (kanbanSectionKiro) sections.push(kanbanSectionKiro);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -1500,6 +1729,7 @@ For bug reports or unexpected behavior, follow the debugging process from the \`
 3. Form and test hypotheses systematically
 4. Identify the root cause
 5. Propose and implement the fix`);
+  sections.push(...buildCoreBehaviorSections());
   if (prompt?.sections) {
     const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
     for (const [name, content] of Object.entries(prompt.sections)) {
@@ -1683,6 +1913,8 @@ Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_mem
   if (agentTeamsSectionCursor) sections.push(agentTeamsSectionCursor);
   const agentTeamsChatSectionCursor = buildAgentTeamsChatSection(config.mcps);
   if (agentTeamsChatSectionCursor) sections.push(agentTeamsChatSectionCursor);
+  const kanbanSectionCursor = buildKanbanSection(config.mcps);
+  if (kanbanSectionCursor) sections.push(kanbanSectionCursor);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -1693,6 +1925,7 @@ It will:
 3. Form and test hypotheses systematically
 4. Identify the root cause
 5. Propose a solution or call coding agents to implement the fix`);
+  sections.push(...buildCoreBehaviorSections());
   if (prompt?.sections) {
     const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
     for (const [name, content] of Object.entries(prompt.sections)) {
@@ -1866,6 +2099,10 @@ async function generateClaudeCode(config, hubDir) {
   await mkdir3(join3(claudeDir, "agents"), { recursive: true });
   const orchestratorRule = buildOrchestratorRule(config);
   const cleanedOrchestrator = orchestratorRule.replace(/^---[\s\S]*?---\n/m, "").trim();
+  const skillsSectionClaude = await buildSkillsSection(hubDir, config);
+  const agentsMdClaude = skillsSectionClaude ? cleanedOrchestrator + "\n" + skillsSectionClaude : cleanedOrchestrator;
+  await writeFile3(join3(hubDir, "AGENTS.md"), agentsMdClaude + "\n", "utf-8");
+  console.log(chalk3.green("  Generated AGENTS.md"));
   const claudeMdSections = [];
   claudeMdSections.push(cleanedOrchestrator);
   const agentsDir = resolve2(hubDir, "agents");
@@ -2016,10 +2253,9 @@ async function generateKiro(config, hubDir) {
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
   const kiroRule = buildKiroOrchestratorRule(config);
-  const kiroOrchestrator = buildKiroSteeringContent(kiroRule, "always", { name: "orchestrator" });
-  await writeFile3(join3(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
-  console.log(chalk3.green("  Generated .kiro/steering/orchestrator.md"));
-  await writeFile3(join3(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
+  const skillsSection = await buildSkillsSection(hubDir, config);
+  const kiroRuleWithSkills = skillsSection ? kiroRule + "\n" + skillsSection : kiroRule;
+  await writeFile3(join3(hubDir, "AGENTS.md"), kiroRuleWithSkills + "\n", "utf-8");
   console.log(chalk3.green("  Generated AGENTS.md"));
   const hubSteeringDir = resolve2(hubDir, "steering");
   try {

package/dist/config/index.d.ts

@@ -196,6 +196,7 @@ declare const mcp: {
     context7(overrides?: MCPOverrides): MCPConfig;
     agentTeamsLead(overrides?: MCPOverrides): MCPConfig;
     agentTeamsChat(overrides?: MCPOverrides): MCPConfig;
+    kanban(overrides?: MCPOverrides): MCPConfig;
     proxy(name: string, overrides: MCPOverrides & {
         upstreams: string[];
     }): MCPConfig;

package/dist/config/index.js

@@ -210,6 +210,14 @@ var mcp = {
       env: { ...overrides?.env }
     };
   },
+  kanban(overrides) {
+    return {
+      name: "kanban",
+      package: "@arvoretech/kanban-mcp",
+      ...overrides,
+      env: { ...overrides?.env }
+    };
+  },
   proxy(name, overrides) {
     return {
       name,

package/dist/{generate-YSMMXJNC.js → generate-YJEPLTSQ.js}

@@ -1,7 +1,7 @@
 import {
   generateCommand,
   generators
-} from "./chunk-H6BAEWCZ.js";
+} from "./chunk-ALJAZQ33.js";
 import "./chunk-VMN4KGAK.js";
 export {
   generateCommand,

package/dist/index.js

@@ -2,14 +2,14 @@
 import {
   checkAndAutoRegenerate,
   generateCommand
-} from "./chunk-H6BAEWCZ.js";
+} from "./chunk-ALJAZQ33.js";
 import {
   loadHubConfig,
   resolveConfigPath
 } from "./chunk-VMN4KGAK.js";
 
 // src/index.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 
 // src/commands/init.ts
 import { Command as Command2 } from "commander";
@@ -763,7 +763,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 +1280,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) {
@@ -2671,10 +2673,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)) {
@@ -2711,8 +2713,8 @@ async function addFromLocalPath3(localPath, hubDir, opts) {
     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 +2741,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));
@@ -2906,8 +2908,8 @@ async function addFromLocalPath4(localPath, hubDir, opts) {
     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 +2920,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) {
@@ -4400,14 +4402,553 @@ 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((resolve6) => {
+    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) => {
+      resolve6({ code: code ?? 1, stdout, stderr });
+    });
+    proc.on("error", (err) => {
+      resolve6({ 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/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 join21 } 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(join21(__dirname, "..", "package.json"), "utf-8"));
+var program = new Command21();
 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 +4974,5 @@ program.addCommand(updateCommand);
 program.addCommand(directoryCommand);
 program.addCommand(scanCommand);
 program.addCommand(cloneCommand);
+program.addCommand(consolidateCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvoretech/hub",
-  "version": "0.13.3",
+  "version": "0.16.0",
   "description": "CLI for managing AI-aware multi-repository workspaces",
   "main": "dist/index.js",
   "type": "module",