@caseyharalson/orrery 0.11.0 → 0.13.0

package/HELP.md

@@ -71,20 +71,28 @@ each step.
 
 ```
 Options:
-  --plan <file>  Process only a specific plan file
-  --dry-run      Show what would be executed without running agents
-  --verbose      Show detailed agent output
-  --resume       Resume orchestration on the current work branch
-  --review       Enable code review loop after each step
-  --parallel     Enable parallel execution with git worktrees for isolation
+  --plan <file>   Process only a specific plan file
+  --dry-run       Show what would be executed without running agents
+  --verbose       Show detailed agent output
+  --resume        Resume orchestration on the current work branch
+  --review        Enable code review loop after each step
+  --parallel      Enable parallel execution with git worktrees for isolation
+  --background    Run orchestration as a detached background process
+  --on-complete <command>  Run a shell command when the orchestrator finishes
 ```
 
+A lock file prevents concurrent runs and is automatically cleaned up. Without
+`--plan`, a global lock (`exec.lock`) allows only one execution at a time.
+With `--plan`, each plan gets its own lock (`exec-<planId>.lock`) and runs in
+an isolated worktree, so multiple plans can execute concurrently.
+
 Example:
 
 ```bash
 orrery exec
 orrery exec --plan my-feature.yaml --review
 orrery exec --parallel --verbose
+orrery exec --background
 ```
 
 #### `orrery resume`
@@ -94,15 +102,25 @@ work branch, resets blocked steps to pending, commits, and resumes.
 
 ```
 Options:
-  --step <id>  Unblock a specific step before resuming
-  --all        Unblock all blocked steps (default behavior)
-  --dry-run    Preview what would be unblocked without making changes
+  --plan <file>  Resume a specific plan file (skips branch auto-detection)
+  --step <id>    Unblock a specific step before resuming
+  --all          Unblock all blocked steps (default behavior)
+  --dry-run      Preview what would be unblocked without making changes
+  --background   Run resume as a detached background process
+  --on-complete <command>  Run a shell command when the orchestrator finishes
 ```
 
+When `--plan` is provided and a worktree exists for the plan, resume runs
+directly inside the worktree. Otherwise, the plan's `work_branch` must match
+the current branch. If the plan hasn't been dispatched yet (no `work_branch`),
+use `orrery exec --plan` first.
+
 Example:
 
 ```bash
 orrery resume
+orrery resume --plan my-feature.yaml
+orrery resume --plan my-feature.yaml --background
 orrery resume --step step-2
 orrery resume --dry-run
 ```
@@ -112,7 +130,8 @@ orrery resume --dry-run
 #### `orrery status`
 
 Show orchestration status for plans in the current project. Auto-detects the
-plan when on a work branch.
+plan when on a work branch. Also shows whether an orchestration process is
+currently running (via lock file detection) or if a stale lock exists.
 
 ```
 Options:
@@ -250,6 +269,72 @@ The review agent inspects changes after each step. If issues are found, an edit
 agent applies fixes and verification re-runs, repeating until approval or the
 max iteration limit is reached (default: 3).
 
+### Background Execution
+
+Run orchestration or resume as a detached background process:
+
+```bash
+orrery exec --background
+orrery exec --plan my-feature.yaml --background
+orrery resume --plan my-feature.yaml --background
+```
+
+The process runs detached and logs output to `<work-dir>/exec.log` (or
+`exec-<planId>.log` for per-plan execution). Use `orrery status` to check
+progress. Each execution acquires its own lock file — a global `exec.lock` for non-plan
+runs, or `exec-<planId>.lock` when `--plan` is used — so background per-plan
+executions can run concurrently.
+
+### Concurrent Plan Execution
+
+Run multiple plans at the same time by using `--plan` in separate terminals.
+Each plan executes in its own git worktree (`.worktrees/plan-<planId>`) with
+an independent lock file, so plans do not interfere with each other.
+
+```bash
+# Terminal 1
+orrery exec --plan auth-feature.yaml
+
+# Terminal 2
+orrery exec --plan search-feature.yaml
+
+# Or run both in the background from a single terminal
+orrery exec --plan auth-feature.yaml --background
+orrery exec --plan search-feature.yaml --background
+```
+
+Use `orrery status` to see all running plans at once. Resume a specific plan
+with `orrery resume --plan <file>`, which automatically re-enters the plan's
+existing worktree.
+
+Note: Without `--plan`, execution uses a global lock and only one run is
+allowed at a time.
+
+### Completion Hook
+
+Run a shell command when the orchestrator finishes using `--on-complete`:
+
+```bash
+orrery exec --on-complete "notify-send 'Plan finished'"
+orrery resume --plan my-feature.yaml --on-complete "./scripts/on-done.sh"
+```
+
+The command receives plan context through environment variables:
+
+| Variable                 | Description                                    | Example                                                |
+| :----------------------- | :--------------------------------------------- | :----------------------------------------------------- |
+| `ORRERY_PLAN_NAME`       | Plan file name                                 | `my-feature.yaml`                                      |
+| `ORRERY_PLAN_FILE`       | Absolute path to the plan file                 | `/home/user/project/.agent-work/plans/my-feature.yaml` |
+| `ORRERY_PLAN_OUTCOME`    | Outcome: `success`, `partial`, or `incomplete` | `success`                                              |
+| `ORRERY_WORK_BRANCH`     | Work branch name                               | `plan/my-feature`                                      |
+| `ORRERY_SOURCE_BRANCH`   | Source branch name                             | `main`                                                 |
+| `ORRERY_PR_URL`          | PR URL (empty if not created)                  | `https://github.com/user/repo/pull/42`                 |
+| `ORRERY_STEPS_TOTAL`     | Total number of steps                          | `5`                                                    |
+| `ORRERY_STEPS_COMPLETED` | Number of completed steps                      | `4`                                                    |
+| `ORRERY_STEPS_BLOCKED`   | Number of blocked steps                        | `1`                                                    |
+
+Hook failures are logged but do not fail the orchestrator.
+
 ### Parallel Execution
 
 Run independent steps concurrently using git worktrees for isolation:
@@ -368,11 +453,19 @@ Orrery maintains state in `.agent-work/` (configurable via `ORRERY_WORK_DIR`):
 
 ```
 .agent-work/
-  plans/        Active plan files (new and in-progress)
-  reports/      Step-level execution logs and outcomes
-  completed/    Successfully executed plans (archived)
+  plans/                Active plan files (new and in-progress)
+  reports/              Step-level execution logs and outcomes
+  completed/            Successfully executed plans (archived)
+  exec.lock             Lock file when orchestration is running
+  exec-<planId>.lock    Per-plan lock file for concurrent execution
+  exec.log              Output log for background execution
+  exec-<planId>.log     Per-plan output log for concurrent background execution
 ```
 
+When `ORRERY_WORK_DIR` is set, Orrery automatically scopes to a project
+subdirectory (`<project-name>-<hash>`) so multiple projects can share the same
+work directory without plan conflicts.
+
 ---
 
 ## Environment Variables
@@ -385,7 +478,7 @@ Orrery maintains state in `.agent-work/` (configurable via `ORRERY_WORK_DIR`):
 | `ORRERY_PARALLEL_MAX`          | Maximum concurrent parallel agents                   | `3`                   |
 | `ORRERY_REVIEW_ENABLED`        | Enable the review loop                               | `false`               |
 | `ORRERY_REVIEW_MAX_ITERATIONS` | Maximum review-edit loop iterations                  | `3`                   |
-| `ORRERY_WORK_DIR`              | Override the work directory path                     | `.agent-work`         |
+| `ORRERY_WORK_DIR`              | Override the work directory path (project-scoped)    | `.agent-work`         |
 
 ---
 

package/README.md

@@ -88,6 +88,8 @@ For power users, Orrery offers additional capabilities:
 - **External Plan Creation** - Import plans from other tools or LLMs
 - **Review Loop** - Iterative code review after each step with automatic fixes
 - **Parallel Execution** - Run independent steps concurrently with git worktree isolation
+- **Background Execution** - Run orchestration as a detached process and poll status
+- **Completion Hook** - Run a command when orchestration finishes
 - **Handling Blocked Plans** - Recovery workflows when steps cannot complete
 
 See [Advanced Workflows](docs/advanced-workflows.md) for details.
@@ -120,17 +122,18 @@ The Orchestrator (`orrery exec`) is the engine that drives the process. It loads
 
 ## Command Reference
 
-| Command              | Description                                                                                                   |
-| :------------------- | :------------------------------------------------------------------------------------------------------------ |
-| `orrery`             | Command reference.                                                                                            |
-| `orrery init`        | Initialize Orrery: install skills to detected agents.                                                         |
-| `orrery manual`      | Show the full CLI reference manual.                                                                           |
-| `orrery orchestrate` | Executes the active plan. Use `--review` for review loop, `--parallel` for parallel execution. Alias: `exec`. |
-| `orrery status`      | Shows the progress of current plans.                                                                          |
+| Command              | Description                                                                                                                                                                            |
+| :------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `orrery`             | Command reference.                                                                                                                                                                     |
+| `orrery init`        | Initialize Orrery: install skills to detected agents.                                                                                                                                  |
+| `orrery manual`      | Show the full CLI reference manual.                                                                                                                                                    |
+| `orrery orchestrate` | Executes the active plan. Use `--review` for review loop, `--parallel` for parallel execution, `--background` for detached mode, `--on-complete` for a completion hook. Alias: `exec`. |
+| `orrery resume`      | Unblock steps and resume orchestration. Use `--plan` to target a specific plan, `--background` for detached mode.                                                                      |
+| `orrery status`      | Shows the progress of current plans and active execution status.                                                                                                                       |
 
 ## Directory Structure
 
-Orrery maintains its state in the `.agent-work/` directory (configurable via `ORRERY_WORK_DIR`).
+Orrery maintains its state in the `.agent-work/` directory (configurable via `ORRERY_WORK_DIR`). When `ORRERY_WORK_DIR` is set, each project gets an isolated subdirectory so multiple projects can share the same work directory.
 
 - `.agent-work/plans/`: **Active Plans.** New and in-progress plan files.
 - `.agent-work/reports/`: **Reports.** Step-level execution logs and outcomes.

package/agent/skills/discovery/SKILL.md

@@ -191,7 +191,15 @@ Use the schema defined in `./schemas/plan-schema.yaml`.
 
 **Output Location:**
 
-- Directory: `.agent-work/plans/`
+First, determine the plans directory by running:
+
+```bash
+orrery plans-dir
+```
+
+This prints the resolved plans directory (respects `ORRERY_WORK_DIR` when set).
+
+- Directory: the path returned by `orrery plans-dir`
 - Filename: `<date>-<plan-name>.yaml`
 - Date format: YYYY-MM-DD (e.g., `2026-01-11`)
 - Plan name: kebab-case description of the task (e.g., `fix-clone-agent-skills`)
@@ -215,7 +223,7 @@ Plans are automatically validated via the PostToolUse hook when written.
 For manual validation, run:
 
 ```bash
-orrery validate-plan .agent-work/plans/<plan>.yaml
+orrery validate-plan <plans-dir>/<plan>.yaml
 ```
 
 This catches common YAML issues like unquoted colons and normalizes formatting.
@@ -405,11 +413,11 @@ Discovery is complete when:
 When the plan is complete and validated, output the plan file path and present the user with their next options:
 
 ```
-Plan created: .agent-work/plans/<date>-<plan-name>.yaml
+Plan created: <plans-dir>/<date>-<plan-name>.yaml
 
 Next steps:
-- /refine-plan .agent-work/plans/<plan-file> — Analyze and improve the plan before execution
-- /simulate-plan .agent-work/plans/<plan-file> — Explore the plan through dialogue, ask "what if" questions
+- /refine-plan <plans-dir>/<plan-file> — Analyze and improve the plan before execution
+- /simulate-plan <plans-dir>/<plan-file> — Explore the plan through dialogue, ask "what if" questions
 - orrery exec — (Command run from the terminal) Execute the plan with the orrery orchestrator
 ```
 

package/agent/skills/orrery-execute/SKILL.md

@@ -39,7 +39,7 @@ These guidelines override generic examples in this skill. For example, if a guid
 
 ### Git State
 
-The orchestrator modifies `.agent-work/` files before you start (marking steps `in_progress`, creating temp files). This is expected. **Ignore changes in `.agent-work/`** when checking git status - these are orchestrator bookkeeping files, not unexpected changes.
+The orchestrator modifies plan and work directory files before you start (marking steps `in_progress`, creating temp files). This is expected. **Ignore changes in the orchestrator work directory** (e.g., `.agent-work/` or the path from `orrery plans-dir`) when checking git status - these are orchestrator bookkeeping files, not unexpected changes.
 
 ### Step 1: Read the Plan
 

package/agent/skills/refine-plan/SKILL.md

@@ -3,7 +3,8 @@ name: refine-plan
 description: >
   Analyze and improve an existing plan file. Reviews plan structure, dependencies,
   context quality, and acceptance criteria, then implements improvements directly.
-  Requires a plan file argument (e.g., /refine-plan .agent-work/plans/my-plan.yaml).
+  Requires a plan file argument (e.g., /refine-plan my-plan.yaml).
+  Run `orrery plans-dir` to find the plans directory.
 hooks:
   PostToolUse:
     - matcher: "Write"
@@ -273,7 +274,7 @@ Ready for execution.
 ## Example Dialogue
 
 ```
-User: /refine-plan .agent-work/plans/analytics-dashboard.yaml
+User: /refine-plan analytics-dashboard.yaml
 
 Agent: I've loaded the analytics dashboard plan. It has 6 steps delivering
 two outcomes. Let me analyze it for improvements.

package/agent/skills/simulate-plan/SKILL.md

@@ -2,7 +2,8 @@
 name: simulate-plan
 description: >
   Explore a plan through conversational dialogue before committing to execution.
-  Requires a plan file argument (e.g., /simulate-plan .agent-work/plans/my-plan.yaml, /simulate-plan my-plan).
+  Requires a plan file argument (e.g., /simulate-plan my-plan.yaml, /simulate-plan my-plan).
+  Run `orrery plans-dir` to find the plans directory.
   Ask "what if" questions, trace dependencies, and build intuition about what you're building.
 ---
 
@@ -164,7 +165,7 @@ Only discuss what's in the plan. If asked about implementation details not cover
 ## Example Dialogue
 
 ```
-User: /simulate .agent-work/plans/analytics-dashboard.yaml
+User: /simulate-plan analytics-dashboard.yaml
 
 Agent: I've loaded the analytics dashboard plan. It has 6 steps delivering
 two outcomes: "Users can see usage trends" and "Admins can export reports."

package/lib/cli/commands/orchestrate.js

@@ -1,4 +1,10 @@
+const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
 const { orchestrate } = require("../../orchestration");
+const { getWorkDir } = require("../../utils/paths");
+const { derivePlanId } = require("../../utils/git");
 
 module.exports = function registerOrchestrateCommand(program) {
   program
@@ -14,7 +20,65 @@ module.exports = function registerOrchestrateCommand(program) {
       "--parallel",
       "Enable parallel execution with git worktrees for isolation"
     )
+    .option(
+      "--background",
+      "Run orchestration as a detached background process"
+    )
+    .option(
+      "--on-complete <command>",
+      "Run a shell command when the orchestrator finishes"
+    )
     .action(async (options) => {
+      // Background mode: re-spawn as detached process
+      if (options.background) {
+        if (options.dryRun) {
+          console.log(
+            "Note: --background with --dry-run runs in foreground.\n"
+          );
+          // Fall through to normal execution
+        } else {
+          const args = [];
+          if (options.plan) args.push("--plan", options.plan);
+          if (options.verbose) args.push("--verbose");
+          if (options.resume) args.push("--resume");
+          if (options.review) args.push("--review");
+          if (options.parallel) args.push("--parallel");
+          if (options.onComplete)
+            args.push("--on-complete", options.onComplete);
+
+          let logFileName = "exec.log";
+          if (options.plan) {
+            const planId = derivePlanId(path.basename(options.plan));
+            logFileName = `exec-${planId}.log`;
+          }
+          const logFile = path.join(getWorkDir(), logFileName);
+          const logFd = fs.openSync(logFile, "a");
+
+          const binPath = path.join(
+            __dirname,
+            "..",
+            "..",
+            "..",
+            "bin",
+            "orrery.js"
+          );
+          const child = spawn(process.execPath, [binPath, "exec", ...args], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            cwd: process.cwd(),
+            env: process.env
+          });
+
+          child.unref();
+          fs.closeSync(logFd);
+
+          console.log(`Background execution started (PID ${child.pid})`);
+          console.log(`Log file: ${logFile}`);
+          console.log("\nUse 'orrery status' to check progress.");
+          return;
+        }
+      }
+
       try {
         await orchestrate({
           plan: options.plan,
@@ -22,7 +86,8 @@ module.exports = function registerOrchestrateCommand(program) {
           verbose: options.verbose,
           resume: options.resume,
           review: options.review,
-          parallel: options.parallel
+          parallel: options.parallel,
+          onComplete: options.onComplete
         });
       } catch (error) {
         console.error(error && error.message ? error.message : error);

package/lib/cli/commands/plans-dir.js

@@ -0,0 +1,10 @@
+const { getPlansDir } = require("../../utils/paths");
+
+module.exports = function registerPlansDirCommand(program) {
+  program
+    .command("plans-dir")
+    .description("Print the resolved plans directory path")
+    .action(() => {
+      console.log(getPlansDir());
+    });
+};

package/lib/cli/commands/resume.js

@@ -1,8 +1,14 @@
+const { spawn } = require("child_process");
+const fs = require("fs");
 const path = require("path");
 
 const { findPlanForCurrentBranch } = require("../../utils/plan-detect");
-const { updateStepsStatus } = require("../../orchestration/plan-loader");
-const { commit } = require("../../utils/git");
+const {
+  loadPlan,
+  updateStepsStatus
+} = require("../../orchestration/plan-loader");
+const { commit, getCurrentBranch, derivePlanId } = require("../../utils/git");
+const { getPlansDir, getWorkDir } = require("../../utils/paths");
 const { orchestrate } = require("../../orchestration");
 
 function supportsColor() {
@@ -24,38 +30,162 @@ module.exports = function registerResumeCommand(program) {
   program
     .command("resume")
     .description("Unblock steps and resume orchestration")
+    .option("--plan <file>", "Resume a specific plan file")
     .option("--step <id>", "Unblock a specific step before resuming")
     .option("--all", "Unblock all blocked steps (default behavior)")
     .option(
       "--dry-run",
       "Preview what would be unblocked without making changes"
     )
+    .option("--background", "Run resume as a detached background process")
+    .option(
+      "--on-complete <command>",
+      "Run a shell command when the orchestrator finishes"
+    )
     .action(async (options) => {
-      // 1. Find plan for current branch
-      let match;
-      try {
-        match = findPlanForCurrentBranch();
-      } catch {
-        console.error("Error detecting plan from current branch.");
-        console.log(
-          "Make sure you're on a work branch (e.g., plan/feature-name)."
-        );
-        process.exitCode = 1;
-        return;
+      // Background mode: re-spawn as detached process
+      if (options.background) {
+        if (options.dryRun) {
+          console.log(
+            "Note: --background with --dry-run runs in foreground.\n"
+          );
+          // Fall through to normal execution
+        } else {
+          const args = [];
+          if (options.plan) args.push("--plan", options.plan);
+          if (options.step) args.push("--step", options.step);
+          if (options.all) args.push("--all");
+          if (options.onComplete)
+            args.push("--on-complete", options.onComplete);
+
+          let logFileName = "exec.log";
+          if (options.plan) {
+            const planId = derivePlanId(path.basename(options.plan));
+            logFileName = `exec-${planId}.log`;
+          }
+          const logFile = path.join(getWorkDir(), logFileName);
+          const logFd = fs.openSync(logFile, "a");
+
+          const binPath = path.join(
+            __dirname,
+            "..",
+            "..",
+            "..",
+            "bin",
+            "orrery.js"
+          );
+          const child = spawn(process.execPath, [binPath, "resume", ...args], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            cwd: process.cwd(),
+            env: process.env
+          });
+
+          child.unref();
+          fs.closeSync(logFd);
+
+          console.log(`Background resume started (PID ${child.pid})`);
+          console.log(`Log file: ${logFile}`);
+          console.log("\nUse 'orrery status' to check progress.");
+          return;
+        }
       }
 
-      if (!match) {
-        console.error(
-          "Not on a work branch. No plan found for current branch."
+      let planFile;
+      let plan;
+
+      if (options.plan) {
+        // Resolve plan path (same pattern as status.js)
+        const planArg = options.plan;
+        let resolvedPath;
+        if (path.isAbsolute(planArg)) {
+          resolvedPath = planArg;
+        } else if (planArg.includes(path.sep)) {
+          resolvedPath = path.resolve(process.cwd(), planArg);
+        } else {
+          resolvedPath = path.join(getPlansDir(), planArg);
+        }
+
+        if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+          console.error(`Plan not found: ${planArg}`);
+          process.exitCode = 1;
+          return;
+        }
+
+        plan = loadPlan(resolvedPath);
+        planFile = resolvedPath;
+
+        // Validate work_branch
+        if (!plan.metadata.work_branch) {
+          console.error(
+            "Plan has no work_branch — it hasn't been dispatched yet."
+          );
+          console.log(
+            "\nUse 'orrery exec --plan <file>' to dispatch the plan first."
+          );
+          process.exitCode = 1;
+          return;
+        }
+
+        // Check for existing worktree — if found, skip branch validation
+        const planId = derivePlanId(path.basename(resolvedPath));
+        const worktreePath = path.join(
+          process.cwd(),
+          ".worktrees",
+          `plan-${planId}`
         );
-        console.log("\nTo resume a plan:");
-        console.log("  1. git checkout <work-branch>");
-        console.log("  2. orrery resume");
-        process.exitCode = 1;
-        return;
-      }
+        const hasWorktree = require("fs").existsSync(worktreePath);
+
+        if (!hasWorktree) {
+          // Verify current branch matches plan's work_branch
+          let currentBranch;
+          try {
+            currentBranch = getCurrentBranch(process.cwd());
+          } catch {
+            console.error("Error detecting current branch.");
+            process.exitCode = 1;
+            return;
+          }
+
+          if (currentBranch !== plan.metadata.work_branch) {
+            console.error(
+              `Plan expects branch '${plan.metadata.work_branch}' but you are on '${currentBranch}'.`
+            );
+            console.log(`\nRun: git checkout ${plan.metadata.work_branch}`);
+            process.exitCode = 1;
+            return;
+          }
+        }
+      } else {
+        // 1. Find plan for current branch (existing behavior)
+        let match;
+        try {
+          match = findPlanForCurrentBranch();
+        } catch {
+          console.error("Error detecting plan from current branch.");
+          console.log(
+            "Make sure you're on a work branch (e.g., plan/feature-name)."
+          );
+          process.exitCode = 1;
+          return;
+        }
 
-      const { planFile, plan } = match;
+        if (!match) {
+          console.error(
+            "Not on a work branch. No plan found for current branch."
+          );
+          console.log("\nTo resume a plan:");
+          console.log("  1. git checkout <work-branch>");
+          console.log("  2. orrery resume");
+          console.log("\nOr specify a plan directly:");
+          console.log("  orrery resume --plan <file>");
+          process.exitCode = 1;
+          return;
+        }
+
+        planFile = match.planFile;
+        plan = match.plan;
+      }
       const planFileName = path.basename(planFile);
       console.log(`(detected plan: ${planFileName})\n`);
 
@@ -72,13 +202,15 @@ module.exports = function registerResumeCommand(program) {
         }
 
         console.log("Resuming orchestration...\n");
-        await orchestrate({ resume: true });
+        await orchestrate({
+          resume: true,
+          plan: options.plan,
+          onComplete: options.onComplete
+        });
         return;
       }
 
       // 4. Determine which steps to unblock
-      let stepsToUnblock = [];
-
       if (options.step) {
         // Unblock specific step
         const step = blockedSteps.find((s) => s.id === options.step);
@@ -93,12 +225,12 @@ module.exports = function registerResumeCommand(program) {
           process.exitCode = 1;
           return;
         }
-        stepsToUnblock = [step];
-      } else {
-        // Default: unblock all (--all is implicit)
-        stepsToUnblock = blockedSteps;
       }
 
+      const stepsToUnblock = options.step
+        ? [blockedSteps.find((s) => s.id === options.step)]
+        : blockedSteps;
+
       // 5. Dry-run mode: show preview
       if (options.dryRun) {
         console.log("Dry run - would unblock the following steps:\n");
@@ -141,6 +273,10 @@ module.exports = function registerResumeCommand(program) {
 
       // 8. Resume orchestration
       console.log("\nResuming orchestration...\n");
-      await orchestrate({ resume: true });
+      await orchestrate({
+        resume: true,
+        plan: options.plan,
+        onComplete: options.onComplete
+      });
     });
 };