oh-my-opencode 5.0.0-beta.17 → 5.0.0-beta.18

package/dist/cli/index.js

@@ -54,7 +54,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "oh-my-opencode",
-    version: "5.0.0-beta.17",
+    version: "5.0.0-beta.18",
     description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
     main: "./dist/index.js",
     types: "dist/index.d.ts",
@@ -235,7 +235,7 @@ var init_package = __esm(() => {
       zod: "^4.4.3"
     },
     devDependencies: {
-      "@code-yeongyu/senpi": "2026.8.22-2",
+      "@code-yeongyu/senpi": "2026.8.23",
       "@oh-my-opencode/agents-md-core": "workspace:*",
       "@oh-my-opencode/ast-grep-mcp": "workspace:*",
       "@oh-my-opencode/boulder-state": "workspace:*",
@@ -276,18 +276,18 @@ var init_package = __esm(() => {
       typescript: "^7.0.2"
     },
     optionalDependencies: {
-      "oh-my-opencode-darwin-arm64": "5.0.0-beta.17",
-      "oh-my-opencode-darwin-x64": "5.0.0-beta.17",
-      "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.17",
-      "oh-my-opencode-linux-arm64": "5.0.0-beta.17",
-      "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.17",
-      "oh-my-opencode-linux-x64": "5.0.0-beta.17",
-      "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.17",
-      "oh-my-opencode-linux-x64-musl": "5.0.0-beta.17",
-      "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.17",
-      "oh-my-opencode-windows-arm64": "5.0.0-beta.17",
-      "oh-my-opencode-windows-x64": "5.0.0-beta.17",
-      "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.17"
+      "oh-my-opencode-darwin-arm64": "5.0.0-beta.18",
+      "oh-my-opencode-darwin-x64": "5.0.0-beta.18",
+      "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.18",
+      "oh-my-opencode-linux-arm64": "5.0.0-beta.18",
+      "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.18",
+      "oh-my-opencode-linux-x64": "5.0.0-beta.18",
+      "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.18",
+      "oh-my-opencode-linux-x64-musl": "5.0.0-beta.18",
+      "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.18",
+      "oh-my-opencode-windows-arm64": "5.0.0-beta.18",
+      "oh-my-opencode-windows-x64": "5.0.0-beta.18",
+      "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.18"
     },
     overrides: {
       "@earendil-works/pi-agent-core": "0.84.2",
@@ -94330,7 +94330,7 @@ var package_default2;
 var init_package2 = __esm(() => {
   package_default2 = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.0.0-beta.17",
+    version: "5.0.0-beta.18",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -103302,7 +103302,7 @@ function localLauncherCmdPath(homeDir = homedir10()) {
 }
 function renderLocalLauncher(options) {
   const brand = {
-    name: "omo",
+    name: "OmO",
     displayVersion: options.version ?? "local",
     configDir: ".omo",
     flatLayout: false,
@@ -113922,6 +113922,333 @@ async function refreshModelCapabilities(options, deps = {}) {
   }
 }
 
+// packages/omo-opencode/src/cli/worktree-sweep/classify.ts
+import path15 from "path";
+var DEFAULT_EXCLUDE_PREFIXES = [
+  "~/.codex/worktrees",
+  "~/.codex-gui-cli-remote/worktrees"
+];
+function expandHome(value, home) {
+  if (value === "~")
+    return home;
+  if (value.startsWith("~/"))
+    return path15.join(home, value.slice(2));
+  return value;
+}
+function isExcludedPath(worktreePath, prefixes, home) {
+  const target = path15.resolve(expandHome(worktreePath, home));
+  return prefixes.some((prefix) => {
+    const resolved = path15.resolve(expandHome(prefix, home));
+    return target === resolved || target.startsWith(`${resolved}${path15.sep}`);
+  });
+}
+function worktreeRef(record3) {
+  return record3.branch ?? record3.head ?? "";
+}
+function classifyWorktree(input) {
+  const { record: record3 } = input;
+  const ref = worktreeRef(record3);
+  if (record3.locked)
+    return { path: record3.path, ref, decision: "KEEP", reason: "locked" };
+  if (!input.pathExists)
+    return { path: record3.path, ref, decision: "PRUNE" };
+  if (input.external)
+    return { path: record3.path, ref, decision: "KEEP", reason: "external" };
+  if (!input.merged && !input.agedOut) {
+    return { path: record3.path, ref, decision: "KEEP", reason: "unmerged" };
+  }
+  if (input.dirty)
+    return { path: record3.path, ref, decision: "KEEP", reason: "dirty" };
+  return { path: record3.path, ref, decision: "SWEEP" };
+}
+// packages/omo-opencode/src/cli/worktree-sweep/format.ts
+function formatClassification(classification) {
+  const head = classification.decision === "KEEP" && classification.reason !== undefined ? `KEEP(${classification.reason})` : classification.decision;
+  return classification.ref.length > 0 ? `${head} ${classification.path} ${classification.ref}` : `${head} ${classification.path}`;
+}
+function formatSummary(result) {
+  const mode = result.apply ? "apply" : "dry-run";
+  const removed2 = result.repos.reduce((total, repo) => total + repo.removed.length, 0);
+  const failed = result.repos.reduce((total, repo) => total + repo.failed.length, 0);
+  return `SUMMARY mode=${mode} repos=${result.repos.length} sweep=${result.sweepCount} keep=${result.keepCount} prune=${result.pruneCount} removed=${removed2} failed=${failed}`;
+}
+function formatResult(result) {
+  const lines = [];
+  for (const repo of result.repos) {
+    lines.push(`REPO ${repo.repo} default=${repo.defaultBranch}`);
+    for (const classification of repo.classifications) {
+      lines.push(formatClassification(classification));
+    }
+    for (const failure of repo.failed) {
+      lines.push(`FAILED ${failure.path} ${failure.error}`);
+    }
+  }
+  lines.push(formatSummary(result));
+  return lines;
+}
+// packages/omo-opencode/src/cli/worktree-sweep/options.ts
+function parseOlderThanDays(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || !Number.isInteger(parsed)) {
+    throw new Error(`--older-than must be a non-negative integer number of days, got: ${value}`);
+  }
+  return parsed;
+}
+// packages/omo-opencode/src/cli/worktree-sweep/parse-worktree-list.ts
+import { normalize } from "path";
+function emptyRecord() {
+  return { detached: false, locked: false, prunable: false };
+}
+function finalize2(record3) {
+  if (record3.path === undefined || record3.path.length === 0)
+    return;
+  return {
+    path: normalize(record3.path),
+    ...record3.head === undefined ? {} : { head: record3.head },
+    ...record3.branch === undefined ? {} : { branch: record3.branch },
+    detached: record3.detached,
+    locked: record3.locked,
+    ...record3.lockReason === undefined ? {} : { lockReason: record3.lockReason },
+    prunable: record3.prunable
+  };
+}
+function applyLine(record3, line) {
+  if (line.startsWith("worktree ")) {
+    record3.path = line.slice("worktree ".length);
+    return;
+  }
+  if (line.startsWith("HEAD ")) {
+    record3.head = line.slice("HEAD ".length);
+    return;
+  }
+  if (line.startsWith("branch ")) {
+    record3.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+    return;
+  }
+  if (line === "detached") {
+    record3.detached = true;
+    return;
+  }
+  if (line === "locked" || line.startsWith("locked ")) {
+    record3.locked = true;
+    const reason = line.slice("locked".length).trim();
+    if (reason.length > 0)
+      record3.lockReason = reason;
+    return;
+  }
+  if (line === "prunable" || line.startsWith("prunable ")) {
+    record3.prunable = true;
+  }
+}
+function parseWorktreeList(porcelain) {
+  const records = [];
+  let current = emptyRecord();
+  for (const rawLine of porcelain.split(`
+`)) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.length === 0) {
+      const finalized = finalize2(current);
+      if (finalized)
+        records.push(finalized);
+      current = emptyRecord();
+      continue;
+    }
+    applyLine(current, line);
+  }
+  const trailing = finalize2(current);
+  if (trailing)
+    records.push(trailing);
+  return records;
+}
+function linkedWorktrees(records) {
+  return records.slice(1);
+}
+// packages/omo-opencode/src/cli/worktree-sweep/sweep.ts
+import { existsSync as existsSync66 } from "fs";
+import { stat as stat8 } from "fs/promises";
+import os7 from "os";
+import { normalize as normalize2 } from "path";
+
+// packages/omo-opencode/src/cli/worktree-sweep/git.ts
+init_runtime();
+async function runGit(cwd, args) {
+  const child = spawn({ cmd: ["git", "-C", cwd, ...args], stdout: "pipe", stderr: "pipe" });
+  const [code, stdout2, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text()
+  ]);
+  return { code, stdout: stdout2, stderr };
+}
+async function listWorktreesPorcelain(repo) {
+  const result = await runGit(repo, ["worktree", "list", "--porcelain"]);
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || `git worktree list failed in ${repo}`);
+  }
+  return result.stdout;
+}
+async function detectDefaultBranch(repo) {
+  const symbolic = await runGit(repo, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (symbolic.code === 0) {
+    const value = symbolic.stdout.trim();
+    if (value.length > 0)
+      return value.replace(/^[^/]*\//, "");
+  }
+  const local = await runGit(repo, [
+    "branch",
+    "--list",
+    "main",
+    "master",
+    "--format=%(refname:short)"
+  ]);
+  if (local.code === 0) {
+    for (const candidate2 of ["main", "master"]) {
+      if (local.stdout.split(`
+`).map((line) => line.trim()).includes(candidate2)) {
+        return candidate2;
+      }
+    }
+  }
+  return;
+}
+async function isMerged(repo, ref, defaultBranch) {
+  if (ref.length === 0)
+    return false;
+  const result = await runGit(repo, ["merge-base", "--is-ancestor", ref, defaultBranch]);
+  return result.code === 0;
+}
+async function isDirty(worktreePath) {
+  const result = await runGit(worktreePath, ["status", "--porcelain"]);
+  if (result.code !== 0)
+    return true;
+  return result.stdout.trim().length > 0;
+}
+async function removeWorktree(repo, worktreePath) {
+  return runGit(repo, ["worktree", "remove", worktreePath]);
+}
+async function pruneWorktrees(repo) {
+  return runGit(repo, ["worktree", "prune"]);
+}
+async function resolveRepoRoot(cwd) {
+  const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (result.code !== 0)
+    return;
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : undefined;
+}
+
+// packages/omo-opencode/src/cli/worktree-sweep/sweep.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+async function isOlderThan(worktreePath, days, now) {
+  if (days <= 0)
+    return false;
+  try {
+    const stats = await stat8(worktreePath);
+    return now - stats.mtimeMs > days * DAY_MS;
+  } catch {
+    return false;
+  }
+}
+async function classifyRecord(repo, record3, defaultBranch, options) {
+  const pathExists3 = existsSync66(record3.path);
+  const external2 = isExcludedPath(record3.path, options.excludePrefixes, options.home);
+  if (record3.locked || !pathExists3 || external2) {
+    return classifyWorktree({
+      record: record3,
+      pathExists: pathExists3,
+      merged: false,
+      agedOut: false,
+      dirty: false,
+      external: external2
+    });
+  }
+  const merged = await isMerged(repo, worktreeRef(record3), defaultBranch);
+  const agedOut = merged ? false : await isOlderThan(record3.path, options.olderThanDays, options.now);
+  const dirty = merged || agedOut ? await isDirty(record3.path) : false;
+  return classifyWorktree({ record: record3, pathExists: pathExists3, merged, agedOut, dirty, external: external2 });
+}
+async function sweepRepo(repo, options) {
+  const root = normalize2(await resolveRepoRoot(repo) ?? repo);
+  const defaultBranch = await detectDefaultBranch(root);
+  if (defaultBranch === undefined) {
+    throw new Error(`Could not determine the default branch for ${root}`);
+  }
+  const records = linkedWorktrees(parseWorktreeList(await listWorktreesPorcelain(root)));
+  const classifications = [];
+  for (const record3 of records) {
+    classifications.push(await classifyRecord(root, record3, defaultBranch, options));
+  }
+  const removed2 = [];
+  const failed = [];
+  if (options.apply) {
+    for (const classification of classifications) {
+      if (classification.decision !== "SWEEP")
+        continue;
+      const result = await removeWorktree(root, classification.path);
+      if (result.code === 0)
+        removed2.push(classification.path);
+      else {
+        failed.push({
+          path: classification.path,
+          error: result.stderr.trim() || `git worktree remove exited with ${result.code}`
+        });
+      }
+    }
+    await pruneWorktrees(root);
+  }
+  return { repo: root, defaultBranch, classifications, removed: removed2, failed };
+}
+async function sweepWorktrees(options = {}) {
+  const apply = options.apply === true;
+  const olderThanDays = options.olderThanDays ?? 0;
+  const excludePrefixes = options.excludePrefixes ?? DEFAULT_EXCLUDE_PREFIXES;
+  const home = os7.homedir();
+  const now = Date.now();
+  const repos = options.repos && options.repos.length > 0 ? options.repos : [options.cwd ?? process.cwd()];
+  const reports = [];
+  for (const repo of repos) {
+    reports.push(await sweepRepo(repo, { apply, olderThanDays, excludePrefixes, home, now }));
+  }
+  const all = reports.flatMap((report) => report.classifications);
+  return {
+    apply,
+    olderThanDays,
+    repos: reports,
+    sweepCount: all.filter((item) => item.decision === "SWEEP").length,
+    keepCount: all.filter((item) => item.decision === "KEEP").length,
+    pruneCount: all.filter((item) => item.decision === "PRUNE").length
+  };
+}
+// packages/omo-opencode/src/cli/worktree-sweep/worktree-sweep.ts
+async function worktreeSweep(options = {}) {
+  let result;
+  try {
+    result = await sweepWorktrees(options);
+  } catch (error51) {
+    process.stderr.write(`[omo] worktree-sweep failed: ${error51 instanceof Error ? error51.message : String(error51)}
+`);
+    return 1;
+  }
+  if (options.json === true) {
+    process.stdout.write(JSON.stringify(result, null, 2));
+    process.stdout.write(`
+`);
+  } else {
+    process.stdout.write(formatResult(result).join(`
+`));
+    process.stdout.write(`
+`);
+  }
+  const failedTotal = result.repos.reduce((total, repo) => total + repo.failed.length, 0);
+  if (failedTotal > 0)
+    return 1;
+  return 0;
+}
 // packages/omo-opencode/src/cli/runtime-commands.ts
 init_shared();
 init_package();
@@ -113946,6 +114273,30 @@ function configureRuntimeCommands(program2) {
     });
     process.exit(exitCode);
   });
+  program2.command("worktree-sweep").description("Report (and optionally remove) stale linked git worktrees").option("--apply", "Actually remove SWEEP worktrees and prune stale metadata (default is dry-run)").option("--older-than <days>", "Sweep unmerged worktrees older than N days (0 = merged-only)", (value) => {
+    try {
+      return parseOlderThanDays(value);
+    } catch (error51) {
+      throw new InvalidArgumentError(error51 instanceof Error ? error51.message : String(error51));
+    }
+  }).option("--repo <path>", "Repository to sweep (repeatable)", (value, previous = []) => [...previous, value]).option("--json", "Output structured JSON result").addHelpText("after", `
+Examples:
+  $ omo-agent-toolkit worktree-sweep
+  $ omo-agent-toolkit worktree-sweep --older-than=14
+  $ omo-agent-toolkit worktree-sweep --repo /path/to/repo --repo /path/to/other --apply
+
+Lines: SWEEP <path> <ref> | KEEP(<reason>) <path> <ref> | PRUNE <path> <ref>
+KEEP reasons: locked, external, unmerged, dirty. Dry-run is the default; --apply
+removes with 'git worktree remove' (never --force) and then prunes.
+`).action(async (options) => {
+    const exitCode = await worktreeSweep({
+      apply: options.apply === true,
+      olderThanDays: options.olderThan ?? 0,
+      repos: options.repo,
+      json: options.json ?? false
+    });
+    process.exit(exitCode);
+  });
   program2.command("ulw-loop [args...]").allowUnknownOption().passThroughOptions().description("Run the Codex LazyCodex ulw-loop CLI").action(async (args = []) => {
     const exitCode = await codexUlwLoop(args);
     process.exit(exitCode);

package/dist/cli/runtime-commands.d.ts

@@ -1,2 +1,2 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 export declare function configureRuntimeCommands(program: Command): void;

package/dist/cli/worktree-sweep/classify.d.ts

@@ -0,0 +1,16 @@
+import type { ClassificationInput, WorktreeClassification, WorktreeRecord } from "./types";
+/**
+ * Externally-owned worktree roots. These are managed by other applications, so
+ * sweeping them would delete state we do not own.
+ */
+export declare const DEFAULT_EXCLUDE_PREFIXES: readonly string[];
+export declare function expandHome(value: string, home: string): string;
+export declare function isExcludedPath(worktreePath: string, prefixes: readonly string[], home: string): boolean;
+/** Branch name when attached, otherwise the detached HEAD sha. */
+export declare function worktreeRef(record: WorktreeRecord): string;
+/**
+ * Single source of truth for sweep decisions. Mirrors the validated `git-wt-cl`
+ * prototype: protection wins over eligibility, and eligibility requires both a
+ * merged (or aged-out) ref and a clean tree.
+ */
+export declare function classifyWorktree(input: ClassificationInput): WorktreeClassification;

package/dist/cli/worktree-sweep/format.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeClassification, WorktreeSweepResult } from "./types";
+/**
+ * One machine-parseable line per worktree:
+ *   `SWEEP <path> <ref>` / `KEEP(<reason>) <path> <ref>` / `PRUNE <path> <ref>`
+ */
+export declare function formatClassification(classification: WorktreeClassification): string;
+export declare function formatSummary(result: WorktreeSweepResult): string;
+export declare function formatResult(result: WorktreeSweepResult): string[];

package/dist/cli/worktree-sweep/git.d.ts

@@ -0,0 +1,19 @@
+export interface GitResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare function runGit(cwd: string, args: readonly string[]): Promise<GitResult>;
+export declare function listWorktreesPorcelain(repo: string): Promise<string>;
+/**
+ * Default branch detection: `origin/HEAD` symbolic ref first, then a local
+ * `main`, then `master`. Mirrors the prototype's fallback chain.
+ */
+export declare function detectDefaultBranch(repo: string): Promise<string | undefined>;
+/** `git merge-base --is-ancestor <ref> <default>` — the merged oracle. */
+export declare function isMerged(repo: string, ref: string, defaultBranch: string): Promise<boolean>;
+export declare function isDirty(worktreePath: string): Promise<boolean>;
+/** Never uses `--force`: git itself refuses dirty and locked worktrees. */
+export declare function removeWorktree(repo: string, worktreePath: string): Promise<GitResult>;
+export declare function pruneWorktrees(repo: string): Promise<GitResult>;
+export declare function resolveRepoRoot(cwd: string): Promise<string | undefined>;

package/dist/cli/worktree-sweep/index.d.ts

@@ -0,0 +1,7 @@
+export { classifyWorktree, DEFAULT_EXCLUDE_PREFIXES, isExcludedPath } from "./classify";
+export { formatClassification, formatResult, formatSummary } from "./format";
+export { parseOlderThanDays } from "./options";
+export { parseWorktreeList, linkedWorktrees } from "./parse-worktree-list";
+export { sweepWorktrees } from "./sweep";
+export { worktreeSweep } from "./worktree-sweep";
+export type { ClassificationInput, WorktreeClassification, WorktreeDecision, WorktreeKeepReason, WorktreeRecord, WorktreeSweepOptions, WorktreeSweepRepoReport, WorktreeSweepResult, } from "./types";

package/dist/cli/worktree-sweep/options.d.ts

@@ -0,0 +1,2 @@
+/** Parses the `--older-than <days>` value: a non-negative integer, else throws. */
+export declare function parseOlderThanDays(value: string): number;

package/dist/cli/worktree-sweep/parse-worktree-list.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeRecord } from "./types";
+/**
+ * Parses `git worktree list --porcelain` output. Records are separated by blank
+ * lines; the first record is always the main worktree.
+ */
+export declare function parseWorktreeList(porcelain: string): WorktreeRecord[];
+/** Drops the main worktree (first record), which is never a sweep candidate. */
+export declare function linkedWorktrees(records: readonly WorktreeRecord[]): WorktreeRecord[];

package/dist/cli/worktree-sweep/sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions, WorktreeSweepResult } from "./types";
+export declare function sweepWorktrees(options?: WorktreeSweepOptions): Promise<WorktreeSweepResult>;

package/dist/cli/worktree-sweep/types.d.ts

@@ -0,0 +1,65 @@
+export interface WorktreeRecord {
+    /** Absolute worktree path as reported by `git worktree list --porcelain`. */
+    readonly path: string;
+    /** Commit SHA of the worktree HEAD, when reported. */
+    readonly head?: string;
+    /** Short branch name (`refs/heads/` stripped), when the worktree is attached. */
+    readonly branch?: string;
+    readonly detached: boolean;
+    readonly locked: boolean;
+    /** Lock reason string recorded by `git worktree lock --reason`, when present. */
+    readonly lockReason?: string;
+    readonly prunable: boolean;
+}
+export type WorktreeDecision = "SWEEP" | "KEEP" | "PRUNE";
+export type WorktreeKeepReason = "locked" | "external" | "unmerged" | "dirty";
+export interface WorktreeClassification {
+    readonly path: string;
+    /** Branch name when attached, otherwise the HEAD sha; empty when neither is known. */
+    readonly ref: string;
+    readonly decision: WorktreeDecision;
+    readonly reason?: WorktreeKeepReason;
+}
+export interface ClassificationInput {
+    readonly record: WorktreeRecord;
+    /** False when the worktree path no longer exists on disk. */
+    readonly pathExists: boolean;
+    readonly merged: boolean;
+    /** True when `--older-than` is satisfied; always false when `--older-than=0`. */
+    readonly agedOut: boolean;
+    readonly dirty: boolean;
+    /** True when the path lives under one of the configured protected prefixes. */
+    readonly external: boolean;
+}
+export interface WorktreeSweepRepoReport {
+    readonly repo: string;
+    readonly defaultBranch: string;
+    readonly classifications: readonly WorktreeClassification[];
+    /** Paths actually removed; always empty in dry-run mode. */
+    readonly removed: readonly string[];
+    /** Paths that `git worktree remove` refused, with the git error text. */
+    readonly failed: readonly {
+        readonly path: string;
+        readonly error: string;
+    }[];
+}
+export interface WorktreeSweepResult {
+    readonly apply: boolean;
+    readonly olderThanDays: number;
+    readonly repos: readonly WorktreeSweepRepoReport[];
+    readonly sweepCount: number;
+    readonly keepCount: number;
+    readonly pruneCount: number;
+}
+export interface WorktreeSweepOptions {
+    /** Dry-run is the default; only an explicit `true` removes anything. */
+    readonly apply?: boolean;
+    /** 0 means merged-only: unmerged worktrees are never swept. */
+    readonly olderThanDays?: number;
+    /** Repositories to sweep; defaults to the current working directory's repo. */
+    readonly repos?: readonly string[];
+    readonly json?: boolean;
+    /** Overrides the built-in externally-owned path prefixes. */
+    readonly excludePrefixes?: readonly string[];
+    readonly cwd?: string;
+}

package/dist/cli/worktree-sweep/worktree-sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions } from "./types";
+export declare function worktreeSweep(options?: WorktreeSweepOptions): Promise<number>;