@hung319/opencode-hive 1.3.9 → 1.4.0

package/dist/index.js

@@ -232,7 +232,7 @@ var init_context_compression = __esm(() => {
 
 // src/index.ts
 import * as path8 from "path";
-import * as os from "os";
+import * as os2 from "os";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -15845,6 +15845,428 @@ mcp:
   }
 });
 
+// src/tools/memory.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+function getGlobalMemoryDir() {
+  return path2.join(os.homedir(), ".config", "opencode", "hive", "memory", "global");
+}
+function getProjectMemoryDir(projectRoot) {
+  return path2.join(projectRoot, ".hive", "memory", "project");
+}
+function getJournalDir() {
+  return path2.join(os.homedir(), ".config", "opencode", "hive", "journal");
+}
+function parseFrontmatter2(content) {
+  if (!content.startsWith(`---
+`)) {
+    return { frontmatter: {}, body: content };
+  }
+  const endIndex = content.indexOf(`
+---
+`, 4);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: content };
+  }
+  const fmText = content.slice(4, endIndex);
+  const body = content.slice(endIndex + 5);
+  const frontmatter = {};
+  for (const line of fmText.split(`
+`)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (value === "true")
+        frontmatter[key] = true;
+      else if (value === "false")
+        frontmatter[key] = false;
+      else if (!isNaN(Number(value)))
+        frontmatter[key] = Number(value);
+      else
+        frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function buildFrontmatter(frontmatter) {
+  const lines = [];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (typeof value === "boolean" || typeof value === "number") {
+      lines.push(`${key}: ${value}`);
+    } else if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${item}`);
+      }
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.length > 0 ? `---
+${lines.join(`
+`)}
+---
+` : "";
+}
+function readMemoryBlock(filePath, scope) {
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter2(content);
+  const label = frontmatter.label || path2.basename(filePath, path2.extname(filePath));
+  const description = frontmatter.description || "Memory block";
+  const limit = frontmatter.limit || 5000;
+  const readOnly = frontmatter.read_only === true;
+  const stats = fs2.statSync(filePath);
+  return {
+    scope,
+    label,
+    description,
+    limit,
+    readOnly,
+    value: body.trim(),
+    filePath,
+    lastModified: stats.mtime.toISOString(),
+    charsCurrent: body.trim().length
+  };
+}
+function listMemoryBlocks(scope, projectRoot) {
+  const dir = scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
+  if (!fs2.existsSync(dir)) {
+    return [];
+  }
+  const blocks = [];
+  for (const file2 of fs2.readdirSync(dir)) {
+    if (file2.endsWith(".md")) {
+      const filePath = path2.join(dir, file2);
+      try {
+        blocks.push(readMemoryBlock(filePath, scope));
+      } catch {}
+    }
+  }
+  return blocks.sort((a, b) => {
+    const priority = { persona: 0, human: 1, project: 2 };
+    const pa = priority[a.label] ?? 10;
+    const pb = priority[b.label] ?? 10;
+    if (pa !== pb)
+      return pa - pb;
+    return a.label.localeCompare(b.label);
+  });
+}
+var SEED_BLOCKS = [
+  { scope: "global", label: "persona", description: "How the agent should behave and respond. Personality, communication style, constraints." },
+  { scope: "global", label: "human", description: "Key details about the user: preferences, habits, constraints, working style." },
+  { scope: "project", label: "project", description: "Project-specific knowledge: commands, architecture, conventions, gotchas." }
+];
+async function ensureMemorySeeded(projectRoot) {
+  for (const seed of SEED_BLOCKS) {
+    const dir = seed.scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
+    fs2.mkdirSync(dir, { recursive: true });
+    const filePath = path2.join(dir, `${seed.label}.md`);
+    if (!fs2.existsSync(filePath)) {
+      const content = buildFrontmatter({
+        label: seed.label,
+        description: seed.description,
+        limit: 5000,
+        read_only: false
+      });
+      fs2.writeFileSync(filePath, content + `
+`, "utf-8");
+    }
+  }
+}
+function writeJournalEntry(title, body, project, tags = []) {
+  const journalDir = getJournalDir();
+  fs2.mkdirSync(journalDir, { recursive: true });
+  const now = new Date;
+  const id2 = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")}-${String(now.getUTCHours()).padStart(2, "0")}${String(now.getUTCMinutes()).padStart(2, "0")}${String(now.getUTCSeconds()).padStart(2, "0")}-${String(now.getUTCMilliseconds()).padStart(3, "0")}`;
+  const filePath = path2.join(journalDir, `${id2}.md`);
+  const frontmatter = buildFrontmatter({
+    title,
+    project: project || "",
+    tags,
+    created: now.toISOString()
+  });
+  fs2.writeFileSync(filePath, frontmatter + body + `
+`, "utf-8");
+  return {
+    id: id2,
+    title,
+    body,
+    project,
+    tags,
+    created: now.toISOString(),
+    filePath
+  };
+}
+function searchJournalEntries(query, project, limit = 20) {
+  const journalDir = getJournalDir();
+  if (!fs2.existsSync(journalDir)) {
+    return { entries: [], total: 0 };
+  }
+  const entries = [];
+  const files = fs2.readdirSync(journalDir).filter((f) => f.endsWith(".md")).sort().reverse();
+  for (const file2 of files) {
+    const filePath = path2.join(journalDir, file2);
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter2(content);
+    const entry = {
+      id: file2.replace(".md", ""),
+      title: frontmatter.title || "Untitled",
+      body: body.trim(),
+      project: frontmatter.project,
+      tags: frontmatter.tags || [],
+      created: frontmatter.created || "",
+      filePath
+    };
+    if (project && entry.project !== project)
+      continue;
+    if (query) {
+      const searchText = `${entry.title} ${entry.body}`.toLowerCase();
+      if (!searchText.includes(query.toLowerCase()))
+        continue;
+    }
+    entries.push(entry);
+    if (entries.length >= limit)
+      break;
+  }
+  return { entries, total: files.length };
+}
+var hiveMemoryListTool = tool({
+  description: "List all memory blocks. Shows global (cross-project) and project-scoped blocks with descriptions and sizes.",
+  args: {
+    scope: tool.schema.enum(["global", "project", "all"]).optional().describe("Scope to list: global, project, or all (default: all)")
+  },
+  async execute({ scope = "all" }) {
+    const projectRoot = process.cwd();
+    const blocks = [];
+    if (scope === "global" || scope === "all") {
+      blocks.push(...listMemoryBlocks("global", projectRoot));
+    }
+    if (scope === "project" || scope === "all") {
+      blocks.push(...listMemoryBlocks("project", projectRoot));
+    }
+    if (blocks.length === 0) {
+      return JSON.stringify({
+        message: "No memory blocks found. Use hive_memory_set to create one.",
+        global: [],
+        project: []
+      }, null, 2);
+    }
+    const grouped = {
+      global: blocks.filter((b) => b.scope === "global"),
+      project: blocks.filter((b) => b.scope === "project")
+    };
+    return JSON.stringify({
+      total: blocks.length,
+      global: grouped.global.map((b) => ({
+        label: b.label,
+        description: b.description,
+        charsCurrent: b.charsCurrent,
+        charsLimit: b.limit,
+        readOnly: b.readOnly,
+        lastModified: b.lastModified
+      })),
+      project: grouped.project.map((b) => ({
+        label: b.label,
+        description: b.description,
+        charsCurrent: b.charsCurrent,
+        charsLimit: b.limit,
+        readOnly: b.readOnly,
+        lastModified: b.lastModified
+      }))
+    }, null, 2);
+  }
+});
+var hiveMemorySetTool = tool({
+  description: "Create or overwrite a memory block. Use for full updates.",
+  args: {
+    scope: tool.schema.enum(["global", "project"]).describe("Scope: global (cross-project) or project (project-scoped)"),
+    label: tool.schema.string().describe("Label for the memory block (e.g., persona, human, project, conventions)"),
+    value: tool.schema.string().describe("Content to store in the memory block"),
+    description: tool.schema.string().optional().describe("Description of how this block should be used"),
+    limit: tool.schema.number().optional().describe("Maximum characters allowed (default: 5000)"),
+    readOnly: tool.schema.boolean().optional().describe("Make block read-only (default: false)")
+  },
+  async execute({ scope, label, value, description, limit = 5000, readOnly = false }) {
+    const projectRoot = process.cwd();
+    if (!/^[a-z0-9][a-z0-9-_]{1,60}$/i.test(label)) {
+      return JSON.stringify({
+        success: false,
+        error: `Invalid label "${label}". Use letters/numbers/dash/underscore (2-61 chars).`
+      }, null, 2);
+    }
+    if (value.length > limit) {
+      return JSON.stringify({
+        success: false,
+        error: `Value too large (${value.length} chars, limit: ${limit})`,
+        hint: "Use hive_memory_replace for surgical edits, or increase the limit."
+      }, null, 2);
+    }
+    const dir = scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
+    fs2.mkdirSync(dir, { recursive: true });
+    const filePath = path2.join(dir, `${label}.md`);
+    if (fs2.existsSync(filePath)) {
+      const existing = readMemoryBlock(filePath, scope);
+      if (existing.readOnly) {
+        return JSON.stringify({
+          success: false,
+          error: `Memory block "${scope}:${label}" is read-only`
+        }, null, 2);
+      }
+    }
+    const content = buildFrontmatter({
+      label,
+      description: description || `Memory block: ${label}`,
+      limit,
+      read_only: readOnly
+    });
+    fs2.writeFileSync(filePath, content + value + `
+`, "utf-8");
+    return JSON.stringify({
+      success: true,
+      scope,
+      label,
+      charsWritten: value.length,
+      charsLimit: limit
+    }, null, 2);
+  }
+});
+var hiveMemoryReplaceTool = tool({
+  description: "Replace a substring within a memory block. Use for surgical edits.",
+  args: {
+    scope: tool.schema.enum(["global", "project"]).describe("Scope of the memory block"),
+    label: tool.schema.string().describe("Label of the memory block"),
+    oldText: tool.schema.string().describe("Text to find and replace"),
+    newText: tool.schema.string().describe("Replacement text")
+  },
+  async execute({ scope, label, oldText, newText }) {
+    const projectRoot = process.cwd();
+    const dir = scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
+    const filePath = path2.join(dir, `${label}.md`);
+    if (!fs2.existsSync(filePath)) {
+      return JSON.stringify({
+        success: false,
+        error: `Memory block not found: ${scope}:${label}`
+      }, null, 2);
+    }
+    const block = readMemoryBlock(filePath, scope);
+    if (block.readOnly) {
+      return JSON.stringify({
+        success: false,
+        error: `Memory block "${scope}:${label}" is read-only`
+      }, null, 2);
+    }
+    if (!block.value.includes(oldText)) {
+      return JSON.stringify({
+        success: false,
+        error: `Text not found in "${scope}:${label}"`,
+        hint: "The oldText must match exactly. Try copying from hive_memory_list output."
+      }, null, 2);
+    }
+    const newValue = block.value.replace(oldText, newText);
+    if (newValue.length > block.limit) {
+      return JSON.stringify({
+        success: false,
+        error: `Replacement would exceed limit (${newValue.length} > ${block.limit})`
+      }, null, 2);
+    }
+    const content = buildFrontmatter({
+      label: block.label,
+      description: block.description,
+      limit: block.limit,
+      read_only: block.readOnly
+    });
+    fs2.writeFileSync(filePath, content + newValue + `
+`, "utf-8");
+    return JSON.stringify({
+      success: true,
+      scope,
+      label,
+      charsReplaced: newValue.length
+    }, null, 2);
+  }
+});
+var hiveJournalWriteTool = tool({
+  description: "Write a journal entry. Journal is append-only for capturing insights, decisions, and discoveries.",
+  args: {
+    title: tool.schema.string().describe("Title of the journal entry"),
+    body: tool.schema.string().describe("Content of the journal entry"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Tags to categorize the entry")
+  },
+  async execute({ title, body, tags = [] }) {
+    const projectRoot = process.cwd();
+    const entry = writeJournalEntry(title, body, projectRoot, tags);
+    return JSON.stringify({
+      success: true,
+      id: entry.id,
+      title: entry.title,
+      created: entry.created,
+      message: "Journal entry written successfully"
+    }, null, 2);
+  }
+});
+var hiveJournalSearchTool = tool({
+  description: "Search journal entries. Filter by text query, project, or tags.",
+  args: {
+    query: tool.schema.string().optional().describe("Text to search for in title and body"),
+    project: tool.schema.string().optional().describe("Filter by project path"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Filter by tags"),
+    limit: tool.schema.number().optional().describe("Maximum entries to return (default: 20)")
+  },
+  async execute({ query, project, tags, limit = 20 }) {
+    const result = searchJournalEntries(query, project, limit);
+    return JSON.stringify({
+      total: result.total,
+      returned: result.entries.length,
+      entries: result.entries.map((e) => ({
+        id: e.id,
+        title: e.title,
+        project: e.project,
+        tags: e.tags,
+        created: e.created,
+        preview: e.body.slice(0, 200) + (e.body.length > 200 ? "..." : "")
+      }))
+    }, null, 2);
+  }
+});
+async function buildMemoryInjection(projectRoot) {
+  await ensureMemorySeeded(projectRoot);
+  const globalBlocks = listMemoryBlocks("global", projectRoot);
+  const projectBlocks = listMemoryBlocks("project", projectRoot);
+  if (globalBlocks.length === 0 && projectBlocks.length === 0) {
+    return "";
+  }
+  const sections = [];
+  sections.push("<memory_instructions>");
+  sections.push("You have access to persistent memory blocks that survive across sessions.");
+  sections.push(`Use memory tools to store important information, decisions, and preferences.
+`);
+  if (globalBlocks.length > 0) {
+    sections.push("## Global Memory (cross-project)");
+    for (const block of globalBlocks) {
+      sections.push(`
+### ${block.label} (${block.charsCurrent}/${block.limit} chars)`);
+      sections.push(`_${block.description}_`);
+      sections.push(block.value || "(empty)");
+    }
+  }
+  if (projectBlocks.length > 0) {
+    sections.push(`
+## Project Memory`);
+    for (const block of projectBlocks) {
+      sections.push(`
+### ${block.label} (${block.charsCurrent}/${block.limit} chars)`);
+      sections.push(`_${block.description}_`);
+      sections.push(block.value || "(empty)");
+    }
+  }
+  sections.push(`
+</memory_instructions>`);
+  return sections.join(`
+`);
+}
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
@@ -16700,6 +17122,426 @@ Before verdict, mentally execute 2-3 tasks:
 - Focus on worker success, not perfection
 `;
 
+// src/agents/code-reviewer.ts
+var CODE_REVIEWER_PROMPT = `# Code Review Agent
+
+You are in code review mode. Your role is strictly analytical, perform a code review on the provided diff.
+
+## Guidelines
+
+- **Pragmatic over pedantic**: Flag real problems, not style preferences
+- **Evidence-based**: Every issue must be traceable to specific diff lines
+- **Actionable**: Every issue must have a clear path to resolution
+- **Production-minded**: Assume this code ships to users
+
+## Scope
+
+### CRITICAL FOCUS AREAS:
+1. **Discipline:** Only review code that is part of the diff. Do not flag pre-existing issues in unchanged code.
+2. **Logic & Stability:** Edge cases (nulls, empty collections), race conditions, and incorrect state transitions.
+3. **Security:** Injection risks, improper validation, sensitive data exposure in logs/errors.
+4. **Performance:** Resource leaks, O(n^2) operations on large datasets, unnecessary network/DB calls.
+5. **Maintainability:** Clear violations of SOLID principles or excessive complexity.
+6. **Convention:** AGENTS.md violation (only if AGENTS.md content is available)
+
+### SIMPLIFICATION FOCUS:
+Identify opportunities to simplify while preserving exact functionality:
+- Reduce unnecessary complexity and nesting
+- Remove redundant code/abstractions introduced by the change
+- Improve naming only when it prevents misunderstanding (not for preference)
+- Consolidate related logic when it increases readability
+- Avoid nested ternary operators; prefer if/else or switch
+- Remove comments that restate obvious code
+- Prefer explicit code over dense one-liners
+
+### OPERATIONAL RULES:
+- **No scope creep:** Do not propose refactors outside the diff unless required to fix a blocking issue.
+- **Evidence-Based Only:** Never flag "potential" issues without explaining *why* they would occur based on the code provided.
+- **AGENTS.md Protocol:** If \`AGENTS.md\` exists in the repo, check it for project-specific rules. If not found, ignore all AGENTS.md instructions.
+- **Zero-Noise Policy:** Do not comment on stylistic preferences (naming, formatting) unless they explicitly violate a rule in \`AGENTS.md\`.
+- **Safety First:** Every suggestion must be provably behavior-preserving. When in doubt, omit it.
+- **Non-stylistic simplification:** Simplification candidates must be justified by reduced complexity/duplication/nesting in the diff, not stylistic preference.
+
+## Output Format
+
+## Code review
+
+### Issues
+- A numbered list of blocking issues
+- Each issue MUST include:
+  - reason: "bug" | "security" | "correctness" | "AGENTS.md adherence"
+  - location: \`<path>::<symbol>\` or \`<path>::<global>\` + \`<lines>\` if available
+  - evidence: quote the exact diff hunk lines
+  - fix:
+    - either a committable patch (max 5 lines per file)
+    - or a concise, explicit instruction if a patch would exceed this limit
+
+If no blocking issues are found, explicitly state:
+- "No blocking issues found."
+
+### Simplification candidates (optional)
+Include this section only if there are meaningful refactors that are clearly behavior-preserving.
+- A numbered list of candidates.
+- Each candidate MUST include:
+  - goal: what clarity/maintainability improves
+  - constraints: "no behavior change", and any diff-specific invariants (e.g., "preserve error messages", "keep API shape")
+  - evidence: quote the exact diff hunk lines
+  - location: \`<path>::<symbol>\` or \`<path>::<global>\` + \`<lines>\` if available
+  - suggested change:
+    - either a committable patch (max 5 lines per file)
+    - or a concise refactor plan (if patch would exceed this limit)
+`;
+
+// src/agents/code-simplifier.ts
+var CODE_SIMPLIFIER_PROMPT = `# Code Simplifier Agent
+
+You are a code simplification agent. Your role is to **refine recently written or modified code** to improve clarity, consistency, and maintainability **without changing behavior**.
+
+This agent is intended to be triggered automatically **after a logical chunk of code has been written or modified** (feature implementation, bug fix, refactor, optimization).
+
+You do not introduce new features, fix bugs, or change logic. You only improve how the code is expressed.
+
+## Core principles
+
+### 1. Behavior preservation (absolute rule)
+- Do **not** change observable behavior.
+- Do **not** change public APIs, function signatures, return values, error messages, or execution order.
+- Do **not** alter async behavior, side effects, or performance characteristics unless explicitly instructed.
+- If behavior preservation cannot be proven, **do not apply the change**.
+
+### 2. Scope discipline
+- Only simplify code that was **modified or introduced in the current session**.
+- This includes **untracked files** (new files not yet committed) listed in the working tree.
+- Do not refactor adjacent or pre-existing code unless strictly required to simplify the modified section.
+- No cross-file refactors unless the change itself spans multiple files.
+
+### 3. Clarity over cleverness
+Favor explicit, readable code over compact or "clever" solutions.
+- Prefer simple control flow over dense expressions.
+- Prefer explicit variable names over implicit meaning.
+- Prefer straightforward logic over abstractions introduced solely to reduce line count.
+
+## Simplification focus
+
+Apply simplifications only when they clearly improve readability or maintainability:
+
+- Reduce unnecessary nesting and branching.
+- Remove redundant checks, conversions, or temporary variables introduced by the change.
+- Consolidate closely related logic when it improves readability **without merging concerns**.
+- Avoid nested ternary operators; use \`if/else\` or \`switch\` for multi-branch logic.
+- Remove comments that restate obvious code; keep comments that explain intent or non-obvious decisions.
+- Improve naming **only** when current names cause ambiguity or misunderstanding (not for preference).
+
+## Project standards
+
+- If a project standards file exists (e.g. \`CLAUDE.md\`, \`AGENTS.md\`), follow it.
+- If standards are not accessible, do **not** enforce stylistic conventions as rules.
+- Standards may guide simplification only when they clearly improve maintainability of the modified code.
+
+## Non-goals (do NOT do these)
+- Do not optimize performance unless simplification naturally preserves it.
+- Do not introduce new abstractions unless they clearly reduce complexity.
+- Do not refactor for consistency across the whole codebase.
+- Do not reformat code purely for style or aesthetics.
+- Do not rewrite working code "because it could be nicer".
+
+## Execution process
+
+1. Identify code that was added or modified in the current session, **including untracked files listed in the diff**.
+2. **Read the content of untracked files** using the Read tool before analyzing them.
+3. Analyze the code for unnecessary complexity, redundancy, or unclear structure.
+4. Apply minimal, behavior-preserving refinements.
+5. Re-check that functionality, outputs, and side effects are unchanged.
+6. Produce the simplified code.
+
+## Output requirements
+
+- Apply changes directly to the code.
+- Keep changes minimal and localized.
+- If no meaningful simplification is possible, make no changes.
+- If a change could be controversial or borderline, prefer omission.
+
+Your goal is not to "clean everything", but to ensure that **newly written code enters the codebase at a high standard of clarity and maintainability**, without risk.
+`;
+
+// src/agents/codebase-locator.ts
+var CODEBASE_LOCATOR_PROMPT = `# Codebase Locator Agent
+
+You are a SUBAGENT for finding file locations in the codebase.
+
+## Purpose
+Find WHERE files live. No content analysis, no suggestions, no opinions, just locations.
+
+## Rules
+
+- Return file paths only
+- Organize results by logical category
+- Be exhaustive - find ALL relevant files
+- Include test files when relevant
+- Include config files when relevant
+
+## Search Strategies
+
+- **by-name**: Glob for file names
+- **by-content**: Grep for specific terms, imports, usage
+- **by-convention**: Check standard locations (src/, lib/, tests/, config/)
+- **by-extension**: Filter by file type
+- **by-import**: Find files that import/export a symbol
+
+## Categories
+
+- Source files
+- Test files
+- Type definitions
+- Configuration
+- Documentation
+- Scripts
+
+## Output Format
+
+## Source Files
+- path/to/file.ts
+- path/to/another.ts
+
+## Tests
+- path/to/file.test.ts
+- path/to/another.spec.ts
+
+## Config
+- path/to/config.json
+- path/to/tsconfig.json
+`;
+
+// src/agents/codebase-analyzer.ts
+var CODEBASE_ANALYZER_PROMPT = `# Codebase Analyzer Agent
+
+You are a SUBAGENT for analyzing and explaining code behavior.
+
+## Purpose
+Explain HOW code works. Document what IS, not what SHOULD BE.
+
+## Rules
+
+- Always include file:line references
+- Read files COMPLETELY - never use limit/offset
+- Describe behavior, not quality
+- No suggestions, no improvements, no opinions
+- Trace actual execution paths, not assumptions
+- Include error handling paths
+- Document side effects explicitly
+- Note any external dependencies called
+
+## Process
+
+1. Identify entry points
+2. Read all relevant files completely
+3. Trace data flow step by step
+4. Trace control flow (conditionals, loops, early returns)
+5. Document function calls with their locations
+6. Note state mutations and side effects
+7. Map error propagation paths
+
+## Output Format
+
+## [Component/Feature]
+
+**Purpose**: [One sentence]
+
+**Entry point**: \`file:line\`
+
+**Data flow**:
+1. \`file:line\` - [what happens]
+2. \`file:line\` - [next step]
+3. \`file:line\` - [continues...]
+
+**Key functions**:
+- \`functionName\` at \`file:line\` - [what it does]
+- \`anotherFn\` at \`file:line\` - [what it does]
+
+**State mutations**:
+- \`file:line\` - [what changes]
+
+**Error paths**:
+- \`file:line\` - [error condition] → [handling]
+
+**External calls**:
+- \`file:line\` - calls [external service/API]
+
+## Tracing Rules
+
+- Follow imports to their source
+- Expand function calls inline when relevant
+- Note async boundaries explicitly
+- Track data transformations step by step
+- Document callback and event flows
+- Include middleware/interceptor chains
+`;
+
+// src/agents/pattern-finder.ts
+var PATTERN_FINDER_PROMPT = `# Pattern Finder Agent
+
+You are a SUBAGENT for finding coding patterns and conventions.
+
+## Purpose
+Find existing patterns in the codebase to model after. Show, don't tell.
+
+## Rules
+
+- Provide concrete code examples, not abstract descriptions
+- Always include file:line references
+- Show 2-3 best examples, not exhaustive lists
+- Include enough context to understand usage
+- Prioritize recent/maintained code over legacy
+- Include test examples when available
+- Note any variations of the pattern
+
+## What to Find
+
+- How similar features are implemented
+- Naming conventions used
+- Error handling patterns
+- Testing patterns
+- File organization patterns
+- Import/export patterns
+- Configuration patterns
+- API patterns (routes, handlers, responses)
+
+## Search Process
+
+1. Grep for similar implementations
+2. Check test files for usage examples
+3. Look for documentation or comments
+4. Find the most representative example
+5. Find variations if they exist
+
+## Output Format
+
+## Pattern: [Name]
+
+**Best example**: \`file:line-line\`
+\`\`\`language
+[code snippet]
+\`\`\`
+
+**Also see**:
+- \`file:line\` - [variation/alternative]
+
+**Usage notes**: [when/how to apply]
+
+## Quality Criteria
+
+- Prefer patterns with tests
+- Prefer patterns that are widely used
+- Prefer recent over old
+- Prefer simple over complex
+- Note if pattern seems inconsistent across codebase
+`;
+
+// src/agents/project-initializer.ts
+var PROJECT_INITIALIZER_PROMPT = `# Project Initializer Agent
+
+You are a SUBAGENT - use task tool to spawn other subagents for parallel execution.
+
+## Purpose
+Rapidly analyze any project and generate ARCHITECTURE.md and CODE_STYLE.md
+
+## Critical Rule
+MAXIMIZE PARALLELISM. Speed is critical.
+- Call multiple task tools in ONE message for parallel execution
+- Never wait for one thing when you can do many
+
+## Task
+Generate two documentation files that help AI agents understand this codebase:
+- ARCHITECTURE.md - Project structure, components, and data flow
+- CODE_STYLE.md - Coding conventions, patterns, and guidelines
+
+## Parallel Execution Strategy
+
+### Phase 1: Discovery
+Launch ALL discovery in ONE message:
+- Glob for entry points, configs, main modules
+- Glob for test files and test patterns
+- Glob for linter, formatter, CI configs
+- Use grep to find key patterns
+
+### Phase 2: Deep Analysis
+Based on discovery:
+- Read 5 core source files simultaneously
+- Read 3 test files simultaneously
+- Read config files simultaneously
+
+### Phase 3: Write Output Files
+- Write ARCHITECTURE.md
+- Write CODE_STYLE.md
+
+## Available Subagents
+
+Use task tool to spawn subagents:
+- **codebase-locator**: Fast file/pattern finder
+- **codebase-analyzer**: Deep module analyzer
+- **pattern-finder**: Pattern extractor
+
+## Language Detection
+
+Identify language(s) by examining file extensions and config files:
+- Python: pyproject.toml, setup.py, requirements.txt, *.py
+- JavaScript/TypeScript: package.json, tsconfig.json, *.js, *.ts, *.tsx
+- Go: go.mod, go.sum, *.go
+- Rust: Cargo.toml, *.rs
+- Java: pom.xml, build.gradle, *.java
+
+## Architecture Analysis
+
+Answer these questions:
+- What does this project do? (purpose)
+- What are the main entry points?
+- How is the code organized? (modules, packages, layers)
+- What are the core abstractions?
+- How does data flow through the system?
+- What external services does it integrate with?
+- How is configuration managed?
+- What's the deployment model?
+
+## Code Style Analysis
+
+Answer these questions:
+- How are files and directories named?
+- How are functions, classes, variables named?
+- What patterns are used consistently?
+- How are errors handled?
+- How is logging done?
+- What testing patterns are used?
+- Are there linter/formatter configs to reference?
+
+## Output Requirements
+
+- ARCHITECTURE.md should let someone understand the system in 5 minutes
+- CODE_STYLE.md should let someone write conforming code immediately
+- Keep total size under 500 lines per file
+- Use bullet points and tables over prose
+- Include file paths for everything you reference
+
+## Execution Steps
+
+1. **Discovery** (parallel):
+   - Glob for package.json, pyproject.toml, go.mod, Cargo.toml
+   - Glob for *.config.*, .eslintrc*, .prettierrc*
+   - Glob for README*, CONTRIBUTING*
+   - Read root directory listing
+   - Use task to spawn codebase-locator for entry points
+   - Use task to spawn codebase-locator for test files
+   - Use task to spawn codebase-locator for config files
+
+2. **Deep Analysis** (parallel):
+   - Read multiple source files
+   - Use task to spawn codebase-analyzer for core modules
+   - Use task to spawn pattern-finder for conventions
+
+3. **Write output files**:
+   - Write ARCHITECTURE.md
+   - Write CODE_STYLE.md
+`;
+
 // src/agents/custom-agents.ts
 function buildCustomSubagents({
   customAgents,
@@ -16772,15 +17614,15 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path3 from "path";
+import * as fs3 from "fs";
 import * as path22 from "path";
 import * as fs22 from "fs";
-import * as fs3 from "fs";
+import * as fs32 from "fs";
 import * as fs4 from "fs";
 import * as fs5 from "fs";
 import * as fs7 from "fs/promises";
-import * as path3 from "path";
+import * as path32 from "path";
 import { Buffer as Buffer2 } from "node:buffer";
 import { spawn } from "child_process";
 import { normalize } from "node:path";
@@ -16792,7 +17634,7 @@ import * as path6 from "path";
 import * as fs11 from "fs";
 import * as path7 from "path";
 import { existsSync as existsSync5 } from "fs";
-import { join as join8, sep } from "path";
+import { join as join82, sep } from "path";
 import { execSync } from "child_process";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -17451,10 +18293,10 @@ var require_src2 = __commonJS((exports) => {
   var fs_1 = __require2("fs");
   var debug_1 = __importDefault(require_src());
   var log = debug_1.default("@kwsites/file-exists");
-  function check2(path32, isFile, isDirectory) {
-    log(`checking %s`, path32);
+  function check2(path33, isFile, isDirectory) {
+    log(`checking %s`, path33);
     try {
-      const stat2 = fs_1.statSync(path32);
+      const stat2 = fs_1.statSync(path33);
       if (stat2.isFile() && isFile) {
         log(`[OK] path represents a file`);
         return true;
@@ -17474,8 +18316,8 @@ var require_src2 = __commonJS((exports) => {
       throw e;
     }
   }
-  function exists(path32, type = exports.READABLE) {
-    return check2(path32, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+  function exists(path33, type = exports.READABLE) {
+    return check2(path33, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
   }
   exports.exists = exists;
   exports.FILE = 1;
@@ -17616,6 +18458,19 @@ var DEFAULT_HIVE_CONFIG = {
       skills: [],
       autoLoadSkills: []
     }
+  },
+  tokenTruncation: {
+    enabled: true,
+    maxChars: 30000,
+    keepFirstPercent: 40,
+    keepLastPercent: 40
+  },
+  sessionSnapshot: {
+    enabled: true,
+    maxSnapshotChars: 2048,
+    includeActiveFeature: true,
+    includePendingTasks: true,
+    includeModifiedFiles: false
   }
 };
 var HIVE_DIR = ".hive";
@@ -17632,78 +18487,78 @@ function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function getHivePath(projectRoot) {
-  return path2.join(projectRoot, HIVE_DIR);
+  return path3.join(projectRoot, HIVE_DIR);
 }
 function getFeaturesPath(projectRoot) {
-  return path2.join(getHivePath(projectRoot), FEATURES_DIR);
+  return path3.join(getHivePath(projectRoot), FEATURES_DIR);
 }
 function getFeaturePath(projectRoot, featureName) {
-  return path2.join(getFeaturesPath(projectRoot), featureName);
+  return path3.join(getFeaturesPath(projectRoot), featureName);
 }
 function getPlanPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
+  return path3.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
 }
 function getCommentsPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
+  return path3.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
 }
 function getFeatureJsonPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
+  return path3.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
 }
 function getContextPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
+  return path3.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
 }
 function getTasksPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
+  return path3.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
 }
 function getTaskPath(projectRoot, featureName, taskFolder) {
-  return path2.join(getTasksPath(projectRoot, featureName), taskFolder);
+  return path3.join(getTasksPath(projectRoot, featureName), taskFolder);
 }
 function getTaskStatusPath(projectRoot, featureName, taskFolder) {
-  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
+  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
 }
 function getTaskReportPath(projectRoot, featureName, taskFolder) {
-  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
+  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
 }
 function getTaskSpecPath(projectRoot, featureName, taskFolder) {
-  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
+  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
 }
 function getApprovedPath(projectRoot, featureName) {
-  return path2.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
+  return path3.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
 }
 var SUBTASKS_DIR = "subtasks";
 var SPEC_FILE = "spec.md";
 function getSubtasksPath(projectRoot, featureName, taskFolder) {
-  return path2.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
+  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
 }
 function getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path2.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
+  return path3.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
 }
 function getSubtaskStatusPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
+  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
 }
 function getSubtaskSpecPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
+  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
 }
 function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path2.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
+  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs2.existsSync(filePath);
+  return fs3.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs2.existsSync(filePath))
+  if (!fs3.existsSync(filePath))
     return null;
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
-  ensureDir(path2.dirname(filePath));
-  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  ensureDir(path3.dirname(filePath));
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -17715,7 +18570,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs2.statSync(lockPath);
+    const stat2 = fs3.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -17725,7 +18580,7 @@ function isLockStale(lockPath, staleTTL) {
 function acquireLockSync(filePath, options = {}) {
   const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
   const lockPath = getLockPath(filePath);
-  const lockDir = path2.dirname(lockPath);
+  const lockDir = path3.dirname(lockPath);
   const startTime = Date.now();
   const lockContent = JSON.stringify({
     pid: process.pid,
@@ -17735,12 +18590,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs2.openSync(lockPath, fs2.constants.O_CREAT | fs2.constants.O_EXCL | fs2.constants.O_WRONLY);
-      fs2.writeSync(fd, lockContent);
-      fs2.closeSync(fd);
+      const fd = fs3.openSync(lockPath, fs3.constants.O_CREAT | fs3.constants.O_EXCL | fs3.constants.O_WRONLY);
+      fs3.writeSync(fd, lockContent);
+      fs3.closeSync(fd);
       return () => {
         try {
-          fs2.unlinkSync(lockPath);
+          fs3.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -17750,7 +18605,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs2.unlinkSync(lockPath);
+            fs3.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -17766,14 +18621,14 @@ function acquireLockSync(filePath, options = {}) {
   }
 }
 function writeAtomic(filePath, content) {
-  ensureDir(path2.dirname(filePath));
+  ensureDir(path3.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs2.writeFileSync(tempPath, content);
-    fs2.renameSync(tempPath, filePath);
+    fs3.writeFileSync(tempPath, content);
+    fs3.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs2.unlinkSync(tempPath);
+      fs3.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -17808,13 +18663,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs2.existsSync(filePath))
+  if (!fs3.existsSync(filePath))
     return null;
-  return fs2.readFileSync(filePath, "utf-8");
+  return fs3.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
-  ensureDir(path2.dirname(filePath));
-  fs2.writeFileSync(filePath, content);
+  ensureDir(path3.dirname(filePath));
+  fs3.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -17896,7 +18751,7 @@ class FeatureService {
     const featuresPath = getFeaturesPath(this.projectRoot);
     if (!fileExists(featuresPath))
       return [];
-    return fs3.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return fs32.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   getActive() {
     const features = this.list();
@@ -17942,7 +18797,7 @@ class FeatureService {
     const tasksPath = getTasksPath(this.projectRoot, featureName);
     if (!fileExists(tasksPath))
       return [];
-    const folders = fs3.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    const folders = fs32.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
     return folders.map((folder) => {
       const statusPath = `${tasksPath}/${folder}/status.json`;
       const status = readJson(statusPath);
@@ -18272,20 +19127,20 @@ ${f.content}`).join(`
       return [task.order - 1];
     };
     const visited = new Map;
-    const path32 = [];
+    const path33 = [];
     const dfs = (taskOrder) => {
       const state = visited.get(taskOrder);
       if (state === 2) {
         return;
       }
       if (state === 1) {
-        const cycleStart = path32.indexOf(taskOrder);
-        const cyclePath = [...path32.slice(cycleStart), taskOrder];
+        const cycleStart = path33.indexOf(taskOrder);
+        const cyclePath = [...path33.slice(cycleStart), taskOrder];
         const cycleDesc = cyclePath.join(" -> ");
         throw new Error(`Invalid dependency graph in plan.md: Cycle detected in task dependencies: ${cycleDesc}. ` + `Tasks cannot have circular dependencies. Please fix the "Depends on:" lines in plan.md.`);
       }
       visited.set(taskOrder, 1);
-      path32.push(taskOrder);
+      path33.push(taskOrder);
       const task = taskByOrder.get(taskOrder);
       if (task) {
         const deps = getDependencies(task);
@@ -18293,7 +19148,7 @@ ${f.content}`).join(`
           dfs(depOrder);
         }
       }
-      path32.pop();
+      path33.pop();
       visited.set(taskOrder, 2);
     };
     for (const task of tasks) {
@@ -18639,8 +19494,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path32) {
-  return path32 instanceof String && cache.has(path32);
+function isPathSpec(path33) {
+  return path33 instanceof String && cache.has(path33);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -18726,8 +19581,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = `
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path32) {
-  return import_file_exists.exists(path32, import_file_exists.FOLDER);
+function folderExists(path33) {
+  return import_file_exists.exists(path33, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -19118,8 +19973,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path32) {
-      return /^\.(git)?$/.test(path32.trim());
+    parser(path33) {
+      return /^\.(git)?$/.test(path33.trim());
     }
   };
 }
@@ -19530,11 +20385,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set;
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path32, line, preview] = input.split(NULL);
-    paths.add(path32);
-    (results[path32] = results[path32] || []).push({
+    const [path33, line, preview] = input.split(NULL);
+    paths.add(path33);
+    (results[path33] = results[path33] || []).push({
       line: asNumber(line),
-      path: path32,
+      path: path33,
       preview
     });
   });
@@ -20200,14 +21055,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path32, text) {
+function parseInit(bare, path33, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path32, false, result[1]);
+    return new InitSummary(bare, path33, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path32, true, result[1]);
+    return new InitSummary(bare, path33, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -20218,7 +21073,7 @@ function parseInit(bare, path32, text) {
       break;
     }
   }
-  return new InitSummary(bare, path32, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path33, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -20226,9 +21081,9 @@ var reInitResponseRegex;
 var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
-      constructor(bare, path32, existing, gitDir) {
+      constructor(bare, path33, existing, gitDir) {
         this.bare = bare;
-        this.path = path32;
+        this.path = path33;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -20240,7 +21095,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path32, customArgs) {
+function initTask(bare = false, path33, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -20249,7 +21104,7 @@ function initTask(bare = false, path32, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path32, text);
+      return parseInit(commands.includes("--bare"), path33, text);
     }
   };
 }
@@ -20964,12 +21819,12 @@ var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path32, index, working_dir) {
-        this.path = path32;
+      constructor(path33, index, working_dir) {
+        this.path = path33;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path32) || [null, path32, path32];
+          const detail = fromPathRegex.exec(path33) || [null, path33, path33];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -21000,14 +21855,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path32) {
+  function data(index, workingDir, path33) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path32);
+      handler(result, path33);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path32, index, workingDir));
+      result.files.push(new FileStatusSummary(path33, index, workingDir));
     }
   }
 }
@@ -21291,8 +22146,8 @@ var init_simple_git_api = __esm2({
         }
         return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
       }
-      hashObject(path32, write) {
-        return this._runTask(hashObjectTask(path32, write === true), trailingFunctionArgument(arguments));
+      hashObject(path33, write) {
+        return this._runTask(hashObjectTask(path33, write === true), trailingFunctionArgument(arguments));
       }
       init(bare) {
         return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
@@ -21585,8 +22440,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path32 = input.trim().replace(/^["']|["']$/g, "");
-  return path32 && normalize(path32);
+  const path33 = input.trim().replace(/^["']|["']$/g, "");
+  return path33 && normalize(path33);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -21851,8 +22706,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path32) {
-  return subModuleTask(["add", repo, path32]);
+function addSubModuleTask(repo, path33) {
+  return subModuleTask(["add", repo, path33]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -22106,8 +22961,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path32, then) {
-      return this._runTask(addSubModuleTask2(repo, path32), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path33, then) {
+      return this._runTask(addSubModuleTask2(repo, path33), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
@@ -22640,19 +23495,19 @@ class WorktreeService {
     return esm_default(cwd || this.config.baseDir);
   }
   getWorktreesDir() {
-    return path3.join(this.config.hiveDir, ".worktrees");
+    return path32.join(this.config.hiveDir, ".worktrees");
   }
   getWorktreePath(feature, step) {
-    return path3.join(this.getWorktreesDir(), feature, step);
+    return path32.join(this.getWorktreesDir(), feature, step);
   }
   async getStepStatusPath(feature, step) {
-    const featurePath = path3.join(this.config.hiveDir, "features", feature);
-    const tasksPath = path3.join(featurePath, "tasks", step, "status.json");
+    const featurePath = path32.join(this.config.hiveDir, "features", feature);
+    const tasksPath = path32.join(featurePath, "tasks", step, "status.json");
     try {
       await fs7.access(tasksPath);
       return tasksPath;
     } catch {}
-    return path3.join(featurePath, "execution", step, "status.json");
+    return path32.join(featurePath, "execution", step, "status.json");
   }
   getBranchName(feature, step) {
     return `hive/${feature}/${step}`;
@@ -22661,7 +23516,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
-    await fs7.mkdir(path3.dirname(worktreePath), { recursive: true });
+    await fs7.mkdir(path32.dirname(worktreePath), { recursive: true });
     const base = baseBranch || (await git.revparse(["HEAD"])).trim();
     const existing = await this.get(feature, step);
     if (existing) {
@@ -22756,7 +23611,7 @@ class WorktreeService {
   }
   async exportPatch(feature, step, baseBranch) {
     const worktreePath = this.getWorktreePath(feature, step);
-    const patchPath = path3.join(worktreePath, "..", `${step}.patch`);
+    const patchPath = path32.join(worktreePath, "..", `${step}.patch`);
     const base = baseBranch || "HEAD~1";
     const worktreeGit = this.getGit(worktreePath);
     const diff = await worktreeGit.diff([`${base}...HEAD`]);
@@ -22768,7 +23623,7 @@ class WorktreeService {
     if (!hasDiff) {
       return { success: true, filesAffected: [] };
     }
-    const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
+    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
       await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
@@ -22790,7 +23645,7 @@ class WorktreeService {
     if (!hasDiff) {
       return { success: true, filesAffected: [] };
     }
-    const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
+    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
       await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
@@ -22859,7 +23714,7 @@ class WorktreeService {
     try {
       const features = feature ? [feature] : await fs7.readdir(worktreesDir);
       for (const feat of features) {
-        const featurePath = path3.join(worktreesDir, feat);
+        const featurePath = path32.join(worktreesDir, feat);
         const stat2 = await fs7.stat(featurePath).catch(() => null);
         if (!stat2?.isDirectory())
           continue;
@@ -22883,13 +23738,13 @@ class WorktreeService {
     const worktreesDir = this.getWorktreesDir();
     const features = feature ? [feature] : await fs7.readdir(worktreesDir).catch(() => []);
     for (const feat of features) {
-      const featurePath = path3.join(worktreesDir, feat);
+      const featurePath = path32.join(worktreesDir, feat);
       const stat2 = await fs7.stat(featurePath).catch(() => null);
       if (!stat2?.isDirectory())
         continue;
       const steps = await fs7.readdir(featurePath).catch(() => []);
       for (const step of steps) {
-        const worktreePath = path3.join(featurePath, step);
+        const worktreePath = path32.join(featurePath, step);
         const stepStat = await fs7.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
@@ -22909,7 +23764,7 @@ class WorktreeService {
     if (!hasDiff) {
       return [];
     }
-    const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
+    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
     try {
       await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
@@ -23592,19 +24447,19 @@ class AgentsMdService {
 
 class DockerSandboxService {
   static detectImage(worktreePath) {
-    if (existsSync5(join8(worktreePath, "Dockerfile"))) {
+    if (existsSync5(join82(worktreePath, "Dockerfile"))) {
       return null;
     }
-    if (existsSync5(join8(worktreePath, "package.json"))) {
+    if (existsSync5(join82(worktreePath, "package.json"))) {
       return "node:22-slim";
     }
-    if (existsSync5(join8(worktreePath, "requirements.txt")) || existsSync5(join8(worktreePath, "pyproject.toml"))) {
+    if (existsSync5(join82(worktreePath, "requirements.txt")) || existsSync5(join82(worktreePath, "pyproject.toml"))) {
       return "python:3.12-slim";
     }
-    if (existsSync5(join8(worktreePath, "go.mod"))) {
+    if (existsSync5(join82(worktreePath, "go.mod"))) {
       return "golang:1.22-slim";
     }
-    if (existsSync5(join8(worktreePath, "Cargo.toml"))) {
+    if (existsSync5(join82(worktreePath, "Cargo.toml"))) {
       return "rust:1.77-slim";
     }
     return "ubuntu:24.04";
@@ -24251,7 +25106,7 @@ async function buildAutoLoadedSkillsContent(agentName, configService, projectRoo
   if (autoLoadSkills.length === 0) {
     return "";
   }
-  const homeDir = process.env.HOME || os.homedir();
+  const homeDir = process.env.HOME || os2.homedir();
   const skillTemplates = [];
   for (const skillId of autoLoadSkills) {
     const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
@@ -24794,6 +25649,10 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
         return;
       }
       output.system.push(HIVE_SYSTEM_PROMPT);
+      const memoryInjection = await buildMemoryInjection(directory);
+      if (memoryInjection) {
+        output.system.push(memoryInjection);
+      }
       const activeFeature = resolveFeature();
       if (activeFeature) {
         const info = featureService.getInfo(activeFeature);
@@ -24814,16 +25673,64 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       }
     },
     "experimental.session.compacting": async (input, output) => {
+      const snapshotConfig = configService.get().sessionSnapshot;
+      const compressionConfig = configService.get().contextCompression;
+      if (snapshotConfig?.enabled !== false) {
+        const snapshotParts = [];
+        const maxChars = snapshotConfig?.maxSnapshotChars ?? 2048;
+        if (snapshotConfig?.includeActiveFeature !== false) {
+          try {
+            const active = featureService.getActive();
+            if (active) {
+              snapshotParts.push(`## Active Feature: ${active.name}`);
+              snapshotParts.push(`Status: ${active.status}`);
+            }
+          } catch {}
+        }
+        if (snapshotConfig?.includePendingTasks !== false) {
+          try {
+            const featureNames = featureService.list();
+            const pendingTasks = [];
+            for (const name of featureNames) {
+              const info = featureService.getInfo(name);
+              if (info && info.status !== "completed") {
+                const pending = info.tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
+                for (const task of pending) {
+                  pendingTasks.push(`- [${task.status}] ${task.name}`);
+                }
+              }
+            }
+            if (pendingTasks.length > 0) {
+              snapshotParts.push(`
+## Pending Tasks (${pendingTasks.length})`);
+              snapshotParts.push(...pendingTasks.slice(0, 20));
+            }
+          } catch {}
+        }
+        if (snapshotParts.length > 0) {
+          const snapshot = snapshotParts.join(`
+`).slice(0, maxChars);
+          output.context.push(`
+## Session Snapshot (before compaction)
+
+${snapshot}
+
+**Important:** After compaction, resume from where you left off. Check the pending tasks above and continue working.
+`);
+        }
+      }
       const contextLimit = input.contextLimit || 200000;
       const messages = input.messages || [];
       if (messages.length > 0) {
-        const { estimateTokens: estimateTokens2, needsCompression: needsCompression2, compressContext: compressContext2, buildCompressionHint: buildCompressionHint2 } = await Promise.resolve().then(() => (init_context_compression(), exports_context_compression));
-        if (needsCompression2(messages, contextLimit, { threshold: 0.5, enabled: true })) {
-          const { compressed, stats } = compressContext2(messages, {
-            threshold: 0.5,
-            enabled: true,
-            maxToolCalls: 50,
-            protectedTools: [
+        const { needsCompression: needsCompression2, compressContext: compressContext2, buildCompressionHint: buildCompressionHint2 } = await Promise.resolve().then(() => (init_context_compression(), exports_context_compression));
+        const threshold = compressionConfig?.threshold ?? 0.5;
+        const enabled = compressionConfig?.enabled ?? true;
+        if (needsCompression2(messages, contextLimit, { threshold, enabled })) {
+          const { stats } = compressContext2(messages, {
+            threshold,
+            enabled,
+            maxToolCalls: compressionConfig?.maxToolCalls ?? 50,
+            protectedTools: compressionConfig?.protectedTools ?? [
               "hive_feature_create",
               "hive_plan_write",
               "hive_worktree_commit",
@@ -24868,6 +25775,27 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       output.args.command = wrapped;
       output.args.workdir = undefined;
     },
+    "tool.execute.after": async (input, output) => {
+      const truncationConfig = configService.get().tokenTruncation;
+      if (!truncationConfig?.enabled)
+        return;
+      const result = output.output;
+      if (!result)
+        return;
+      const maxChars = truncationConfig.maxChars ?? 30000;
+      if (result.length <= maxChars)
+        return;
+      const keepFirst = truncationConfig.keepFirstPercent ?? 40;
+      const keepLast = truncationConfig.keepLastPercent ?? 40;
+      const firstChars = Math.floor(result.length * keepFirst / 100);
+      const lastChars = Math.floor(result.length * keepLast / 100);
+      const truncated = result.slice(0, firstChars) + `
+
+[... ${result.length - firstChars - lastChars} characters truncated ...]
+
+` + result.slice(-lastChars);
+      output.output = truncated;
+    },
     mcp: builtinMcps,
     tool: {
       gitingest: gitingestTool,
@@ -24887,6 +25815,11 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       lsp_code_actions: lspCodeActionsTool,
       skill_mcp: skillMcpTool,
       list_skill_mcps: listSkillMcpsTool,
+      hive_memory_list: hiveMemoryListTool,
+      hive_memory_set: hiveMemorySetTool,
+      hive_memory_replace: hiveMemoryReplaceTool,
+      hive_journal_write: hiveJournalWriteTool,
+      hive_journal_search: hiveJournalSearchTool,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
@@ -25661,13 +26594,111 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
           skill: "allow"
         }
       };
+      const micodeUserConfig = configService.getAgentConfig("codebase-locator");
+      const codebaseLocatorConfig = {
+        model: micodeUserConfig.model,
+        variant: micodeUserConfig.variant,
+        temperature: micodeUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Codebase Locator - Finds WHERE files live in the codebase. No analysis, just locations.",
+        prompt: CODEBASE_LOCATOR_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
+      const codebaseAnalyzerConfig = {
+        model: micodeUserConfig.model,
+        variant: micodeUserConfig.variant,
+        temperature: micodeUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Codebase Analyzer - Explains HOW code works. Deep module analysis.",
+        prompt: CODEBASE_ANALYZER_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
+      const patternFinderConfig = {
+        model: micodeUserConfig.model,
+        variant: micodeUserConfig.variant,
+        temperature: micodeUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Pattern Finder - Finds patterns to model after. Extracts conventions.",
+        prompt: PATTERN_FINDER_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
+      const projectInitializerConfig = {
+        model: micodeUserConfig.model,
+        variant: micodeUserConfig.variant,
+        temperature: micodeUserConfig.temperature ?? 0.5,
+        mode: "subagent",
+        description: "Project Initializer - Generates project documentation from codebase analysis.",
+        prompt: PROJECT_INITIALIZER_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_context_write", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
+      const froggyUserConfig = configService.getAgentConfig("code-reviewer");
+      const codeReviewerConfig = {
+        model: froggyUserConfig.model,
+        variant: froggyUserConfig.variant,
+        temperature: froggyUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Code Reviewer - Reviews code for quality, correctness, security, and maintainability.",
+        prompt: CODE_REVIEWER_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
+      const codeSimplifierConfig = {
+        model: froggyUserConfig.model,
+        variant: froggyUserConfig.variant,
+        temperature: froggyUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Code Simplifier - Simplifies recently modified code for clarity while preserving behavior.",
+        prompt: CODE_SIMPLIFIER_PROMPT,
+        tools: agentTools(["hive_plan_read", "hive_skill"]),
+        permission: {
+          edit: "deny",
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
       const builtInAgentConfigs = {
         zetta: zettaConfig,
         "architect-planner": architectConfig,
         "swarm-orchestrator": swarmConfig,
         "scout-researcher": scoutConfig,
         "forager-worker": foragerConfig,
-        "hygienic-reviewer": hygienicConfig
+        "hygienic-reviewer": hygienicConfig,
+        "code-reviewer": codeReviewerConfig,
+        "code-simplifier": codeSimplifierConfig,
+        "codebase-locator": codebaseLocatorConfig,
+        "codebase-analyzer": codebaseAnalyzerConfig,
+        "pattern-finder": patternFinderConfig,
+        "project-initializer": projectInitializerConfig
       };
       const customAutoLoadedSkills = Object.fromEntries(await Promise.all(Object.entries(customAgentConfigs).map(async ([customAgentName, customAgentConfig]) => {
         const inheritedBaseSkills = customAgentConfig.baseAgent === "forager-worker" ? foragerUserConfig.autoLoadSkills ?? [] : hygienicUserConfig.autoLoadSkills ?? [];