chainlesschain 0.162.162 → 0.162.164

package/src/commands/review.js

@@ -34,7 +34,11 @@ import path from "node:path";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { firstBalancedJson } from "../lib/json-schema-output.js";
-import { dedupeFindings } from "../lib/review-pipeline.js";
+import {
+  dedupeFindings,
+  buildReviewReport,
+  findingKey,
+} from "../lib/review-pipeline.js";
 
 /** Diffs larger than this are truncated before going to the model. */
 const MAX_DIFF_CHARS = 200_000;
@@ -121,6 +125,32 @@ export function normalizeEffort(value) {
   return v;
 }
 
+/**
+ * Decide whether the multi-finder fan-out and its skeptic verifier pass run.
+ * Explicit flags always win; otherwise the top effort tier (`high`) auto-enables
+ * BOTH — a "high" review IS the thorough, verified pass — while low/medium stay
+ * single-pass (byte-identical default). `--single` forces single-pass even at
+ * high effort. Verify only ever runs with multi. Pure.
+ *
+ * @param {{multi?, verify?, effort?, single?}} opts  Commander-shaped (undefined = unset)
+ * @returns {{multi:boolean, verify:boolean, auto:boolean}}  auto = enabled by effort
+ */
+export function resolveMultiVerify({ multi, verify, effort, single } = {}) {
+  const highEffort = normalizeEffort(effort) === "high";
+  let multiOn;
+  if (single === true) multiOn = false;
+  else if (multi === true) multiOn = true;
+  else if (multi === false) multiOn = false;
+  else multiOn = highEffort; // unset → auto-enable at high effort
+  const verifyOn =
+    verify === true ? true : verify === false ? false : multiOn && highEffort;
+  return {
+    multi: multiOn,
+    verify: multiOn && verifyOn,
+    auto: multi == null && single !== true && multiOn,
+  };
+}
+
 /** Resolve the review lens from flags. Pure. */
 export function resolveReviewMode({ security, simplify } = {}) {
   if (security && simplify) {
@@ -585,8 +615,280 @@ export async function runReviewComment(options = {}, deps = {}) {
   };
 }
 
+// ── multi-agent fan-out (opt-in `--multi`) ──────────────────────────────────
+// A high-confidence review runs one focused FINDER per dimension, then dedupes
+// and ranks their findings into a single structured report — instead of the
+// default single agent that hunts everything at once. Each finder is blind to
+// the others; overlapping findings merge (union categories, keep max severity).
+
+/** The review dimensions fanned out, one finder agent each. */
+export const REVIEW_DIMENSIONS = Object.freeze([
+  {
+    key: "correctness",
+    label: "correctness",
+    hint: "logic errors, off-by-one, null/undefined, wrong API usage, unhandled errors, race conditions",
+  },
+  {
+    key: "security",
+    label: "security",
+    hint: "injection, auth/authz gaps, secrets, path traversal, SSRF, unsafe deserialization, missing input validation",
+  },
+  {
+    key: "performance",
+    label: "performance",
+    hint: "N+1 queries, unbounded loops, sync IO on hot paths, memory leaks, needless allocations/copies",
+  },
+  {
+    key: "tests",
+    label: "test coverage",
+    hint: "untested branches, missing edge cases, weak assertions, changed behavior lacking a test",
+  },
+]);
+
+const JSON_FINDINGS_CONTRACT =
+  'Output ONLY a JSON array (no prose, no fences). Each element: {"path":"file","line":12,"severity":"Critical|High|Medium|Low|Note","title":"one-line issue","body":"why it is a bug and how to fix"}. Output [] if you find nothing.';
+
+/** Build a single dimension finder's prompt from the shared diff context. Pure. */
+export function buildDimensionPrompt(ctx = {}, dim = {}) {
+  const {
+    diff = "",
+    summary = "",
+    label = "",
+    untrackedBlocks = [],
+    truncated = false,
+  } = ctx;
+  return [
+    `You are a ${dim.label} code reviewer. Report ONLY ${dim.label} issues: ${dim.hint}.`,
+    `Review this diff (${label}). ${summary}`,
+    truncated ? "(diff truncated — review what is shown)" : "",
+    "```diff",
+    diff,
+    "```",
+    ...(untrackedBlocks && untrackedBlocks.length
+      ? ["", "New untracked files:", ...untrackedBlocks]
+      : []),
+    "",
+    JSON_FINDINGS_CONTRACT,
+  ]
+    .filter((l) => l !== "")
+    .join("\n");
+}
+
+/** Render a structured review report to markdown. Pure. */
+export function renderMultiFinderReport(report = {}, byDimension = {}) {
+  const findings = report.findings || [];
+  const summary = report.summary || { total: 0, bySeverity: {} };
+  const sevOrder = ["Critical", "High", "Medium", "Low", "Note"];
+  const lines = [];
+  lines.push(`# Multi-agent review — ${summary.total} finding(s)`);
+  lines.push("");
+  lines.push(
+    sevOrder.map((s) => `${s}: ${summary.bySeverity?.[s] || 0}`).join("  ·  "),
+  );
+  const dimLine = Object.entries(byDimension)
+    .map(([k, v]) => `${k} ${v}`)
+    .join("  ·  ");
+  if (dimLine) lines.push(`By dimension: ${dimLine}`);
+  lines.push("");
+  for (const f of findings) {
+    lines.push(
+      `## [${f.severity}] ${f.path}:${f.line}${f.category ? ` (${f.category})` : ""}`,
+    );
+    if (f.failure_scenario) lines.push(f.failure_scenario);
+    if (f.evidence) lines.push(`> ${f.evidence}`);
+    lines.push("");
+  }
+  if (findings.length === 0) lines.push("No findings.");
+  return lines.join("\n") + "\n";
+}
+
+/** Build a skeptic verifier's prompt for one finding. Pure. */
+export function buildVerifierPrompt(f = {}) {
+  return [
+    "You are a SKEPTICAL code reviewer. Independently verify the finding below by reading the actual code with your tools. Assume it is WRONG until you can reproduce it; default to REFUTED if you cannot.",
+    `Finding: [${f.severity}] ${f.path}:${f.line}`,
+    f.title ? `Claim: ${f.title}` : "",
+    f.evidence || f.failureScenario
+      ? `Details: ${f.evidence || f.failureScenario}`
+      : "",
+    "",
+    'Reply with ONLY a JSON object (no prose): {"reproduced": true|false, "confidence": 0.0-1.0, "reason": "one line"}. Set reproduced=true ONLY if the defect is real and reachable.',
+  ]
+    .filter((l) => l !== "")
+    .join("\n");
+}
+
+/** Parse a verifier reply into an applyVerdicts verdict. Pure; null if unparseable. */
+export function parseVerdict(text) {
+  const balanced = firstBalancedJson(String(text || ""), "{");
+  if (!balanced) return null;
+  let obj;
+  try {
+    obj = JSON.parse(balanced);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const reproduced = obj.reproduced === true || obj.verified === true;
+  const conf = Number(obj.confidence);
+  return {
+    verified: reproduced,
+    ...(Number.isFinite(conf) ? { confidence: conf } : {}),
+    ...(obj.reason ? { note: String(obj.reason) } : {}),
+  };
+}
+
 /**
- * Core review run — collects the diff and dispatches one headless agent turn.
+ * Run one skeptic verifier agent per (already-deduped) finding and collect a
+ * verdicts map keyed by findingKey. A verifier that throws/parses to nothing
+ * leaves the finding unverified (kept as-is). Deps: { runAgentHeadless }.
+ */
+export async function runVerifierPass(findings, ctx = {}, deps = {}) {
+  const run =
+    deps.runAgentHeadless ||
+    (await import("../runtime/headless-runner.js")).runAgentHeadless;
+  const writeErr = ctx.writeErr || (() => {});
+  const verdicts = {};
+  for (const f of findings || []) {
+    let captured = "";
+    let outcome;
+    try {
+      outcome = await run(
+        {
+          ...(ctx.baseOptions || {}),
+          prompt: buildVerifierPrompt(f),
+          outputFormat: "text",
+        },
+        {
+          writeOut: (s) => {
+            captured += s;
+          },
+          writeErr,
+        },
+      );
+    } catch (e) {
+      writeErr(
+        `review --verify: verifier failed for ${f.path}:${f.line}: ${e.message}\n`,
+      );
+      continue;
+    }
+    const text = String(outcome?.result ?? captured ?? "");
+    const v = parseVerdict(text);
+    if (v) verdicts[findingKey(f)] = v;
+  }
+  return verdicts;
+}
+
+/**
+ * Fan out one finder agent per review dimension, capture each finder's JSON
+ * findings, and dedupe/rank them into a structured report. With `ctx.verify`, a
+ * skeptic verifier agent then independently reproduces each finding and REFUTED
+ * ones are dropped. Each agent runs a captured headless turn (its raw output
+ * never hits stdout — only the final report does).
+ * Deps: { runAgentHeadless, dimensions }.
+ */
+export async function runMultiFinderReview(ctx = {}, deps = {}) {
+  const run =
+    deps.runAgentHeadless ||
+    (await import("../runtime/headless-runner.js")).runAgentHeadless;
+  const dimensions = deps.dimensions || REVIEW_DIMENSIONS;
+  const writeOut = ctx.writeOut || ((s) => process.stdout.write(s));
+  const writeErr = ctx.writeErr || ((s) => process.stderr.write(s));
+
+  const all = [];
+  const byDimension = {};
+  for (const dim of dimensions) {
+    let captured = "";
+    let outcome;
+    try {
+      outcome = await run(
+        {
+          ...(ctx.baseOptions || {}),
+          prompt: buildDimensionPrompt(ctx, dim),
+          outputFormat: "text",
+        },
+        {
+          writeOut: (s) => {
+            captured += s;
+          },
+          writeErr,
+        },
+      );
+    } catch (e) {
+      writeErr(`review --multi: ${dim.key} finder failed: ${e.message}\n`);
+      byDimension[dim.key] = 0;
+      continue;
+    }
+    const text =
+      String(outcome?.result ?? captured ?? "").trim() || captured.trim();
+    // Carry title into `failureScenario` (the one-line issue) and body into
+    // `evidence` so the structured report keeps them; `title` stays on the
+    // object so cross-dimension dedup keys on path:line:title.
+    const found = parseFindings(text).map((f) => ({
+      path: f.path,
+      line: f.line,
+      severity: f.severity,
+      title: f.title,
+      category: dim.key,
+      failureScenario: f.title || f.body || "",
+      evidence: f.body || "",
+    }));
+    byDimension[dim.key] = found.length;
+    all.push(...found);
+  }
+
+  // Optional skeptic pass: verify each unique finding; refuted ones are dropped
+  // by buildReviewReport via applyVerdicts. Verify the DEDUPED set so a finding
+  // reported by several finders is only checked once.
+  let verdicts = {};
+  let verifiedCount = null;
+  if (ctx.verify) {
+    const unique = dedupeFindings(all);
+    verdicts = await runVerifierPass(unique, ctx, deps);
+    verifiedCount = Object.values(verdicts).filter((v) => v.verified).length;
+  }
+
+  // P1-1: read each referenced file's current content so every finding's output
+  // carries a re-anchorable comment anchor (file + base hash + line + context),
+  // not just a bare line number — an IDE diff review can then relocate or stale
+  // the comment after the agent's fix instead of reusing a dead coordinate.
+  // Best-effort: an unreadable path is simply skipped (no anchor for it).
+  const reviewCwd = ctx.baseOptions?.cwd || process.cwd();
+  const readFile = deps.readFileSync || fs.readFileSync;
+  const fileContents = new Map();
+  for (const p of new Set(all.map((f) => f && f.path).filter(Boolean))) {
+    try {
+      fileContents.set(p, readFile(path.resolve(reviewCwd, p), "utf-8"));
+    } catch {
+      /* file gone / binary / outside tree — no anchor, never fail the review */
+    }
+  }
+
+  const report = buildReviewReport(all, { verdicts, fileContents });
+  const meta = {
+    byDimension,
+    ...(ctx.verify ? { verified: verifiedCount } : {}),
+  };
+  if (ctx.outputFormat === "json") {
+    writeOut(`${JSON.stringify({ ...report, ...meta }, null, 2)}\n`);
+  } else {
+    writeOut(renderMultiFinderReport(report, byDimension));
+  }
+  return {
+    exitCode: 0,
+    isError: false,
+    scope: ctx.scope,
+    empty: false,
+    multi: true,
+    report,
+    byDimension,
+    ...(ctx.verify ? { verified: verifiedCount } : {}),
+  };
+}
+
+/**
+ * Core review run — collects the diff and dispatches one headless agent turn
+ * (or, with `--multi`, one finder agent per dimension merged into a report).
  * Deps are injected for tests (git / runAgentHeadless / config helpers).
  *
  * @returns {Promise<{exitCode:number, isError:boolean, scope:string, empty?:boolean}>}
@@ -657,6 +959,53 @@ export async function runReview(options = {}, deps = {}) {
     // fall back to runner defaults
   }
 
+  // --multi: fan out one finder per dimension and merge into a structured
+  // report. Opt-in — or auto-enabled at high effort (a "high" review IS the
+  // thorough, verified pass). The default single-pass path below is
+  // byte-identical for low/medium effort with no flags.
+  const {
+    multi: useMulti,
+    verify: useVerify,
+    auto,
+  } = resolveMultiVerify({
+    multi: options.multi,
+    verify: options.verify,
+    effort: options.effort,
+    single: options.single,
+  });
+  if (useMulti) {
+    if (auto && deps.writeErr) {
+      deps.writeErr(
+        `high-effort review: multi-finder fan-out${useVerify ? " + verifier" : ""} auto-enabled (use --single to force single-pass)\n`,
+      );
+    }
+    return runMultiFinderReview(
+      {
+        diff: hasDiff ? diff : "(no tracked changes)",
+        summary,
+        label,
+        scope,
+        untrackedBlocks: untracked.blocks,
+        truncated,
+        verify: useVerify,
+        outputFormat: options.outputFormat || "text",
+        writeOut: deps.writeOut,
+        writeErr: deps.writeErr,
+        baseOptions: {
+          model: options.model,
+          provider: options.provider,
+          baseUrl: options.baseUrl,
+          apiKey: options.apiKey,
+          cwd,
+          permissionMode: "plan",
+          expandFileRefs: false,
+          maxTurns: Number.isFinite(options.maxTurns) ? options.maxTurns : 20,
+        },
+      },
+      deps,
+    );
+  }
+
   // review-only → plan mode (clamped to read-only tools, cannot mutate).
   // --fix     → acceptEdits + auto-checkpoint (reversible edits).
   const permissionMode = fix ? "acceptEdits" : "plan";
@@ -725,6 +1074,18 @@ export function registerReviewCommand(program) {
       "--dry-run",
       "With --comment: show what would be posted without posting",
     )
+    .option(
+      "--multi",
+      "Fan out one finder agent per dimension (correctness/security/performance/tests) and merge into a structured report",
+    )
+    .option(
+      "--verify",
+      "With --multi: run a skeptic verifier agent per finding and drop the ones it cannot reproduce",
+    )
+    .option(
+      "--single",
+      "Force a single-pass review even at high effort (disables the multi-finder auto-enable)",
+    )
     .option("--json", "Emit the agent result envelope as JSON")
     .action(async (effortArg, options) => {
       try {

package/src/commands/session.js

@@ -9,6 +9,7 @@ import path from "path";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
+import { scanSecrets, redactSecrets } from "../lib/secret-scan.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   listSessions,
@@ -75,6 +76,97 @@ function _sessionEpoch(ts) {
   return Number.isFinite(n) ? n : 0;
 }
 
+/**
+ * Render a PR's automation status (P1-4 "PR/CI Monitor + 受控合并") from a
+ * gathered signals object — PURE, so it is testable without gh / the network.
+ * `enabled` mirrors the "auto-merge is OFF by default" rule: only an explicit
+ * opt-in even considers a merge. Everything else defers to the fail-closed
+ * pr-automation-policy decision engine.
+ *
+ * @param {object} signals  {branch, prNumber, hasOpenPr, headCommitSha,
+ *   branchProtectionSatisfied, reviewApproved, pendingApprovals,
+ *   requiredChecks, checks}
+ * @param {{enabled?:boolean}} [opts]
+ * @returns {{statusBar:string, autoMerge:{allow:boolean,reason:string,unmet:string[]}, lines:string[]}}
+ */
+export async function renderPrStatus(signals = {}, opts = {}) {
+  const { autoMergeDecision, describePrStatusBar } =
+    await import("../lib/pr-automation-policy.js");
+  const autoMerge = autoMergeDecision({
+    enabled: opts.enabled === true,
+    hasOpenPr: signals.hasOpenPr,
+    branchProtectionSatisfied: signals.branchProtectionSatisfied,
+    reviewApproved: signals.reviewApproved,
+    pendingApprovals: signals.pendingApprovals,
+    requiredChecks: signals.requiredChecks,
+    checks: signals.checks,
+  });
+  const statusBar = describePrStatusBar({
+    branch: signals.branch,
+    prNumber: signals.prNumber,
+    checks: signals.checks,
+    reviewApproved: signals.reviewApproved,
+    mergeable: autoMerge.allow,
+  });
+  const lines = [statusBar];
+  if (autoMerge.allow) {
+    lines.push("auto-merge: ✓ eligible");
+  } else {
+    lines.push(`auto-merge: ✗ blocked (${autoMerge.unmet.join(", ")})`);
+  }
+  return { statusBar, autoMerge, lines };
+}
+
+/**
+ * Best-effort map of `gh pr view --json …` output to the pr-automation signals.
+ * PURE (json → json); the command supplies the gh JSON (or a --checks-file). A
+ * missing field stays undefined so the fail-closed policy denies rather than
+ * assuming.
+ */
+export function mapGhPrToSignals(gh = {}) {
+  const rollup = Array.isArray(gh.statusCheckRollup)
+    ? gh.statusCheckRollup
+    : [];
+  return {
+    branch: gh.headRefName || undefined,
+    prNumber: gh.number,
+    hasOpenPr: String(gh.state || "").toUpperCase() === "OPEN",
+    headCommitSha: gh.headRefOid || undefined,
+    reviewApproved: gh.reviewDecision === "APPROVED",
+    // gh doesn't expose branch-protection satisfaction or pending in-app
+    // approvals here; leave them undefined → fail-closed unless a --checks-file
+    // asserts them.
+    checks: rollup.map((c) => ({
+      name: c.name || c.context,
+      // check runs use `conclusion`; legacy statuses use `state`.
+      state: c.conclusion || c.state || c.status,
+    })),
+  };
+}
+
+/**
+ * Best-effort live fetch of a PR's signals via `gh pr view --json`. Returns the
+ * mapped signals, or throws (caller degrades to a "pass --checks-file" hint).
+ * 8s timeout, stderr suppressed — a missing / unauthenticated gh just fails.
+ */
+async function fetchPrSignalsViaGh(target) {
+  const { execFileSync } = await import("node:child_process");
+  const args = [
+    "pr",
+    "view",
+    String(target.number),
+    "--json",
+    "number,state,headRefName,headRefOid,reviewDecision,statusCheckRollup",
+  ];
+  if (target.repo) args.push("--repo", String(target.repo));
+  const out = execFileSync("gh", args, {
+    encoding: "utf-8",
+    timeout: 8000,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return mapGhPrToSignals(JSON.parse(out));
+}
+
 export function rankSessions(sessions, limit) {
   // Dedup by id, preferring the JSONL copy when a session exists in both stores
   // (the original "JSONL takes precedence" intent, previously achieved only as
@@ -254,6 +346,87 @@ export function registerSessionCommand(program) {
       }
     });
 
+  // session pr-status — PR/CI monitor + controlled auto-merge decision (P1-4)
+  // for a session's linked PR. Offline-testable via --checks-file; otherwise a
+  // best-effort `gh pr view` fetch for the session's newest linked PR.
+  session
+    .command("pr-status")
+    .description(
+      "PR/CI monitor + controlled auto-merge decision for a session's linked PR",
+    )
+    .argument("[id]", "Session id (default: most recent)")
+    .option("--pr <number>", "Which linked PR to assess (default: newest)")
+    .option(
+      "--checks-file <path>",
+      "JSON file of PR signals {branch,prNumber,hasOpenPr,branchProtectionSatisfied,reviewApproved,pendingApprovals,requiredChecks,checks} — bypasses gh",
+    )
+    .option("--enable", "Consider auto-merge eligibility (default: off)")
+    .option("--json", "Output as machine-readable JSON")
+    .action(async (id, options) => {
+      try {
+        let signals = null;
+        let source = "";
+        if (options.checksFile) {
+          // Offline / explicit path: the caller supplies the PR signals.
+          signals = JSON.parse(fs.readFileSync(options.checksFile, "utf-8"));
+          source = options.checksFile;
+        } else {
+          // Live path: resolve the session's linked PR and fetch via gh.
+          const { getPrLinks } = await import("../lib/pr-link-ledger.js");
+          const { getLastSessionId } =
+            await import("../harness/jsonl-session-store.js");
+          const sid = !id || id === "last" ? getLastSessionId() : id;
+          const links = sid ? getPrLinks(sid) : [];
+          if (links.length === 0) {
+            logger.error(
+              "No linked PRs for this session — pass --checks-file to assess a PR directly.",
+            );
+            process.exit(1);
+          }
+          let target;
+          if (options.pr) {
+            target = links.find((l) => String(l.number) === String(options.pr));
+            if (!target) {
+              logger.error(`Session has no linked PR #${options.pr}.`);
+              process.exit(1);
+            }
+          } else {
+            // Newest by updatedAt (epoch-normalized; unknowns sort last).
+            target = links
+              .slice()
+              .sort(
+                (a, b) =>
+                  (Date.parse(b.updatedAt) || 0) -
+                  (Date.parse(a.updatedAt) || 0),
+              )[0];
+          }
+          signals = await fetchPrSignalsViaGh(target).catch(() => null);
+          if (!signals) {
+            logger.error(
+              `Could not fetch PR #${target.number} via gh — authenticate gh or pass --checks-file.`,
+            );
+            process.exit(1);
+          }
+          source = `gh:${target.repo || "?"}#${target.number}`;
+        }
+
+        const result = await renderPrStatus(signals, {
+          enabled: options.enable === true,
+        });
+        if (options.json) {
+          console.log(JSON.stringify({ source, ...result }, null, 2));
+        } else {
+          logger.log(
+            chalk.bold("PR automation status") + chalk.gray(`  (${source})`),
+          );
+          for (const line of result.lines) logger.log(`  ${line}`);
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // session resume
   session
     .command("resume")
@@ -368,6 +541,10 @@ export function registerSessionCommand(program) {
       "Session ID (or prefix; `last` = most recent agent session)",
     )
     .option("-o, --output <file>", "Output file path")
+    .option(
+      "--no-redact",
+      "Do NOT redact detected secrets from the exported transcript (default: redact)",
+    )
     .action(async (id, options) => {
       try {
         let markdown = null;
@@ -406,6 +583,20 @@ export function registerSessionCommand(program) {
           process.exit(1);
         }
 
+        // §8.1 export gate: a transcript can carry provider tokens, JWTs,
+        // connection strings or cookies (in tool commands / results). Redact by
+        // default — an export leaves the machine and must fail toward "no leak".
+        // `--no-redact` keeps raw values for the user's own trusted backup.
+        if (options.redact !== false) {
+          const findings = scanSecrets(markdown);
+          if (findings.length > 0) {
+            markdown = redactSecrets(markdown);
+            logger.warn(
+              `Redacted ${findings.length} secret${findings.length === 1 ? "" : "s"} from the export (use --no-redact to keep raw values).`,
+            );
+          }
+        }
+
         if (options.output) {
           fs.writeFileSync(options.output, markdown, "utf8");
           logger.success(`Exported to ${chalk.cyan(options.output)}`);

package/src/commands/team.js

@@ -215,6 +215,14 @@ export function registerTeamCommand(program, { logger } = {}) {
       "--merge",
       "With --worktree: merge each clean branch back to base (conflicts reported, not forced)",
     )
+    .option(
+      "--sparse-paths <paths>",
+      "With --worktree: comma-separated packages to sparse-checkout (only these are materialized)",
+    )
+    .option(
+      "--symlink-dirs <dirs>",
+      "With --worktree: comma-separated approved dependency dirs to symlink from the main checkout (e.g. node_modules)",
+    )
     .option("--max-tasks <n>", "Budget: total task executions across the team")
     .option("--max-tokens <n>", "Budget: total LLM tokens across the team")
     .option(
@@ -348,7 +356,17 @@ export function registerTeamCommand(program, { logger } = {}) {
       let runTask;
       let coord = null;
       if (options.worktree) {
-        coord = new TeamWorktreeCoordinator(process.cwd());
+        const splitList = (v) =>
+          v
+            ? String(v)
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)
+            : null;
+        coord = new TeamWorktreeCoordinator(process.cwd(), {
+          sparsePaths: splitList(options.sparsePaths),
+          symlinkDirectories: splitList(options.symlinkDirs),
+        });
         if (!coord.isGitRepo()) {
           (log.error || console.error)(
             "--worktree requires a git repository (run inside one)",