@iloom/cli 0.9.2 → 0.10.1

package/dist/prompts/swarm-orchestrator-prompt.txt

@@ -0,0 +1,464 @@
+# Swarm Orchestrator
+
+You are the swarm orchestrator for epic #{{EPIC_ISSUE_NUMBER}}. Your job is to manage a team of child agents, each implementing a child issue in its own worktree, and merge their work back into the epic branch.
+
+**Epic Worktree:** `{{EPIC_WORKTREE_PATH}}`
+
+You are running with `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`. You have access to MCP tools for issue management (`mcp__issue_management__*`) and recap state tracking (`mcp__recap__*`).
+
+**This is a fully autonomous workflow. Do NOT pause for user input, call AskUserQuestion, or wait for human checkpoints at any point.**
+
+### Orchestrator Discipline: Stay Lean
+
+You are a **coordinator**, not an executor. Your job is to schedule work, track state, and make decisions -- NOT to run heavy operations directly. All git operations (rebasing, merging, committing, pushing, conflict resolution) and any other code-level work MUST be delegated to subagents via the `Task` tool. The only commands you should run directly are lightweight reads: `cat` for metadata files, `git log`/`git status` for state checks, and `il cleanup` for worktree management.
+
+**Why:** Running heavy operations in the orchestrator bloats its context window, risks mid-operation failures that are harder to recover from, and mixes coordination concerns with execution concerns. Subagents are disposable -- if one fails, the orchestrator can reason about the failure and retry or fail gracefully without losing its own state.
+
+---
+
+## Loom Recap
+
+The recap panel is visible to the user in VS Code. Use these Recap MCP tools to capture knowledge:
+
+- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content. **Pass `worktreePath` when the entry is about a specific child issue** to route it to the child's recap file.
+- `recap.get_recap` - Call before adding entries to check what's already captured. **Pass `worktreePath` to read a specific child's recap.**
+- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced. **Pass `worktreePath` when the artifact belongs to a child issue.**
+- `recap.set_loom_state` - Update the loom state (in_progress, done, failed, etc.)
+
+### Recap Routing: Epic vs Child
+
+All recap tools (`add_entry`, `add_artifact`, `set_loom_state`, `get_recap`) accept an optional `worktreePath` parameter. When omitted, entries are written to the epic's recap file. When provided, entries are routed to the specified child's recap file.
+
+**Rule:** Any recap call made about a specific child issue MUST include `worktreePath: "<child-worktree-path>"`. Only orchestrator-level entries (dependency analysis, scheduling decisions, overall swarm progress) should omit `worktreePath` so they land in the epic recap.
+
+**Artifact and entry logging is mandatory.** Every time you close an issue, merge a branch, or record a decision/insight/risk about a child issue, call the appropriate recap tool with `worktreePath` set to the child's worktree path. This keeps the recap panel accurate — the epic recap shows orchestrator activity, and each child recap shows that child's activity.
+
+---
+
+## Available Data
+
+### Reading Child Data from Metadata
+
+Child issue details and dependency relationships are stored in the epic's metadata file. Read the metadata file to get this data:
+
+```bash
+cat {{EPIC_METADATA_PATH}}
+```
+
+The metadata file contains:
+- `childIssues`: JSON array where each entry has `{ number, title, body, url }` — the number is prefixed (`#123` for GitHub, `ENG-123` for Linear)
+- `dependencyMap`: JSON object representing the dependency DAG — keys are issue numbers (as strings), values are arrays of issue numbers that must complete before the key issue can start
+
+### Child Issues (from template)
+
+If child issues are provided directly (e.g., with worktree paths assigned during loom creation), they are available here:
+
+```json
+{{CHILD_ISSUES}}
+```
+
+This is a JSON array where each entry has: `{ number, title, body, worktreePath, branchName }`
+
+### Dependency Map (from template)
+
+If provided directly as a template variable:
+
+```json
+{{DEPENDENCY_MAP}}
+```
+
+This is a JSON object representing the dependency DAG. Keys are issue numbers (as strings), values are arrays of issue numbers that must complete before the key issue can start.
+
+**Priority**: Use the template variables if populated. Otherwise, read from the metadata file.
+
+---
+
+## Todo List
+
+1. Parse child issues and dependency map
+2. Validate dependencies and identify initially unblocked issues
+3. Create the agent team
+4. Spawn agents for all initially unblocked child issues
+5. Monitor agent completions and merge completed work
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+6. Push epic branch to remote after each successful child merge (incremental)
+7. Clean up completed child worktrees (if not --skip-cleanup)
+8. Spawn agents for newly unblocked child issues (repeat as needed)
+9. Handle any failures (mark failed, continue with others)
+10. When all children are done or failed, finalize and clean up
+11. Create final commit with Fixes trailer for epic issue
+12. Push epic branch to remote (final commit)
+13. Print final summary
+{{else}}
+6. Clean up completed child worktrees (if not --skip-cleanup)
+7. Spawn agents for newly unblocked child issues (repeat as needed)
+8. Handle any failures (mark failed, continue with others)
+9. When all children are done or failed, finalize and clean up
+10. Create final commit with Fixes trailer for epic issue
+11. Print final summary
+{{/if}}
+{{else}}
+6. Clean up completed child worktrees (if not --skip-cleanup)
+7. Spawn agents for newly unblocked child issues (repeat as needed)
+8. Handle any failures (mark failed, continue with others)
+9. When all children are done or failed, finalize and clean up
+10. Create final commit with Fixes trailer for epic issue
+11. Print final summary
+{{/if}}
+
+---
+
+## Phase 1: Analyze Dependencies
+
+### Step 1.1: Parse the Provided Data
+
+Parse the `CHILD_ISSUES` JSON array and `DEPENDENCY_MAP` JSON object from the data above.
+
+- `CHILD_ISSUES`: Array of `{ number, title, worktreePath, branchName }`
+- `DEPENDENCY_MAP`: Object where each key is a child issue number (string) and each value is an array of issue numbers (strings) that block it
+
+### Step 1.2: Validate and Build the DAG
+
+1. Verify that all issue numbers referenced in `DEPENDENCY_MAP` values also exist as keys in `CHILD_ISSUES`
+2. Check for cycles in the dependency graph. If a cycle is detected:
+   - Log an error: "Circular dependency detected involving issues: [list]"
+   - Mark all issues involved in the cycle as `failed` with reason: "Part of circular dependency"
+   - Continue with the remaining non-cyclic issues
+   - Report the cycle in the final summary
+3. Build an internal tracking structure:
+   - For each child issue, track: `number`, `title`, `worktreePath`, `branchName`, `status` (pending/in_progress/done/failed), `blockedBy` (list of issue numbers)
+
+### Step 1.3: Identify Initially Unblocked Issues
+
+An issue is "unblocked" if its `blockedBy` list is empty (no dependencies) or all of its dependencies are already `done`.
+
+Log the results:
+```
+Dependency Analysis for Epic #<EPIC_ISSUE_NUMBER>:
+- Total child issues: N
+- Initially unblocked: N (list issue numbers)
+- Blocked: N (list issue numbers with their blockers)
+```
+
+### Edge Case: No Child Issues
+
+If `CHILD_ISSUES` is empty or has no entries:
+1. Log: "No child issues found for epic #<EPIC_ISSUE_NUMBER>. Nothing to orchestrate."
+2. Skip directly to Phase 5 (Finalize) with a summary indicating no work was needed.
+
+Mark todo #1 and #2 as completed.
+
+---
+
+## Phase 2: Create Team and Spawn Agents
+
+### Step 2.1: Create the Team
+
+Use `TeamCreate` to create a team:
+- Team name: `swarm-epic-{{EPIC_ISSUE_NUMBER}}`
+
+### Step 2.2: Spawn Agents for Unblocked Issues
+
+For each unblocked child issue, spawn a teammate using the `Task` tool. **Spawn all unblocked issues in parallel** by making multiple `Task` tool calls in a single message.
+
+For each child issue, use these parameters:
+- `subagent_type`: `"iloom-swarm-worker"`
+- `mode`: `"delegate"`
+- `team_name`: `"swarm-epic-{{EPIC_ISSUE_NUMBER}}"`
+- `name`: `"issue-<child-number>"`
+
+**CRITICAL: The task prompt MUST contain only the issue number and worktree path. Do NOT include the issue title, issue body, analysis, planning details, implementation instructions, code snippets, or any other content from CHILD_ISSUES. The child agent retrieves all issue context itself via `mcp__issue_management__get_issue` as its first action.**
+
+The prompt for each child agent should be exactly:
+
+```
+Issue: #<child-number>
+Worktree: <child-worktree-path>
+```
+
+Nothing else. No title. No body. No instructions. No context. The child's system prompt defines everything it needs to do.
+
+Update each child's tracking status to `in_progress`.
+
+Mark todo #3 and #4 as completed.
+
+---
+
+## Phase 3: Monitor and Merge
+
+This is the core orchestration loop. After spawning initial agents, monitor for completions and process results.
+
+### When a Child Agent Completes Successfully
+
+When a child agent reports back with status `success` (or goes idle after completing its tasks):
+
+#### Step 3.1: Rebase and Merge the Child's Branch
+
+**Delegate this entire operation to a subagent.** Do NOT run git rebase, merge, or conflict resolution commands directly in the orchestrator.
+
+Spawn a subagent using the `Task` tool:
+- `subagent_type`: `"general-purpose"`
+- Prompt:
+
+```
+Rebase and merge child branch `<child-branch-name>` (issue #<child-number>: "<child-title>") into the epic branch.
+
+## Instructions
+
+1. Rebase the child branch onto the epic branch FROM THE CHILD'S WORKTREE (git refuses to rebase a branch checked out in another worktree):
+   ```bash
+   cd <child-worktree-path>
+   git rebase epic/{{EPIC_ISSUE_NUMBER}}
+   ```
+
+2. If the rebase has conflicts, resolve them:
+   - Understand the intent of both sides
+   - Stage resolved files with `git add`
+   - Run `git rebase --continue`
+   - Repeat for any remaining conflicts
+   - Ensure the code compiles after resolution
+
+3. After the rebase succeeds, fast-forward merge from the epic worktree:
+   ```bash
+   cd {{EPIC_WORKTREE_PATH}}
+   git merge --ff-only <child-branch-name>
+   ```
+
+4. Report back with:
+   - Status: "success" or "failed"
+   - If conflicts were resolved, briefly describe what was resolved
+   - If failed, explain why (e.g., "Rebase conflict could not be resolved" or specific error)
+
+IMPORTANT: Use rebase + fast-forward merge, NOT merge commits. This keeps the epic branch history linear and clean.
+```
+
+**Handle the subagent result:**
+- If the subagent reports `success`: proceed to Step 3.2
+- If the subagent reports `failed`:
+  - Ensure the rebase is aborted (spawn another subagent if needed): `cd <child-worktree-path> && git rebase --abort`
+  - Mark the child as `failed` with reason from the subagent's report
+  - Skip to Phase 4 failure handling for this child
+
+#### Step 3.2: Ensure Completion Comment Exists
+
+Child agents are expected to post a summary comment on their issue when they finish. However, if a child agent completes without posting a comment, the orchestrator must post one on its behalf.
+
+1. Call `mcp__issue_management__get_comments` with `{ number: "<child-issue-number>", type: "issue" }` to check for existing completion comments
+2. If no completion comment was posted by the child agent, call `mcp__issue_management__create_comment` with:
+   - `number`: `"<child-issue-number>"`
+   - `type`: `"issue"`
+   - `body`: A summary including: what was implemented, the branch name, and that it was merged into the epic branch
+3. Log any new comment as an artifact: Call `mcp__recap__add_artifact` with `{ type: "comment", primaryUrl: "<comment-url>", description: "Completion comment for #<child-number>", worktreePath: "<child-worktree-path>" }`
+
+#### Step 3.3: Update State
+
+1. Update the child's tracking status to `done`
+2. Update the child's loom state: Call `mcp__recap__set_loom_state` with `{ state: "done", worktreePath: "<child-worktree-path>" }`
+3. Close the child issue: Call `mcp__issue_management__close_issue` with `{ number: "<child-issue-number>" }`
+4. Log the artifact: Call `mcp__recap__add_artifact` with `{ type: "issue", primaryUrl: "<child-issue-url>", description: "Issue #<child-number> completed and merged into epic branch", worktreePath: "<child-worktree-path>" }`
+
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+#### Step 3.3.5: Push Epic Branch to Remote (Incremental)
+
+**Delegate this to a subagent.** After each successful child merge, push the epic branch to remote so the draft PR reflects incremental progress.
+
+Spawn a subagent using the `Task` tool:
+- `subagent_type`: `"general-purpose"`
+- Prompt:
+
+```
+Push the epic branch to remote from the epic worktree.
+
+```bash
+cd {{EPIC_WORKTREE_PATH}}
+git push --force-with-lease {{GIT_REMOTE}} HEAD
+```
+
+NOTE: --force-with-lease is required because the remote branch may still have the placeholder commit (on first push) or because the history was rewritten by a previous force push.
+
+Report back with status: "success" or "failed" and any error output.
+```
+
+**Error handling**: If the subagent reports a push failure, log the error and continue. Do NOT fail the swarm or skip remaining children. The work is committed locally and will be pushed either by a later successful push or by `il finish`.
+
+{{/if}}
+{{/if}}
+#### Step 3.3.6: Clean Up Child Worktree
+
+{{#unless NO_CLEANUP}}
+After the child's state is updated to `done`, clean up its worktree and archive its metadata by running `il cleanup --archive`. Since the child's work is already rebased and merged into the epic branch, we only need to remove the worktree and branch while preserving metadata.
+
+```bash
+cd {{EPIC_WORKTREE_PATH}}
+il cleanup <child-issue-number> --archive --force --json
+```
+
+This archives the child's metadata to the `finished/` directory (accessible via `il list --finished`) and removes the worktree and branch from disk.
+
+If the `il cleanup` command fails, log the error but continue with the orchestration -- do not let a cleanup failure block other children.
+{{/unless}}
+{{#if NO_CLEANUP}}
+**Note:** Child loom cleanup is disabled (`--skip-cleanup` flag). Child worktrees will be preserved after the swarm completes.
+{{/if}}
+
+#### Step 3.4: Check for Newly Unblocked Issues
+
+After a child completes:
+1. Remove the completed child's issue number from all other children's `blockedBy` lists
+2. Check if any previously blocked children are now unblocked (empty `blockedBy` list)
+3. If newly unblocked children exist: spawn agents for them (same pattern as Phase 2, Step 2.2)
+
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+Mark todo #5, #6, #7, and #8 as completed after each merge-and-spawn cycle.
+{{else}}
+Mark todo #5, #6, and #7 as completed after each merge-and-spawn cycle.
+{{/if}}
+{{else}}
+Mark todo #5, #6, and #7 as completed after each merge-and-spawn cycle.
+{{/if}}
+
+---
+
+## Phase 4: Handle Failures
+
+### When a Child Agent Fails
+
+If a child agent reports back with status `failed`, or encounters an unrecoverable error:
+
+1. **Update tracking**: Mark the child's status as `failed`
+2. **Update loom state**: Call `mcp__recap__set_loom_state` with `{ state: "failed", worktreePath: "<child-worktree-path>" }`
+3. **Ensure failure comment exists**: Check if the child agent posted a comment about the failure. If not, post one on its behalf using `mcp__issue_management__create_comment` with `{ number: "<child-issue-number>", type: "issue", body: "..." }` explaining what failed and why. Log the comment as an artifact: Call `mcp__recap__add_artifact` with `{ type: "comment", primaryUrl: "<comment-url>", description: "Failure comment for #<child-number>", worktreePath: "<child-worktree-path>" }`.
+4. **Log the failure as a recap entry**: Call `mcp__recap__add_entry` with `{ type: "risk", content: "Child #<child-number> failed: <brief reason>", worktreePath: "<child-worktree-path>" }` to record the failure in the child's recap
+5. **Do NOT block other children**: Continue processing remaining children
+6. **Handle downstream dependencies**: For any children that depend on the failed child:
+   - Mark them as `failed` with reason: "Blocked by failed dependency #<failed-child-number>"
+   - Update their loom state: Call `mcp__recap__set_loom_state` with `{ state: "failed", worktreePath: "<downstream-child-worktree-path>" }`
+   - Log a recap entry for each: Call `mcp__recap__add_entry` with `{ type: "risk", content: "Blocked by failed dependency #<failed-child-number>", worktreePath: "<downstream-child-worktree-path>" }`
+   - Do NOT spawn agents for them
+
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+Mark todo #9 as completed.
+{{else}}
+Mark todo #8 as completed.
+{{/if}}
+{{else}}
+Mark todo #8 as completed.
+{{/if}}
+
+---
+
+## Phase 5: Finalize
+
+When all children have reached a terminal state (`done` or `failed`):
+
+### Step 5.1: Shut Down Teammates
+
+Send `shutdown_request` to all teammates that are still active:
+- Use `SendMessage` with `type: "shutdown_request"` for each active teammate
+
+### Step 5.2: Clean Up Team
+
+Use `TeamDelete` to clean up the team `swarm-epic-{{EPIC_ISSUE_NUMBER}}`.
+
+### Step 5.3: Final Commit on Epic Branch
+
+If at least one child succeeded, **delegate the final commit to a subagent.**
+
+Spawn a subagent using the `Task` tool:
+- `subagent_type`: `"general-purpose"`
+- Prompt:
+
+```
+Create the final commit on the epic branch that closes the epic issue.
+
+```bash
+cd {{EPIC_WORKTREE_PATH}}
+git add -A
+git commit --allow-empty -m "Fixes {{ISSUE_PREFIX}}{{EPIC_ISSUE_NUMBER}}"
+```
+
+NOTE: --allow-empty is used because the child branches have already been merged — there may be no additional staged changes, but we still need the commit message to trigger issue closure.
+
+Report back with status: "success" or "failed" and the commit hash if successful.
+```
+
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+### Step 5.3.5: Push Epic Branch to Remote (Final Commit)
+
+After the final "Fixes" commit, push the epic branch to remote so the draft PR includes the issue-closing trailer. **Delegate this to a subagent.**
+
+**Note**: Incremental pushes in Step 3.3.5 should have already pushed merged child work. This final push adds the "Fixes" commit.
+
+First, check if push is needed (this is a lightweight read, OK to do directly):
+```bash
+cd {{EPIC_WORKTREE_PATH}}
+git log -1 --format=%s
+```
+- If the latest commit message starts with `[iloom-placeholder]` or `[iloom] Temporary`, no children succeeded. Skip the push.
+
+If a push is needed, spawn a subagent using the `Task` tool:
+- `subagent_type`: `"general-purpose"`
+- Prompt:
+
+```
+Push the epic branch to remote (final commit with Fixes trailer).
+
+```bash
+cd {{EPIC_WORKTREE_PATH}}
+git push --force-with-lease {{GIT_REMOTE}} HEAD
+```
+
+NOTE: --force-with-lease is required because the branch history includes rebased child commits.
+
+Report back with status: "success" or "failed" and any error output.
+```
+
+**Handle the subagent result:**
+- If push fails: Log the error but do NOT fail the swarm. The work is committed locally and `il finish` will handle the push.
+- Do NOT retry automatically.
+- If push succeeds: Log "Epic branch pushed to remote. Draft PR #{{DRAFT_PR_NUMBER}} updated with final commit."
+
+{{/if}}
+{{/if}}
+### Step 5.4: Print Summary
+
+Print a comprehensive summary:
+
+```
+## Swarm Orchestration Summary for Epic #<EPIC_ISSUE_NUMBER>
+
+### Results
+| Issue | Title | Status | Details |
+|-------|-------|--------|---------|
+| #<number> | <title> | <done/failed> | <brief detail> |
+| ... | ... | ... | ... |
+
+### Statistics
+- Total children: N
+- Succeeded: N
+- Failed: N
+
+### Epic Branch State
+The epic branch at `{{EPIC_WORKTREE_PATH}}` contains merged work from all successful children.
+
+### Failed Children
+<If any failed, list them with reasons>
+
+### Next Steps
+The epic worktree is ready for review at: `{{EPIC_WORKTREE_PATH}}`
+```
+
+{{#if DRAFT_PR_MODE}}
+{{#if AUTO_COMMIT_PUSH}}
+Mark todo #10, #11, #12, and #13 as completed.
+{{else}}
+Mark todo #9, #10, and #11 as completed.
+{{/if}}
+{{else}}
+Mark todo #9, #10, and #11 as completed.
+{{/if}}

package/dist/{rebase-YND35CIE.js → rebase-6NVLX5V7.js}

@@ -2,24 +2,24 @@
 import {
   BuildRunner,
   MergeManager
-} from "./chunk-R4YWBGY6.js";
+} from "./chunk-5FJWO4IT.js";
 import {
   installDependencies
-} from "./chunk-4LKGCFGG.js";
+} from "./chunk-WWKOVDWC.js";
 import {
   GitWorktreeManager
-} from "./chunk-TC7APDKU.js";
-import "./chunk-TL72BGP6.js";
-import "./chunk-VOGGLPG5.js";
+} from "./chunk-I5T677EA.js";
+import "./chunk-MORRVYPT.js";
+import "./chunk-YQ57ORTV.js";
+import "./chunk-UR5DGNUO.js";
 import {
   getWorktreeRoot,
   isValidGitRepo
-} from "./chunk-AR5QKYNE.js";
+} from "./chunk-4FGEGQW4.js";
 import {
   SettingsManager
-} from "./chunk-RI2YL6TK.js";
-import "./chunk-KBEIQP4G.js";
-import "./chunk-FO5GGFOV.js";
+} from "./chunk-7VHJNVLF.js";
+import "./chunk-KB64WNBZ.js";
 import "./chunk-6MLEBAYZ.js";
 import {
   logger
@@ -93,9 +93,10 @@ var RebaseCommand = class {
     }
     const mergeOptions = {
       dryRun: options.dryRun ?? false,
-      force: options.force ?? false
+      force: options.force ?? false,
+      jsonStream: options.jsonStream ?? false
     };
-    await this.mergeManager.rebaseOnMain(worktreePath, mergeOptions);
+    const outcome = await this.mergeManager.rebaseOnMain(worktreePath, mergeOptions);
     if (!options.dryRun) {
       logger.info("Installing dependencies...");
       try {
@@ -109,6 +110,14 @@ var RebaseCommand = class {
       logger.info("[DRY RUN] Would install dependencies");
     }
     await this.runPostRebaseBuild(worktreePath, options);
+    if (options.jsonStream) {
+      return {
+        success: true,
+        conflictsDetected: outcome.conflictsDetected,
+        claudeLaunched: outcome.claudeLaunched,
+        conflictsResolved: outcome.conflictsResolved
+      };
+    }
   }
   /**
    * Run post-rebase build for CLI projects
@@ -139,4 +148,4 @@ export {
   RebaseCommand,
   WorktreeValidationError
 };
-//# sourceMappingURL=rebase-YND35CIE.js.map
+//# sourceMappingURL=rebase-6NVLX5V7.js.map

package/dist/rebase-6NVLX5V7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/rebase.ts"],"sourcesContent":["import { logger } from '../utils/logger.js'\nimport { MergeManager } from '../lib/MergeManager.js'\nimport { GitWorktreeManager } from '../lib/GitWorktreeManager.js'\nimport { SettingsManager } from '../lib/SettingsManager.js'\nimport { BuildRunner } from '../lib/BuildRunner.js'\nimport { isValidGitRepo, getWorktreeRoot } from '../utils/git.js'\nimport { installDependencies } from '../utils/package-manager.js'\nimport type { MergeOptions, RebaseResult } from '../types/index.js'\n\nexport interface RebaseOptions {\n\tforce?: boolean\n\tdryRun?: boolean\n\tjsonStream?: boolean\n}\n\n/**\n * Error thrown when the rebase command is run from an invalid location\n */\nexport class WorktreeValidationError extends Error {\n\tconstructor(\n\t\tmessage: string,\n\t\tpublic readonly suggestion: string\n\t) {\n\t\tsuper(message)\n\t\tthis.name = 'WorktreeValidationError'\n\t}\n}\n\n/**\n * RebaseCommand: Rebase current branch on main with Claude-assisted conflict resolution\n *\n * This command:\n * 1. Validates the current directory is an iloom-managed worktree\n * 2. Detects the worktree root (supports running from subdirectories)\n * 3. Delegates to MergeManager.rebaseOnMain() which handles:\n *    - Checking main branch exists\n *    - Detecting uncommitted changes (throws if found)\n *    - Checking if already up-to-date\n *    - Executing rebase\n *    - Claude-assisted conflict resolution\n * 4. Reports success\n */\nexport class RebaseCommand {\n\tprivate mergeManager: MergeManager\n\tprivate gitWorktreeManager: GitWorktreeManager\n\tprivate settingsManager: SettingsManager\n\tprivate buildRunner: BuildRunner\n\n\tconstructor(mergeManager?: MergeManager, gitWorktreeManager?: GitWorktreeManager, settingsManager?: SettingsManager, buildRunner?: BuildRunner) {\n\t\tthis.mergeManager = mergeManager ?? new MergeManager()\n\t\tthis.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager()\n\t\tthis.settingsManager = settingsManager ?? new SettingsManager()\n\t\tthis.buildRunner = buildRunner ?? new BuildRunner()\n\t}\n\n\t/**\n\t * Validate that the current directory is within an iloom-managed worktree\n\t * Returns the worktree root path if valid\n\t * @throws WorktreeValidationError if validation fails\n\t */\n\tprivate async validateWorktreeContext(): Promise<string> {\n\t\tconst currentDir = process.cwd()\n\n\t\t// Step 1: Check if we're in a git repository at all\n\t\tconst isGitRepo = await isValidGitRepo(currentDir)\n\t\tif (!isGitRepo) {\n\t\t\tthrow new WorktreeValidationError(\n\t\t\t\t'Not a git repository.',\n\t\t\t\t\"Run 'il rebase' from within an iloom worktree created by 'il start'.\"\n\t\t\t)\n\t\t}\n\n\t\t// Step 2: Get the worktree root (handles subdirectories)\n\t\tconst worktreeRoot = await getWorktreeRoot(currentDir)\n\t\tif (!worktreeRoot) {\n\t\t\tthrow new WorktreeValidationError(\n\t\t\t\t'Could not determine repository root.',\n\t\t\t\t\"Run 'il rebase' from within an iloom worktree created by 'il start'.\"\n\t\t\t)\n\t\t}\n\n\t\t// Step 3: Check if this path is a registered git worktree\n\t\tconst worktrees = await this.gitWorktreeManager.listWorktrees()\n\t\tconst currentWorktree = worktrees.find(wt => wt.path === worktreeRoot)\n\n\t\tif (!currentWorktree) {\n\t\t\tthrow new WorktreeValidationError(\n\t\t\t\t'This directory is not an iloom worktree.',\n\t\t\t\t\"Run 'il rebase' from within a worktree created by 'il start <issue>'. Use 'il list' to see available worktrees.\"\n\t\t\t)\n\t\t}\n\n\t\t// Step 4: Check if this is the main worktree (we shouldn't rebase from main)\n\t\tconst isMain = await this.gitWorktreeManager.isMainWorktree(currentWorktree, this.settingsManager)\n\t\tif (isMain) {\n\t\t\tthrow new WorktreeValidationError(\n\t\t\t\t'Cannot rebase from the main worktree.',\n\t\t\t\t\"Navigate to a feature worktree created by 'il start <issue>' and run 'il rebase' from there.\"\n\t\t\t)\n\t\t}\n\n\t\treturn worktreeRoot\n\t}\n\n\tasync execute(options: RebaseOptions = {}): Promise<RebaseResult | void> {\n\t\t// Set ILOOM=1 so hooks know this is an iloom session\n\t\tprocess.env.ILOOM = '1'\n\n\t\t// Step 1: Validate we're in a valid iloom worktree\n\t\tlet worktreePath: string\n\t\ttry {\n\t\t\tworktreePath = await this.validateWorktreeContext()\n\t\t} catch (error) {\n\t\t\tif (error instanceof WorktreeValidationError) {\n\t\t\t\tlogger.error(error.message)\n\t\t\t\tlogger.info(error.suggestion)\n\t\t\t\tthrow error\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\n\t\tconst mergeOptions: MergeOptions = {\n\t\t\tdryRun: options.dryRun ?? false,\n\t\t\tforce: options.force ?? false,\n\t\t\tjsonStream: options.jsonStream ?? false,\n\t\t}\n\n\t\t// MergeManager.rebaseOnMain() handles:\n\t\t// - Checking main branch exists\n\t\t// - Detecting uncommitted changes (throws if found)\n\t\t// - Checking if already up-to-date\n\t\t// - Executing rebase\n\t\t// - Claude-assisted conflict resolution\n\t\tconst outcome = await this.mergeManager.rebaseOnMain(worktreePath, mergeOptions)\n\n\t\t// Install dependencies after successful rebase\n\t\tif (!options.dryRun) {\n\t\t\tlogger.info('Installing dependencies...')\n\t\t\ttry {\n\t\t\t\tawait installDependencies(worktreePath, true, true) // frozen=true, quiet=true\n\t\t\t} catch (error) {\n\t\t\t\t// Log warning but don't fail - rebase succeeded, user can fix deps manually\n\t\t\t\tconst message = error instanceof Error ? error.message : 'Unknown error'\n\t\t\t\tlogger.warn(`Dependency installation failed: ${message}`)\n\t\t\t\tlogger.warn('Please run your package manager install command manually')\n\t\t\t}\n\t\t} else {\n\t\t\tlogger.info('[DRY RUN] Would install dependencies')\n\t\t}\n\n\t\t// Run build for CLI projects after successful rebase\n\t\tawait this.runPostRebaseBuild(worktreePath, options)\n\n\t\t// Return result if jsonStream mode\n\t\tif (options.jsonStream) {\n\t\t\treturn {\n\t\t\t\tsuccess: true,\n\t\t\t\tconflictsDetected: outcome.conflictsDetected,\n\t\t\t\tclaudeLaunched: outcome.claudeLaunched,\n\t\t\t\tconflictsResolved: outcome.conflictsResolved,\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Run post-rebase build for CLI projects\n\t * Non-blocking: build failures are logged as warnings but don't fail the rebase\n\t */\n\tprivate async runPostRebaseBuild(worktreePath: string, options: RebaseOptions): Promise<void> {\n\t\tif (options.dryRun) {\n\t\t\tlogger.info('[DRY RUN] Would run post-rebase build for CLI projects')\n\t\t\treturn\n\t\t}\n\n\t\ttry {\n\t\t\tconst buildResult = await this.buildRunner.runBuild(worktreePath, {\n\t\t\t\tdryRun: options.dryRun ?? false,\n\t\t\t})\n\n\t\t\tif (buildResult.skipped) {\n\t\t\t\tlogger.debug(`Build skipped: ${buildResult.reason}`)\n\t\t\t} else {\n\t\t\t\tlogger.success('Post-rebase build completed successfully')\n\t\t\t}\n\t\t} catch (error) {\n\t\t\t// Log warning but don't fail - rebase succeeded, user can fix build manually\n\t\t\tconst message = error instanceof Error ? error.message : 'Unknown error'\n\t\t\tlogger.warn(`Post-rebase build failed: ${message}`)\n\t\t\tlogger.warn('Please run the build command manually')\n\t\t}\n\t}\n}\n"],"mappings":"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","names":[]}

package/dist/{recap-3W7COH7D.js → recap-OMBOKJST.js}

@@ -2,15 +2,18 @@
 import {
   formatRecapMarkdown
 } from "./chunk-NXMDEL3F.js";
+import {
+  findArchivedRecap
+} from "./chunk-LUKXJSRI.js";
 import {
   IdentifierParser
-} from "./chunk-YKFCCV6S.js";
+} from "./chunk-63QWFWH3.js";
 import {
   GitWorktreeManager
-} from "./chunk-TC7APDKU.js";
-import "./chunk-AR5QKYNE.js";
-import "./chunk-RI2YL6TK.js";
-import "./chunk-KBEIQP4G.js";
+} from "./chunk-I5T677EA.js";
+import "./chunk-4FGEGQW4.js";
+import "./chunk-7VHJNVLF.js";
+import "./chunk-KB64WNBZ.js";
 import "./chunk-6MLEBAYZ.js";
 import "./chunk-VT4PDUYT.js";
 
@@ -31,8 +34,7 @@ var RecapCommand = class {
    * Returns RecapOutput in JSON mode, void otherwise
    */
   async execute(input) {
-    const loomPath = await this.resolveLoomPath(input.identifier);
-    const filePath = path.join(RECAPS_DIR, slugifyPath(loomPath));
+    const filePath = await this.resolveRecapFilePath(input.identifier);
     let recap = {};
     try {
       if (await fs.pathExists(filePath)) {
@@ -52,12 +54,14 @@ var RecapCommand = class {
     console.log(formatRecapMarkdown(result));
   }
   /**
-   * Resolve identifier to loom path
-   * Falls back to cwd when no identifier is provided (backward compatible)
+   * Resolve identifier to a full recap file path.
+   * Returns the path to the active recap file, or falls back to an archived
+   * recap when the worktree no longer exists (e.g., after cleanup --archive).
+   * Falls back to cwd when no identifier is provided (backward compatible).
    */
-  async resolveLoomPath(identifier) {
+  async resolveRecapFilePath(identifier) {
     if (!(identifier == null ? void 0 : identifier.trim())) {
-      return process.cwd();
+      return path.join(RECAPS_DIR, slugifyPath(process.cwd()));
     }
     const trimmedId = identifier.trim();
     const gitWorktreeManager = new GitWorktreeManager();
@@ -68,34 +72,58 @@ var RecapCommand = class {
       const prNumber = parseInt(prMatch[1], 10);
       const worktree = await gitWorktreeManager.findWorktreeForPR(prNumber, "");
       if (worktree) {
-        return worktree.path;
+        return path.join(RECAPS_DIR, slugifyPath(worktree.path));
       }
-      throw new Error(`No worktree found for PR #${prNumber}`);
+      const archivedPath = await findArchivedRecap("pr", prNumber);
+      if (archivedPath) return archivedPath;
+      throw new Error(`No worktree or archived recap found for PR #${prNumber}`);
     }
     try {
       const parsed = await identifierParser.parseForPatternDetection(trimmedId);
       if (parsed.type === "pr" && typeof parsed.number === "number") {
         const worktree = await gitWorktreeManager.findWorktreeForPR(parsed.number, "");
         if (worktree) {
-          return worktree.path;
+          return path.join(RECAPS_DIR, slugifyPath(worktree.path));
         }
-        throw new Error(`No worktree found for PR #${parsed.number}`);
+        const archivedPath = await findArchivedRecap("pr", parsed.number);
+        if (archivedPath) return archivedPath;
+        throw new Error(`No worktree or archived recap found for PR #${parsed.number}`);
       }
       if (parsed.type === "issue" && parsed.number !== void 0) {
         const worktree = await gitWorktreeManager.findWorktreeForIssue(parsed.number);
         if (worktree) {
-          return worktree.path;
+          return path.join(RECAPS_DIR, slugifyPath(worktree.path));
+        }
+        const issueNum = typeof parsed.number === "string" ? parseInt(parsed.number, 10) : parsed.number;
+        if (isNaN(issueNum)) {
+          throw new Error(`No worktree found for identifier: ${identifier}`);
         }
-        throw new Error(`No worktree found for issue #${parsed.number}`);
+        const archivedPath = await findArchivedRecap("issue", issueNum);
+        if (archivedPath) return archivedPath;
+        throw new Error(`No worktree or archived recap found for issue #${parsed.number}`);
       }
       if (parsed.type === "branch" && parsed.branchName) {
         const worktree = await gitWorktreeManager.findWorktreeForBranch(parsed.branchName);
         if (worktree) {
-          return worktree.path;
+          return path.join(RECAPS_DIR, slugifyPath(worktree.path));
         }
         throw new Error(`No worktree found for branch: ${parsed.branchName}`);
       }
     } catch (error) {
+      if (error instanceof Error && (error.message.startsWith("No worktree or archived recap found") || error.message.startsWith("No worktree found for branch:"))) {
+        throw error;
+      }
+      if (error instanceof Error && error.message === `No worktree found for identifier: ${trimmedId}`) {
+        const numericMatch = trimmedId.match(/^(\d+)$/);
+        if (numericMatch == null ? void 0 : numericMatch[1]) {
+          const num = parseInt(numericMatch[1], 10);
+          const archivedIssue = await findArchivedRecap("issue", num);
+          if (archivedIssue) return archivedIssue;
+          const archivedPr = await findArchivedRecap("pr", num);
+          if (archivedPr) return archivedPr;
+          throw new Error(`No worktree or archived recap found for #${num}`);
+        }
+      }
       if (error instanceof Error) {
         throw new Error(`Could not resolve identifier '${identifier}': ${error.message}`);
       }
@@ -107,4 +135,4 @@ var RecapCommand = class {
 export {
   RecapCommand
 };
-//# sourceMappingURL=recap-3W7COH7D.js.map
+//# sourceMappingURL=recap-OMBOKJST.js.map