opencode-swarm-plugin 0.30.6 → 0.31.0

package/dist/swarm-prompts.d.ts

@@ -17,11 +17,11 @@
  * Used by swarm_decompose to instruct the agent on how to break down work.
  * The agent responds with a CellTree that gets validated.
  */
-export declare const DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{context_section}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\n## Guidelines\n\n- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task\n- **Prefer smaller, focused subtasks** over large complex ones\n- **Include test files** in the same subtask as the code they test\n- **Consider shared types** - if multiple files share types, handle that first\n- **Think about imports** - changes to exported APIs affect downstream files\n- **Explicit > implicit** - spell out what each subtask should do, don't assume\n\n## File Assignment Examples\n\n- Schema change: `[\"src/schemas/user.ts\", \"src/schemas/index.ts\"]`\n- Component + test: `[\"src/components/Button.tsx\", \"src/components/Button.test.tsx\"]`\n- API route: `[\"src/app/api/users/route.ts\"]`\n\nNow decompose the task:";
+export declare const DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{context_section}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into independent subtasks** that can run in parallel (as many as needed)\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\n## Guidelines\n\n- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task\n- **Prefer smaller, focused subtasks** over large complex ones\n- **Include test files** in the same subtask as the code they test\n- **Consider shared types** - if multiple files share types, handle that first\n- **Think about imports** - changes to exported APIs affect downstream files\n- **Explicit > implicit** - spell out what each subtask should do, don't assume\n\n## File Assignment Examples\n\n- Schema change: `[\"src/schemas/user.ts\", \"src/schemas/index.ts\"]`\n- Component + test: `[\"src/components/Button.tsx\", \"src/components/Button.test.tsx\"]`\n- API route: `[\"src/app/api/users/route.ts\"]`\n\nNow decompose the task:";
 /**
  * Strategy-specific decomposition prompt template
  */
-export declare const STRATEGY_DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{strategy_guidelines}\n\n{context_section}\n\n{cass_history}\n\n{skills_context}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\nNow decompose the task:";
+export declare const STRATEGY_DECOMPOSITION_PROMPT = "You are decomposing a task into parallelizable subtasks for a swarm of agents.\n\n## Task\n{task}\n\n{strategy_guidelines}\n\n{context_section}\n\n{cass_history}\n\n{skills_context}\n\n## MANDATORY: Hive Issue Tracking\n\n**Every subtask MUST become a cell.** This is non-negotiable.\n\nAfter decomposition, the coordinator will:\n1. Create an epic cell for the overall task\n2. Create child cells for each subtask\n3. Track progress through cell status updates\n4. Close cells with summaries when complete\n\nAgents MUST update their cell status as they work. No silent progress.\n\n## Requirements\n\n1. **Break into independent subtasks** that can run in parallel (as many as needed)\n2. **Assign files** - each subtask must specify which files it will modify\n3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)\n4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array\n5. **Estimate complexity** - 1 (trivial) to 5 (complex)\n6. **Plan aggressively** - break down more than you think necessary, smaller is better\n\n## Response Format\n\nRespond with a JSON object matching this schema:\n\n```typescript\n{\n  epic: {\n    title: string,        // Epic title for the hive tracker\n    description?: string  // Brief description of the overall goal\n  },\n  subtasks: [\n    {\n      title: string,              // What this subtask accomplishes\n      description?: string,       // Detailed instructions for the agent\n      files: string[],            // Files this subtask will modify (globs allowed)\n      dependencies: number[],     // Indices of subtasks this depends on (0-indexed)\n      estimated_complexity: 1-5   // Effort estimate\n    },\n    // ... more subtasks\n  ]\n}\n```\n\nNow decompose the task:";
 /**
  * Prompt template for spawned subtask agents.
  *
@@ -37,7 +37,7 @@ export declare const SUBTASK_PROMPT = "You are a swarm agent working on a subtas
  *
  * Supports {error_context} placeholder for retry prompts.
  */
-export declare const SUBTASK_PROMPT_V2 = "You are a swarm agent working on: **{subtask_title}**\n\n## [IDENTITY]\nAgent: (assigned at spawn)\nCell: {bead_id}\nEpic: {epic_id}\n\n## [TASK]\n{subtask_description}\n\n## [FILES]\nReserved (exclusive):\n{file_list}\n\nOnly modify these files. Need others? Message the coordinator.\n\n## [CONTEXT]\n{shared_context}\n\n{compressed_context}\n\n{error_context}\n\n## [MANDATORY SURVIVAL CHECKLIST]\n\n**CRITICAL: Follow this checklist IN ORDER. Each step builds on the previous.**\n\n### Step 1: Initialize Coordination (REQUIRED - DO THIS FIRST)\n```\nswarmmail_init(project_path=\"{project_path}\", task_description=\"{bead_id}: {subtask_title}\")\n```\n\n**This registers you with the coordination system and enables:**\n- File reservation tracking\n- Inter-agent communication\n- Progress monitoring\n- Conflict detection\n\n**If you skip this step, your work will not be tracked and swarm_complete will fail.**\n\n### Step 2: Query Past Learnings (BEFORE starting work)\n```\nsemantic-memory_find(query=\"<keywords from your task>\", limit=5)\n```\n\n**Check if past agents solved similar problems.** Search for:\n- Error messages if debugging\n- Domain concepts (e.g., \"authentication\", \"caching\")\n- Technology stack (e.g., \"Next.js\", \"React\")\n- Patterns (e.g., \"event sourcing\", \"validation\")\n\n**Past learnings save time and prevent repeating mistakes.**\n\n### Step 3: Load Relevant Skills (if available)\n```\nskills_list()  # See what skills exist\nskills_use(name=\"<relevant-skill>\", context=\"<your task>\")  # Load skill\n```\n\n**Common skill triggers:**\n- Writing tests? \u2192 `skills_use(name=\"testing-patterns\")`\n- Breaking dependencies? \u2192 `skills_use(name=\"testing-patterns\")`\n- Multi-agent coordination? \u2192 `skills_use(name=\"swarm-coordination\")`\n- Building a CLI? \u2192 `skills_use(name=\"cli-builder\")`\n\n### Step 4: Reserve Your Files (YOU reserve, not coordinator)\n```\nswarmmail_reserve(\n  paths=[{file_list}],\n  reason=\"{bead_id}: {subtask_title}\",\n  exclusive=true\n)\n```\n\n**Workers reserve their own files.** This prevents edit conflicts with other agents.\n\n### Step 5: Do the Work (TDD MANDATORY)\n\n**Follow RED \u2192 GREEN \u2192 REFACTOR. No exceptions.**\n\n1. **RED**: Write a failing test that describes the expected behavior\n   - Test MUST fail before you write implementation\n   - If test passes immediately, your test is wrong\n   \n2. **GREEN**: Write minimal code to make the test pass\n   - Don't over-engineer - just make it green\n   - Hardcode if needed, refactor later\n   \n3. **REFACTOR**: Clean up while tests stay green\n   - Run tests after every change\n   - If tests break, undo and try again\n\n```bash\n# Run tests continuously\nbun test <your-test-file> --watch\n```\n\n**Why TDD?**\n- Catches bugs before they exist\n- Documents expected behavior\n- Enables fearless refactoring\n- Proves your code works\n\n### Step 6: Report Progress at Milestones\n```\nswarm_progress(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  status=\"in_progress\",\n  progress_percent=25,  # or 50, 75\n  message=\"<what you just completed>\"\n)\n```\n\n**Report at 25%, 50%, 75% completion.** This:\n- Triggers auto-checkpoint (saves context)\n- Keeps coordinator informed\n- Prevents silent failures\n\n### Step 7: Manual Checkpoint BEFORE Risky Operations\n```\nswarm_checkpoint(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\"\n)\n```\n\n**Call BEFORE:**\n- Large refactors\n- File deletions\n- Breaking API changes\n- Anything that might fail catastrophically\n\n**Checkpoints preserve context so you can recover if things go wrong.**\n\n### Step 8: Store Learnings (if you discovered something)\n```\nsemantic-memory_store(\n  information=\"<what you learned, WHY it matters, how to apply it>\",\n  metadata=\"<tags: domain, tech-stack, pattern-type>\"\n)\n```\n\n**Store:**\n- Tricky bugs you solved (root cause + solution)\n- Project-specific patterns or domain rules\n- Tool/library gotchas and workarounds\n- Failed approaches (anti-patterns to avoid)\n\n**Don't store generic knowledge.** Store the WHY, not just the WHAT.\n\n### Step 9: Complete (REQUIRED - releases reservations)\n```\nswarm_complete(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  summary=\"<what you accomplished>\",\n  files_touched=[\"list\", \"of\", \"files\"]\n)\n```\n\n**This automatically:**\n- Runs UBS bug scan\n- Releases file reservations\n- Records learning signals\n- Notifies coordinator\n\n**DO NOT manually close the cell with hive_close.** Use swarm_complete.\n\n## [SWARM MAIL COMMUNICATION]\n\n### Check Inbox Regularly\n```\nswarmmail_inbox()  # Check for coordinator messages\nswarmmail_read_message(message_id=N)  # Read specific message\n```\n\n### When Blocked\n```\nswarmmail_send(\n  to=[\"coordinator\"],\n  subject=\"BLOCKED: {bead_id}\",\n  body=\"<blocker description, what you need>\",\n  importance=\"high\",\n  thread_id=\"{epic_id}\"\n)\nhive_update(id=\"{bead_id}\", status=\"blocked\")\n```\n\n### Report Issues to Other Agents\n```\nswarmmail_send(\n  to=[\"OtherAgent\", \"coordinator\"],\n  subject=\"Issue in {bead_id}\",\n  body=\"<describe problem, don't fix their code>\",\n  thread_id=\"{epic_id}\"\n)\n```\n\n### Manual Release (if needed)\n```\nswarmmail_release()  # Manually release reservations\n```\n\n**Note:** `swarm_complete` automatically releases reservations. Only use manual release if aborting work.\n\n## [OTHER TOOLS]\n### Hive - You Have Autonomy to File Issues\nYou can create new cells against this epic when you discover:\n- **Bugs**: Found a bug while working? File it.\n- **Tech debt**: Spotted something that needs cleanup? File it.\n- **Follow-up work**: Task needs more work than scoped? File a follow-up.\n- **Dependencies**: Need something from another agent? File and link it.\n\n```\nhive_create(\n  title=\"<descriptive title>\",\n  type=\"bug\",  # or \"task\", \"chore\"\n  priority=2,\n  parent_id=\"{epic_id}\",  # Links to this epic\n  description=\"Found while working on {bead_id}: <details>\"\n)\n```\n\n**Don't silently ignore issues.** File them so they get tracked and addressed.\n\nOther cell operations:\n- hive_update(id, status) - Mark blocked if stuck\n- hive_query(status=\"open\") - See what else needs work\n\n### Skills\n- skills_list() - Discover available skills\n- skills_use(name) - Activate skill for specialized guidance\n- skills_create(name) - Create new skill (if you found a reusable pattern)\n\n## [CRITICAL REQUIREMENTS]\n\n**NON-NEGOTIABLE:**\n1. Step 1 (swarmmail_init) MUST be first - do it before anything else\n2. Step 2 (semantic-memory_find) MUST happen before starting work\n3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator\n4. Step 6 (swarm_progress) - Report at milestones, don't work silently\n5. Step 9 (swarm_complete) - Use this to close, NOT hive_close\n\n**If you skip these steps:**\n- Your work won't be tracked (swarm_complete will fail)\n- You'll waste time repeating solved problems (no semantic memory query)\n- Edit conflicts with other agents (no file reservation)\n- Lost work if you crash (no checkpoints)\n- Future agents repeat your mistakes (no learnings stored)\n\nBegin now.";
+export declare const SUBTASK_PROMPT_V2 = "You are a swarm agent working on: **{subtask_title}**\n\n## [IDENTITY]\nAgent: (assigned at spawn)\nCell: {bead_id}\nEpic: {epic_id}\n\n## [TASK]\n{subtask_description}\n\n## [FILES]\nReserved (exclusive):\n{file_list}\n\nOnly modify these files. Need others? Message the coordinator.\n\n## [CONTEXT]\n{shared_context}\n\n{compressed_context}\n\n{error_context}\n\n## [MANDATORY SURVIVAL CHECKLIST]\n\n**CRITICAL: Follow this checklist IN ORDER. Each step builds on the previous.**\n\n### Step 1: Initialize Coordination (REQUIRED - DO THIS FIRST)\n```\nswarmmail_init(project_path=\"{project_path}\", task_description=\"{bead_id}: {subtask_title}\")\n```\n\n**This registers you with the coordination system and enables:**\n- File reservation tracking\n- Inter-agent communication\n- Progress monitoring\n- Conflict detection\n\n**If you skip this step, your work will not be tracked and swarm_complete will fail.**\n\n### Step 2: \uD83E\uDDE0 Query Past Learnings (MANDATORY - BEFORE starting work)\n\n**\u26A0\uFE0F CRITICAL: ALWAYS query semantic memory BEFORE writing ANY code.**\n\n```\nsemantic-memory_find(query=\"<keywords from your task>\", limit=5, expand=true)\n```\n\n**Why this is MANDATORY:**\n- Past agents may have already solved your exact problem\n- Avoids repeating mistakes that wasted 30+ minutes before\n- Discovers project-specific patterns and gotchas\n- Finds known workarounds for tool/library quirks\n\n**Search Query Examples by Task Type:**\n\n- **Bug fix**: Use exact error message or \"<symptom> <component>\"\n- **New feature**: Search \"<domain concept> implementation pattern\"\n- **Refactor**: Query \"<pattern name> migration approach\"\n- **Integration**: Look for \"<library name> gotchas configuration\"\n- **Testing**: Find \"testing <component type> characterization tests\"\n- **Performance**: Search \"<technology> performance optimization\"\n\n**BEFORE you start coding:**\n1. Run semantic-memory_find with keywords from your task\n2. Read the results with expand=true for full content\n3. Check if any memory solves your problem or warns of pitfalls\n4. Adjust your approach based on past learnings\n\n**If you skip this step, you WILL waste time solving already-solved problems.**\n\n### Step 3: Load Relevant Skills (if available)\n```\nskills_list()  # See what skills exist\nskills_use(name=\"<relevant-skill>\", context=\"<your task>\")  # Load skill\n```\n\n**Common skill triggers:**\n- Writing tests? \u2192 `skills_use(name=\"testing-patterns\")`\n- Breaking dependencies? \u2192 `skills_use(name=\"testing-patterns\")`\n- Multi-agent coordination? \u2192 `skills_use(name=\"swarm-coordination\")`\n- Building a CLI? \u2192 `skills_use(name=\"cli-builder\")`\n\n### Step 4: Reserve Your Files (YOU reserve, not coordinator)\n```\nswarmmail_reserve(\n  paths=[{file_list}],\n  reason=\"{bead_id}: {subtask_title}\",\n  exclusive=true\n)\n```\n\n**Workers reserve their own files.** This prevents edit conflicts with other agents.\n\n### Step 5: Do the Work (TDD MANDATORY)\n\n**Follow RED \u2192 GREEN \u2192 REFACTOR. No exceptions.**\n\n1. **RED**: Write a failing test that describes the expected behavior\n   - Test MUST fail before you write implementation\n   - If test passes immediately, your test is wrong\n   \n2. **GREEN**: Write minimal code to make the test pass\n   - Don't over-engineer - just make it green\n   - Hardcode if needed, refactor later\n   \n3. **REFACTOR**: Clean up while tests stay green\n   - Run tests after every change\n   - If tests break, undo and try again\n\n```bash\n# Run tests continuously\nbun test <your-test-file> --watch\n```\n\n**Why TDD?**\n- Catches bugs before they exist\n- Documents expected behavior\n- Enables fearless refactoring\n- Proves your code works\n\n### Step 6: Report Progress at Milestones\n```\nswarm_progress(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  status=\"in_progress\",\n  progress_percent=25,  # or 50, 75\n  message=\"<what you just completed>\"\n)\n```\n\n**Report at 25%, 50%, 75% completion.** This:\n- Triggers auto-checkpoint (saves context)\n- Keeps coordinator informed\n- Prevents silent failures\n\n### Step 7: Manual Checkpoint BEFORE Risky Operations\n```\nswarm_checkpoint(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\"\n)\n```\n\n**Call BEFORE:**\n- Large refactors\n- File deletions\n- Breaking API changes\n- Anything that might fail catastrophically\n\n**Checkpoints preserve context so you can recover if things go wrong.**\n\n### Step 8: \uD83D\uDCBE STORE YOUR LEARNINGS (if you discovered something)\n\n**If you learned it the hard way, STORE IT so the next agent doesn't have to.**\n\n```\nsemantic-memory_store(\n  information=\"<what you learned, WHY it matters, how to apply it>\",\n  tags=\"<domain, tech-stack, pattern-type>\"\n)\n```\n\n**MANDATORY Storage Triggers - Store when you:**\n- \uD83D\uDC1B **Solved a tricky bug** (>15min debugging) - include root cause + solution\n- \uD83D\uDCA1 **Discovered a project-specific pattern** - domain rules, business logic quirks\n- \u26A0\uFE0F **Found a tool/library gotcha** - API quirks, version-specific bugs, workarounds\n- \uD83D\uDEAB **Tried an approach that failed** - anti-patterns to avoid, why it didn't work\n- \uD83C\uDFD7\uFE0F **Made an architectural decision** - reasoning, alternatives considered, tradeoffs\n\n**What Makes a GOOD Memory:**\n\n\u2705 **GOOD** (actionable, explains WHY):\n```\n\"OAuth refresh tokens need 5min buffer before expiry to avoid race conditions.\nWithout buffer, token refresh can fail mid-request if expiry happens between\ncheck and use. Implemented with: if (expiresAt - Date.now() < 300000) refresh()\"\n```\n\n\u274C **BAD** (generic, no context):\n```\n\"Fixed the auth bug by adding a null check\"\n```\n\n**What NOT to Store:**\n- Generic knowledge that's in official documentation\n- Implementation details that change frequently\n- Vague descriptions without context (\"fixed the thing\")\n\n**The WHY matters more than the WHAT.** Future agents need context to apply your learning.\n\n### Step 9: Complete (REQUIRED - releases reservations)\n```\nswarm_complete(\n  project_key=\"{project_path}\",\n  agent_name=\"<your-agent-name>\",\n  bead_id=\"{bead_id}\",\n  summary=\"<what you accomplished>\",\n  files_touched=[\"list\", \"of\", \"files\"]\n)\n```\n\n**This automatically:**\n- Runs UBS bug scan\n- Releases file reservations\n- Records learning signals\n- Notifies coordinator\n\n**DO NOT manually close the cell with hive_close.** Use swarm_complete.\n\n## [SWARM MAIL COMMUNICATION]\n\n### Check Inbox Regularly\n```\nswarmmail_inbox()  # Check for coordinator messages\nswarmmail_read_message(message_id=N)  # Read specific message\n```\n\n### When Blocked\n```\nswarmmail_send(\n  to=[\"coordinator\"],\n  subject=\"BLOCKED: {bead_id}\",\n  body=\"<blocker description, what you need>\",\n  importance=\"high\",\n  thread_id=\"{epic_id}\"\n)\nhive_update(id=\"{bead_id}\", status=\"blocked\")\n```\n\n### Report Issues to Other Agents\n```\nswarmmail_send(\n  to=[\"OtherAgent\", \"coordinator\"],\n  subject=\"Issue in {bead_id}\",\n  body=\"<describe problem, don't fix their code>\",\n  thread_id=\"{epic_id}\"\n)\n```\n\n### Manual Release (if needed)\n```\nswarmmail_release()  # Manually release reservations\n```\n\n**Note:** `swarm_complete` automatically releases reservations. Only use manual release if aborting work.\n\n## [OTHER TOOLS]\n### Hive - You Have Autonomy to File Issues\nYou can create new cells against this epic when you discover:\n- **Bugs**: Found a bug while working? File it.\n- **Tech debt**: Spotted something that needs cleanup? File it.\n- **Follow-up work**: Task needs more work than scoped? File a follow-up.\n- **Dependencies**: Need something from another agent? File and link it.\n\n```\nhive_create(\n  title=\"<descriptive title>\",\n  type=\"bug\",  # or \"task\", \"chore\"\n  priority=2,\n  parent_id=\"{epic_id}\",  # Links to this epic\n  description=\"Found while working on {bead_id}: <details>\"\n)\n```\n\n**Don't silently ignore issues.** File them so they get tracked and addressed.\n\nOther cell operations:\n- hive_update(id, status) - Mark blocked if stuck\n- hive_query(status=\"open\") - See what else needs work\n\n### Skills\n- skills_list() - Discover available skills\n- skills_use(name) - Activate skill for specialized guidance\n- skills_create(name) - Create new skill (if you found a reusable pattern)\n\n## [CRITICAL REQUIREMENTS]\n\n**NON-NEGOTIABLE:**\n1. Step 1 (swarmmail_init) MUST be first - do it before anything else\n2. \uD83E\uDDE0 Step 2 (semantic-memory_find) MUST happen BEFORE starting work - query first, code second\n3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator\n4. Step 6 (swarm_progress) - Report at milestones, don't work silently\n5. \uD83D\uDCBE Step 8 (semantic-memory_store) - If you learned something hard, STORE IT\n6. Step 9 (swarm_complete) - Use this to close, NOT hive_close\n\n**If you skip these steps:**\n- Your work won't be tracked (swarm_complete will fail)\n- \uD83D\uDD04 You'll waste time repeating already-solved problems (no semantic memory query)\n- Edit conflicts with other agents (no file reservation)\n- Lost work if you crash (no checkpoints)\n- \uD83D\uDD04 Future agents repeat YOUR mistakes (no learnings stored)\n\n**Memory is the swarm's collective intelligence. Query it. Feed it.**\n\nBegin now.";
 /**
  * Prompt for self-evaluation before completing a subtask.
  *
@@ -130,6 +130,7 @@ export declare const swarm_spawn_subtask: {
             skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
             coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
     };
     execute(args: {
         bead_id: string;
@@ -144,6 +145,7 @@ export declare const swarm_spawn_subtask: {
             skills_to_load?: string[] | undefined;
             coordinator_notes?: string | undefined;
         } | undefined;
+        model?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 /**
@@ -178,7 +180,7 @@ export declare const swarm_plan_prompt: {
             "risk-based": "risk-based";
             auto: "auto";
         }>>;
-        max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+        max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
         context: import("zod").ZodOptional<import("zod").ZodString>;
         query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
         cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -186,8 +188,8 @@ export declare const swarm_plan_prompt: {
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
         strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+        max_subtasks?: number | undefined;
         context?: string | undefined;
         query_cass?: boolean | undefined;
         cass_limit?: number | undefined;
@@ -233,6 +235,7 @@ export declare const promptTools: {
                 skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                 coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>>;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
         };
         execute(args: {
             bead_id: string;
@@ -247,6 +250,7 @@ export declare const promptTools: {
                 skills_to_load?: string[] | undefined;
                 coordinator_notes?: string | undefined;
             } | undefined;
+            model?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_evaluation_prompt: {
@@ -272,7 +276,7 @@ export declare const promptTools: {
                 "risk-based": "risk-based";
                 auto: "auto";
             }>>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -280,8 +284,8 @@ export declare const promptTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;

package/dist/swarm-prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,m6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,gxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,ksOA8PnB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0D9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CA0I5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
+{"version":3,"file":"swarm-prompts.d.ts","sourceRoot":"","sources":["../src/swarm-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,s6EAkET,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,6BAA6B,mxDAyDlB,CAAC;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mkFAgFK,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,mzSA0SnB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8jCAmCU,CAAC;AAMzC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,GAAG,MAAM,CA2ET;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,MAAM,CAUT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,MAAM,CAMT;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAoC/B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAoClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CAwI5B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/swarm.d.ts

@@ -344,6 +344,7 @@ export declare const swarmTools: {
                 skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                 coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>>;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
         };
         execute(args: {
             bead_id: string;
@@ -358,6 +359,7 @@ export declare const swarmTools: {
                 skills_to_load?: string[] | undefined;
                 coordinator_notes?: string | undefined;
             } | undefined;
+            model?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_evaluation_prompt: {
@@ -383,7 +385,7 @@ export declare const swarmTools: {
                 "risk-based": "risk-based";
                 auto: "auto";
             }>>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -391,8 +393,8 @@ export declare const swarmTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -403,14 +405,14 @@ export declare const swarmTools: {
         description: string;
         args: {
             task: import("zod").ZodString;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             context: import("zod").ZodOptional<import("zod").ZodString>;
             query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -430,7 +432,7 @@ export declare const swarmTools: {
         args: {
             task: import("zod").ZodString;
             context: import("zod").ZodOptional<import("zod").ZodString>;
-            max_subtasks: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+            max_subtasks: import("zod").ZodOptional<import("zod").ZodNumber>;
             strategy: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
                 "file-based": "file-based";
                 "feature-based": "feature-based";
@@ -441,10 +443,10 @@ export declare const swarmTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy: "file-based" | "feature-based" | "risk-based" | "auto";
             query_cass: boolean;
             context?: string | undefined;
+            max_subtasks?: number | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_plan_interactive: {

package/dist/swarm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAQpC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}
+{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAQpC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.30.6",
+  "version": "0.31.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
     "minimatch": "^10.1.1",
-    "swarm-mail": "0.5.0",
+    "swarm-mail": "1.1.0",
     "zod": "4.1.8"
   },
   "devDependencies": {

package/src/hive.integration.test.ts

@@ -406,7 +406,7 @@ describe("beads integration", () => {
   });
 
   describe("hive_create_epic", () => {
-    it("creates an epic with subtasks", async () => {
+    it("creates an epic with subtasks and syncs to JSONL", async () => {
       const result = await hive_create_epic.execute(
         {
           epic_title: "Integration test epic",
@@ -438,6 +438,28 @@ describe("beads integration", () => {
         expect(subtaskBead).toBeDefined();
         expect(subtaskBead!.parent_id).toBe(epicResult.epic.id);
       }
+      
+      // NEW TEST: Verify cells are synced to JSONL immediately
+      const { readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const jsonlPath = join(TEST_PROJECT_KEY, ".hive", "issues.jsonl");
+      
+      expect(existsSync(jsonlPath)).toBe(true);
+      
+      const jsonlContent = readFileSync(jsonlPath, "utf-8");
+      const lines = jsonlContent.trim().split("\n").filter(l => l);
+      const cells = lines.map(line => JSON.parse(line));
+      
+      // Epic and all subtasks should be in JSONL
+      const epicInJsonl = cells.find(c => c.id === epicResult.epic.id);
+      expect(epicInJsonl).toBeDefined();
+      expect(epicInJsonl!.title).toBe("Integration test epic");
+      
+      for (const subtask of epicResult.subtasks) {
+        const subtaskInJsonl = cells.find(c => c.id === subtask.id);
+        expect(subtaskInJsonl).toBeDefined();
+        expect(subtaskInJsonl!.parent_id).toBe(epicResult.epic.id);
+      }
     });
 
     it("creates an epic with files metadata in subtasks", async () => {
@@ -601,6 +623,181 @@ describe("beads integration", () => {
     });
   });
 
+  describe("partial ID resolution", () => {
+    let fullId: string;
+    let hash: string;
+
+    beforeEach(async () => {
+      // Create a test cell to resolve
+      const result = await hive_create.execute(
+        { title: "Partial ID test cell" },
+        mockContext,
+      );
+      const cell = parseResponse<Cell>(result);
+      fullId = cell.id;
+      createdBeadIds.push(fullId);
+
+      // Extract hash from ID (format: {prefix}-{hash}-{timestamp}{random})
+      // The last segment is always timestamp+random (11 chars)
+      // The hash is the 6-char segment before that
+      // Examples:
+      //   "opencode-swarm-monorepo-lf2p4u-mjd2h5v4wdt" -> hash is "lf2p4u"
+      //   "cell--gcel4-mjd2h5v4wdt" -> hash is "-gcel4" (negative hash creates consecutive hyphens)
+      
+      // Find the last hyphen, then work backwards to find the second-to-last hyphen
+      const lastHyphenIndex = fullId.lastIndexOf("-");
+      if (lastHyphenIndex === -1) {
+        hash = "";
+      } else {
+        // Get everything before the last hyphen
+        const beforeLast = fullId.substring(0, lastHyphenIndex);
+        // Find the second-to-last hyphen
+        const secondLastHyphenIndex = beforeLast.lastIndexOf("-");
+        if (secondLastHyphenIndex === -1) {
+          hash = "";
+        } else {
+          // Hash is between second-to-last and last hyphen
+          hash = fullId.substring(secondLastHyphenIndex + 1, lastHyphenIndex);
+        }
+      }
+    });
+
+    describe("hive_update", () => {
+      it("accepts full cell ID (no resolution needed)", async () => {
+        const result = await hive_update.execute(
+          { id: fullId, description: "Updated via full ID" },
+          mockContext,
+        );
+
+        const updated = parseResponse<Cell>(result);
+        expect(updated.id).toBe(fullId);
+        expect(updated.description).toContain("Updated via full ID");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_update.execute(
+            { id: hash, priority: 1 },
+            mockContext,
+          );
+
+          const updated = parseResponse<Cell>(result);
+          expect(updated.id).toBe(fullId);
+          expect(updated.priority).toBe(1);
+        } catch (error) {
+          // In test environment with many cells, hash may be ambiguous
+          // Verify we get a helpful error message
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error; // Re-throw if not ambiguity error
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_update.execute({ id: "zzzzzz", status: "closed" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|zzzzzz/i);
+      });
+
+      it("throws helpful error for ambiguous hash", async () => {
+        // Create another cell with potentially similar hash
+        // (in practice, hashes are unique, but we simulate ambiguity by using a short partial)
+        // This test verifies the error message is helpful
+        try {
+          // Use a single char which might match multiple cells in larger datasets
+          await hive_update.execute({ id: "a", status: "closed" }, mockContext);
+          // If it succeeds, it means only one cell matched - that's fine
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          // Error should mention ambiguity if multiple matches
+          if (message.includes("ambiguous") || message.includes("multiple")) {
+            expect(message).toMatch(/ambiguous|multiple/i);
+          }
+        }
+      });
+    });
+
+    describe("hive_close", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_close.execute(
+          { id: fullId, reason: "Closed via full ID" },
+          mockContext,
+        );
+
+        expect(result).toContain("Closed");
+        expect(result).toContain(fullId);
+
+        const closed = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(closed?.status).toBe("closed");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_close.execute(
+            { id: hash, reason: "Close via hash" },
+            mockContext,
+          );
+
+          expect(result).toContain("Closed");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_close.execute({ id: "nonono", reason: "Test" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nonono/i);
+      });
+    });
+
+    describe("hive_start", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_start.execute({ id: fullId }, mockContext);
+
+        expect(result).toContain("Started");
+        expect(result).toContain(fullId);
+
+        const started = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(started?.status).toBe("in_progress");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_start.execute(
+            { id: hash },
+            mockContext,
+          );
+
+          expect(result).toContain("Started");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_start.execute({ id: "nope99" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nope99/i);
+      });
+    });
+  });
+
   describe("workflow integration", () => {
     it("complete bead lifecycle: create -> start -> update -> close", async () => {
       // 1. Create
@@ -1225,8 +1422,8 @@ describe("beads integration", () => {
           mockContext,
         );
 
-        // Should return "No cells to sync" since no dirty cells
-        expect(result).toContain("No cells to sync");
+        // Should return "No cells or memories to sync" since no dirty cells
+        expect(result).toContain("No cells or memories to sync");
       } finally {
         setHiveWorkingDirectory(originalDir);
         rmSync(tempProject, { recursive: true, force: true });
@@ -1450,4 +1647,136 @@ describe("beads integration", () => {
       rmSync(tempProject, { recursive: true, force: true });
     });
   });
+
+  describe("process exit hook", () => {
+    it("registers beforeExit hook that syncs dirty cells", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      // Initialize git repo
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Initial commit with empty issues.jsonl
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial"', { cwd: tempProject });
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell (marks it dirty but don't sync)
+        await hive_create.execute(
+          { title: "Exit hook test cell", type: "task" },
+          mockContext,
+        );
+
+        // Verify cell is NOT in JSONL yet (only in PGLite)
+        const beforeContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(beforeContent.trim()).toBe("");
+
+        // Simulate process exit by triggering beforeExit event
+        process.emit("beforeExit", 0);
+
+        // Wait for async flush to complete
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Verify cell was synced to JSONL by the exit hook
+        const afterContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(afterContent.trim()).not.toBe("");
+
+        const cells = afterContent.trim().split("\n").map(line => JSON.parse(line));
+        expect(cells).toHaveLength(1);
+        expect(cells[0].title).toBe("Exit hook test cell");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook is idempotent - safe to call multiple times", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell
+        await hive_create.execute(
+          { title: "Idempotent test cell", type: "task" },
+          mockContext,
+        );
+
+        // Trigger exit hook multiple times
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+        
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // Verify cell is written only once (no duplication)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        const lines = content.trim().split("\n").filter(l => l);
+        
+        // Should have exactly one cell (even though we triggered hook twice)
+        expect(lines.length).toBeGreaterThanOrEqual(1);
+        
+        // All cells should have unique IDs
+        const cells = lines.map(line => JSON.parse(line));
+        const uniqueIds = new Set(cells.map(c => c.id));
+        expect(uniqueIds.size).toBe(cells.length);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook handles case with no dirty cells gracefully", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with empty JSONL
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Trigger exit hook with no dirty cells (should not throw)
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // JSONL should still be empty (no error thrown)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(content.trim()).toBe("");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
 });