@stackmemoryai/stackmemory 1.10.4 → 1.12.0

package/dist/src/cli/commands/daemon.js

@@ -107,6 +107,7 @@ The daemon provides:
         const services = [];
         if (newStatus.services.context.enabled) services.push("context");
         if (newStatus.services.linear.enabled) services.push("linear");
+        if (newStatus.services.github?.enabled) services.push("github");
         if (newStatus.services.maintenance?.enabled)
           services.push("maintenance");
         if (newStatus.services.memory?.enabled) services.push("memory");
@@ -232,6 +233,25 @@ The daemon provides:
         console.log(chalk.gray(`    Syncs: ${lin.syncCount}`));
       }
     }
+    const gh = status.services.github;
+    if (gh) {
+      console.log(
+        `  GitHub: ${gh.enabled ? chalk.green("Enabled") : chalk.gray("Disabled")}`
+      );
+      if (gh.enabled) {
+        console.log(
+          chalk.gray(`    Interval: ${config.github.interval} min`)
+        );
+        if (gh.syncCount) {
+          console.log(chalk.gray(`    Refreshes: ${gh.syncCount}`));
+        }
+        if (gh.lastProjectionState) {
+          console.log(
+            chalk.gray(`    Last PR state: ${gh.lastProjectionState}`)
+          );
+        }
+      }
+    }
     const maint = status.services.maintenance;
     if (maint) {
       console.log(
@@ -605,6 +625,22 @@ function getServiceHealthChecks(status, config) {
       detail: "Disabled"
     });
   }
+  const gh = status.services.github;
+  if (gh?.enabled) {
+    const intervalMs = config.github.interval * 6e4;
+    const overdue = gh.lastRun ? Date.now() - gh.lastRun > intervalMs * 2 : false;
+    checks.push({
+      name: "GitHub Service",
+      status: overdue ? "warn" : "ok",
+      detail: gh.lastRun ? `Last refresh: ${formatTimeAgo(gh.lastRun)} | Refreshes: ${gh.syncCount ?? 0}${gh.lastProjectionState ? ` | Last PR state: ${gh.lastProjectionState}` : ""}` : `Enabled (interval: ${config.github.interval}m) | No refreshes yet`
+    });
+  } else {
+    checks.push({
+      name: "GitHub Service",
+      status: "ok",
+      detail: "Disabled"
+    });
+  }
   const maint = status.services.maintenance;
   if (maint?.enabled) {
     const intervalMs = config.maintenance.interval * 6e4;
@@ -701,6 +737,11 @@ function buildHealthReport(status, config, paths) {
       enabled: status.services.linear.enabled,
       lastRun: status.services.linear.lastRun
     },
+    {
+      key: "github",
+      enabled: status.services.github?.enabled ?? false,
+      lastRun: status.services.github?.lastRun
+    },
     {
       key: "maintenance",
       enabled: status.services.maintenance?.enabled ?? false,

package/dist/src/cli/commands/handoff.js

@@ -20,6 +20,10 @@ import { FrameManager } from "../../core/context/index.js";
 import { LinearTaskManager } from "../../features/tasks/linear-task-manager.js";
 import { logger } from "../../core/monitoring/logger.js";
 import { EnhancedHandoffGenerator } from "../../core/session/handoff.js";
+import {
+  getProjectHandoffPaths,
+  loadProjectHandoff
+} from "../../core/session/project-handoff.js";
 const countTokens = (text) => Math.ceil(text.length / 3.5);
 const MAX_HANDOFF_VERSIONS = 10;
 function saveVersionedHandoff(projectRoot, branch, content) {
@@ -273,7 +277,7 @@ Generated by stackmemory capture at ${timestamp}
       if (!existsSync(stackmemoryDir)) {
         mkdirSync(stackmemoryDir, { recursive: true });
       }
-      const handoffPath = join(stackmemoryDir, "last-handoff.md");
+      const { handoffPath, metadataPath } = getProjectHandoffPaths(projectRoot);
       writeFileSync(handoffPath, handoffPrompt);
       let branch = "unknown";
       try {
@@ -289,6 +293,18 @@ Generated by stackmemory capture at ${timestamp}
         branch,
         handoffPrompt
       );
+      writeFileSync(
+        metadataPath,
+        JSON.stringify(
+          {
+            branch,
+            capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            projectRoot
+          },
+          null,
+          2
+        )
+      );
       console.log(
         `Versioned: ${versionedPath.split("/").slice(-2).join("/")}`
       );
@@ -331,26 +347,41 @@ Generated by stackmemory capture at ${timestamp}
 }
 function createRestoreCommand() {
   const cmd = new Command("restore");
-  cmd.description("Restore context from last handoff").option("--no-copy", "Do not copy prompt to clipboard").action(async (options) => {
+  cmd.description("Restore context from last handoff").option("--no-copy", "Do not copy prompt to clipboard").option("--force", "Restore even if the handoff branch does not match").action(async (options) => {
     try {
       const projectRoot = process.cwd();
-      const handoffPath = join(
-        projectRoot,
-        ".stackmemory",
-        "last-handoff.md"
-      );
       const metaPath = join(
         process.env["HOME"] || "~",
         ".stackmemory",
         "handoffs",
         "last-handoff-meta.json"
       );
-      if (!existsSync(handoffPath)) {
+      const currentBranch = (() => {
+        try {
+          return execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf-8",
+            cwd: projectRoot,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+        } catch {
+          return void 0;
+        }
+      })();
+      const handoff = loadProjectHandoff(projectRoot, currentBranch);
+      if (!handoff) {
         console.log("\u274C No handoff found in this project");
         console.log('\u{1F4A1} Run "stackmemory capture" to create one');
         return;
       }
-      const handoffPrompt = readFileSync(handoffPath, "utf-8");
+      if (!handoff.compatible && !options.force) {
+        console.log("\u26A0\uFE0F  Skipping stale handoff");
+        console.log(`   ${handoff.mismatchReason}`);
+        console.log(
+          '   Run "stackmemory restore --force" to inspect it anyway'
+        );
+        return;
+      }
+      const handoffPrompt = handoff.content;
       console.log("\n" + "=".repeat(60));
       console.log("\u{1F4CB} RESTORED HANDOFF");
       console.log("=".repeat(60));

package/dist/src/cli/commands/onboard.js

@@ -383,6 +383,67 @@ DATABASE_URL=${config.databaseUrl}
       console.log(chalk.yellow("  \u26A0 Could not write hosted DB env file"));
     }
   }
+  {
+    const claudeCommandsDir = join(homedir(), ".claude", "commands");
+    const packsDir = join(__dirname, "..", "..", "..", "packs");
+    const coreManifest = join(packsDir, "core", "manifest.json");
+    if (existsSync(coreManifest)) {
+      const { installCommands } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "installCommands",
+          message: "Install session commands for Claude Code? (/start, /stop, /restart, /next)",
+          default: true
+        }
+      ]);
+      if (installCommands) {
+        console.log(chalk.gray("Installing command pack: core..."));
+        try {
+          execFileSync(
+            process.execPath,
+            [process.argv[1], "setup-commands", "--force"],
+            { stdio: "pipe" }
+          );
+          console.log(
+            chalk.green("  \u2713 Installed /start, /stop, /restart, /next")
+          );
+        } catch {
+          try {
+            if (!existsSync(claudeCommandsDir)) {
+              mkdirSync(claudeCommandsDir, { recursive: true });
+            }
+            const manifest = JSON.parse(
+              (await import("fs")).readFileSync(coreManifest, "utf8")
+            );
+            const allCmds = [
+              ...manifest.commands?.public || [],
+              ...manifest.commands?.internal || []
+            ];
+            let count = 0;
+            for (const cmd of allCmds) {
+              const src = join(packsDir, "core", cmd.file);
+              const dst = join(claudeCommandsDir, `${cmd.name}.md`);
+              if (existsSync(src) && !existsSync(dst)) {
+                execFileSync("ln", ["-s", src, dst]);
+                count++;
+              }
+            }
+            if (count > 0) {
+              console.log(
+                chalk.green(`  \u2713 Installed ${count} command(s)`)
+              );
+            }
+          } catch {
+            console.log(
+              chalk.yellow(
+                "  \u26A0 Could not install commands. Run: stackmemory setup-commands"
+              )
+            );
+          }
+        }
+      }
+    }
+  }
   const binPath = "/usr/local/bin/claude-sm";
   const sourcePath = join(configPath, "bin", "stackmemory");
   try {
@@ -531,12 +592,18 @@ function showNextSteps(config) {
       )
     );
   }
-  console.log("3. Use with Claude:");
+  console.log("3. Install session commands for Claude Code:");
+  console.log(
+    chalk.gray(
+      "   stackmemory setup-commands  # Installs /start, /stop, /restart, /next\n"
+    )
+  );
+  console.log("4. Use with Claude:");
   console.log(chalk.gray("   claude-sm  # Or use stackmemory directly\n"));
-  console.log("4. Use with Codex:");
+  console.log("5. Use with Codex:");
   console.log(chalk.gray("   codex-sm   # Codex + StackMemory integration\n"));
   if (config.enableLinear) {
-    console.log("5. Sync with Linear:");
+    console.log("6. Sync with Linear:");
     console.log(chalk.gray("   stackmemory linear sync\n"));
   }
   console.log("For more help:");

package/dist/src/cli/commands/optimize.js

@@ -0,0 +1,117 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { TraceStore } from "../../core/trace/trace-store.js";
+import { TraceOptimizer } from "../../core/optimization/trace-optimizer.js";
+function createOptimizeCommand() {
+  const optimize = new Command("optimize").description(
+    "Offline optimizers for harnesses, traces, and prompts"
+  );
+  optimize.command("traces").description(
+    "Analyze stored traces and generate HALO-like offline optimizer recommendations"
+  ).option("-d, --days <n>", "Only analyze traces from the last N days", "30").option(
+    "-m, --min-occurrences <n>",
+    "Minimum repeated occurrences before surfacing a pattern",
+    "2"
+  ).option("--json", "Print machine-readable JSON").option(
+    "--no-write",
+    "Do not persist report files under .stackmemory/build"
+  ).action(async (options) => {
+    const projectRoot = process.cwd();
+    const dbPath = join(projectRoot, ".stackmemory", "context.db");
+    if (!existsSync(dbPath)) {
+      console.log(
+        chalk.red("StackMemory not initialized in this directory.")
+      );
+      console.log(chalk.gray('Run "stackmemory init" first.'));
+      return;
+    }
+    const db = new Database(dbPath);
+    try {
+      const traceStore = new TraceStore(db);
+      const optimizer = new TraceOptimizer(traceStore);
+      const report = optimizer.analyze({
+        lookbackDays: parseInt(options.days, 10) || 30,
+        minOccurrences: parseInt(options.minOccurrences, 10) || 2
+      });
+      const persisted = options.write ? optimizer.persistReport(projectRoot, report) : null;
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              ...report,
+              persisted
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(chalk.blue("\nTrace Optimizer Report\n"));
+      console.log(`Lookback window: ${report.lookbackDays} day(s)`);
+      console.log(`Traces analyzed: ${report.totalTracesAnalyzed}`);
+      console.log(`Traces with errors: ${report.tracesWithErrors}`);
+      console.log(`Causal traces: ${report.causalTraces}`);
+      console.log(
+        `Average tools/trace: ${report.averageToolsPerTrace.toFixed(2)}`
+      );
+      console.log(
+        `Average trace score: ${report.averageTraceScore.toFixed(2)}`
+      );
+      if (report.recommendations.length === 0) {
+        console.log(
+          chalk.yellow(
+            "\nNo repeated patterns crossed the threshold. Lower --min-occurrences or collect more traces."
+          )
+        );
+      } else {
+        console.log(chalk.blue("\nRecommendations:\n"));
+        for (const recommendation of report.recommendations) {
+          const badge = recommendation.priority === "high" ? chalk.red("[high]") : chalk.yellow("[medium]");
+          console.log(
+            `${badge} ${chalk.white(recommendation.title)} (${recommendation.confidence.toFixed(2)} confidence)`
+          );
+          console.log(`  ${recommendation.summary}`);
+          console.log(`  Targets: ${recommendation.targetAreas.join(", ")}`);
+          console.log(`  Actions: ${recommendation.actions.join(" | ")}`);
+          console.log(
+            `  Validate: ${recommendation.validations.join(" | ")}`
+          );
+          console.log("");
+        }
+      }
+      if (report.clusters.length > 0) {
+        console.log(chalk.blue("Detected clusters:\n"));
+        for (const cluster of report.clusters) {
+          console.log(
+            `- ${cluster.label} (${cluster.occurrences} traces, ${cluster.kind})`
+          );
+          if (cluster.toolPatterns.length > 0) {
+            console.log(`  Tools: ${cluster.toolPatterns.join(", ")}`);
+          }
+          if (cluster.sampleSummaries.length > 0) {
+            console.log(`  Examples: ${cluster.sampleSummaries.join(" | ")}`);
+          }
+        }
+        console.log("");
+      }
+      if (persisted) {
+        console.log(chalk.gray(`Saved JSON: ${persisted.jsonPath}`));
+        console.log(chalk.gray(`Saved Markdown: ${persisted.markdownPath}`));
+      }
+    } finally {
+      db.close();
+    }
+  });
+  return optimize;
+}
+export {
+  createOptimizeCommand
+};

package/dist/src/cli/commands/orchestrate.js

@@ -189,13 +189,13 @@ function progressBar(pct, width) {
   return `${col}${"\u2501".repeat(filled)}${c.d}${"\u254C".repeat(empty)}${c.r}`;
 }
 function scanAgentStatuses() {
-  const agentsDir2 = join(homedir(), ".stackmemory", "conductor", "agents");
-  if (!existsSync(agentsDir2)) return [];
-  const entries = readdirSync(agentsDir2, { withFileTypes: true });
+  const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
+  if (!existsSync(agentsDir)) return [];
+  const entries = readdirSync(agentsDir, { withFileTypes: true });
   const statuses = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const statusPath = join(agentsDir2, entry.name, "status.json");
+    const statusPath = join(agentsDir, entry.name, "status.json");
     if (!existsSync(statusPath)) continue;
     try {
       const data = JSON.parse(readFileSync(statusPath, "utf-8"));
@@ -953,6 +953,7 @@ function createConductorCommands() {
     console.log("");
   });
   cmd.command("finalize").description("Clean up completed/dead agents that conductor missed").option("--dry-run", "Show what would be done without doing it", false).action(async (options) => {
+    const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
     const statuses = scanAgentStatuses();
     const needsFinalize = statuses.map((s) => ({ ...s, ...enrichStatus(s) })).filter((s) => {
       return !s.alive || s.elapsed > STALE_FINALIZE_THRESHOLD_MS;
@@ -1038,6 +1039,221 @@ function createConductorCommands() {
       );
     }
   });
+  const isMerged = (repo, branch, lane) => {
+    try {
+      execSync(`git merge-base --is-ancestor "${branch}" "${lane}"`, {
+        cwd: repo,
+        stdio: "pipe",
+        timeout: 5e3
+      });
+      return true;
+    } catch (err) {
+      const status = err.status;
+      if (status !== 1) throw err;
+    }
+    try {
+      const out = execSync(`git cherry "${lane}" "${branch}"`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).trim();
+      if (!out) return true;
+      const lines = out.split("\n").filter(Boolean);
+      return lines.every((l) => l.startsWith("-"));
+    } catch {
+      return false;
+    }
+  };
+  const bucketLaneBranches = (repo, lane) => {
+    let all = [];
+    try {
+      all = execSync(`git branch --list 'worktree-agent-*'`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).split("\n").map((s) => s.trim().replace(/^[*+]\s*/, "")).filter(Boolean);
+    } catch {
+    }
+    const merged = [];
+    const unmerged = [];
+    for (const b of all) {
+      (isMerged(repo, b, lane) ? merged : unmerged).push(b);
+    }
+    return { merged, unmerged };
+  };
+  const getWorktreeCleanliness = (repo, wtPath) => {
+    try {
+      const out = execSync(`git -C "${wtPath}" status --short`, {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      return out.trim().length > 0 ? "dirty" : "clean";
+    } catch {
+      return "unknown";
+    }
+  };
+  const laneCmd = cmd.command("lane").description(
+    "Inspect or clean up worktree-agent-* branches against a lane"
+  );
+  laneCmd.command("status").description(
+    "List worktree-agent-* branches and their merge state vs the lane"
+  ).option(
+    "--lane <branch>",
+    "Lane branch to compare against (default: current branch)"
+  ).option("--repo <path>", "Git repo root", process.cwd()).action((options) => {
+    const repo = options.repo;
+    const lane = options.lane || execSync("git branch --show-current", {
+      cwd: repo,
+      encoding: "utf-8"
+    }).trim();
+    if (!lane) {
+      console.error(
+        `${c.red}Could not resolve lane branch.${c.r} Pass --lane.`
+      );
+      process.exit(1);
+    }
+    const { merged, unmerged } = bucketLaneBranches(repo, lane);
+    console.log(`
+  ${c.b}Lane:${c.r} ${c.cyan}${lane}${c.r}
+`);
+    if (merged.length) {
+      console.log(`  ${c.green}merged (${merged.length}):${c.r}`);
+      for (const b of merged) console.log(`    ${c.gray}\u2713${c.r} ${b}`);
+    }
+    if (unmerged.length) {
+      console.log(`
+  ${c.orange}unmerged (${unmerged.length}):${c.r}`);
+      for (const b of unmerged) console.log(`    ${c.orange}\u2022${c.r} ${b}`);
+    }
+    if (!merged.length && !unmerged.length) {
+      console.log(`  ${c.gray}No worktree-agent-* branches found.${c.r}`);
+    }
+  });
+  laneCmd.command("cleanup").description(
+    "Remove worktree-agent-* branches and worktrees already merged into the lane"
+  ).option(
+    "--lane <branch>",
+    "Lane branch to compare against (default: current branch)"
+  ).option("--repo <path>", "Git repo root", process.cwd()).option("--dry-run", "Show what would be removed without doing it", false).option(
+    "--force",
+    "Remove worktrees even if they have uncommitted changes",
+    false
+  ).action((options) => {
+    const repo = options.repo;
+    const lane = options.lane || execSync("git branch --show-current", {
+      cwd: repo,
+      encoding: "utf-8"
+    }).trim();
+    if (!lane) {
+      console.error(
+        `${c.red}Could not resolve lane branch.${c.r} Pass --lane.`
+      );
+      process.exit(1);
+    }
+    const { merged } = bucketLaneBranches(repo, lane);
+    if (merged.length === 0) {
+      console.log(
+        `${c.green}Nothing to clean up for lane ${c.cyan}${lane}${c.r}.`
+      );
+      return;
+    }
+    const worktreeMap = /* @__PURE__ */ new Map();
+    try {
+      const wt = execSync("git worktree list --porcelain", {
+        cwd: repo,
+        encoding: "utf-8",
+        timeout: 1e4
+      });
+      let currentPath = "";
+      for (const line of wt.split("\n")) {
+        if (line.startsWith("worktree ")) {
+          currentPath = line.slice("worktree ".length).trim();
+        } else if (line.startsWith("branch ")) {
+          const ref = line.slice("branch ".length).trim();
+          const b = ref.replace(/^refs\/heads\//, "");
+          if (currentPath) worktreeMap.set(b, currentPath);
+        }
+      }
+    } catch {
+    }
+    console.log(
+      `
+  ${c.b}Lane:${c.r} ${c.cyan}${lane}${c.r}  ${c.d}(${merged.length} merged branches)${c.r}
+`
+    );
+    let skippedDirty = 0;
+    let skippedUnknown = 0;
+    for (const branch of merged) {
+      const wtPath = worktreeMap.get(branch);
+      const cleanliness = wtPath ? getWorktreeCleanliness(repo, wtPath) : "unknown";
+      const dirty = cleanliness === "dirty";
+      if (dirty && !options.force) {
+        skippedDirty++;
+        console.log(
+          `  ${c.orange}\u26A0${c.r}  ${c.orange}dirty${c.r} ${wtPath} ${c.d}(skipping ${branch} \u2014 pass --force to remove)${c.r}`
+        );
+        continue;
+      }
+      if (wtPath && cleanliness === "unknown" && !options.force) {
+        skippedUnknown++;
+        console.log(
+          `  ${c.orange}\u26A0${c.r}  ${c.orange}unknown${c.r} ${wtPath} ${c.d}(skipping ${branch} \u2014 could not verify clean state; pass --force to remove)${c.r}`
+        );
+        continue;
+      }
+      const dirtyTag = dirty ? ` ${c.orange}[dirty]${c.r}` : "";
+      const unknownTag = cleanliness === "unknown" ? ` ${c.orange}[unknown]${c.r}` : "";
+      const action = wtPath ? `${c.gray}worktree remove${c.r} ${wtPath}${dirtyTag}${unknownTag} + ${c.gray}branch -D${c.r} ${branch}` : `${c.gray}branch -D${c.r} ${branch}`;
+      console.log(`  ${c.green}\u2713${c.r} ${action}`);
+      if (options.dryRun) continue;
+      if (wtPath) {
+        try {
+          execSync(`git worktree remove "${wtPath}" --force`, {
+            cwd: repo,
+            stdio: "pipe",
+            timeout: 15e3
+          });
+        } catch (err) {
+          console.log(
+            `     ${c.red}worktree remove failed:${c.r} ${err.message}`
+          );
+        }
+      }
+      try {
+        execSync(`git branch -D "${branch}"`, {
+          cwd: repo,
+          stdio: "pipe",
+          timeout: 5e3
+        });
+      } catch (err) {
+        console.log(
+          `     ${c.red}branch -D failed:${c.r} ${err.message}`
+        );
+      }
+    }
+    if (!options.dryRun) {
+      try {
+        execSync("git worktree prune", {
+          cwd: repo,
+          stdio: "pipe",
+          timeout: 1e4
+        });
+      } catch {
+      }
+      const skipNote = skippedDirty ? ` ${c.orange}(${skippedDirty} dirty skipped \u2014 pass --force)${c.r}` : "";
+      const unknownNote = skippedUnknown ? ` ${c.orange}(${skippedUnknown} unknown skipped \u2014 pass --force)${c.r}` : "";
+      console.log(`
+  ${c.green}Done.${c.r}${skipNote}${unknownNote}`);
+    } else {
+      const skipNote = skippedDirty ? ` ${c.orange}(${skippedDirty} dirty would be skipped \u2014 pass --force to include)${c.r}` : "";
+      const unknownNote = skippedUnknown ? ` ${c.orange}(${skippedUnknown} unknown would be skipped \u2014 pass --force to include)${c.r}` : "";
+      console.log(
+        `
+  ${c.d}Dry run \u2014 no changes made. Remove --dry-run to execute.${c.r}${skipNote}${unknownNote}`
+      );
+    }
+  });
   cmd.command("logs").description("Tail agent output log").argument("<issue-id>", "Issue identifier (e.g., STA-499)").option("-f, --follow", "Follow the log (tail -f)", false).option("-n, --lines <n>", "Number of lines to show", "50").action(async (issueId, options) => {
     const logPath = join(getAgentStatusDir(issueId), "output.log");
     if (!existsSync(logPath)) {
@@ -1521,6 +1737,13 @@ function createConductorCommands() {
   ).option(
     "--no-pr",
     "Disable automatic GitHub PR creation after agent success"
+  ).option(
+    "--workspace-mode <mode>",
+    'Workspace mode: "auto" (detect GitButler), "gitbutler", or "worktree"',
+    "auto"
+  ).option(
+    "--lane <branch>",
+    "Optional lane branch. When set, conductor uses git worktrees rooted at the lane as worktree-agent-<id> and suppresses PRs (lane is human-curated)."
   ).action(async (options) => {
     ensureDefaultPromptTemplate();
     const conductor = new Conductor({
@@ -1537,7 +1760,9 @@ function createConductorCommands() {
       turnTimeoutMs: parseInt(options.turnTimeout, 10),
       agentMode: options.mode === "adapter" ? "adapter" : "cli",
       model: options.model,
-      autoPR: options.pr
+      autoPR: options.lane ? false : options.pr,
+      workspaceMode: options.workspaceMode,
+      laneBranch: options.lane
     });
     await conductor.start();
   });