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

package/dist/cli-node/index.js

@@ -55,7 +55,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "oh-my-opencode",
-    version: "5.0.0-beta.16",
+    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",
@@ -236,7 +236,7 @@ var init_package = __esm(() => {
       zod: "^4.4.3"
     },
     devDependencies: {
-      "@code-yeongyu/senpi": "2026.8.22",
+      "@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:*",
@@ -277,18 +277,18 @@ var init_package = __esm(() => {
       typescript: "^7.0.2"
     },
     optionalDependencies: {
-      "oh-my-opencode-darwin-arm64": "5.0.0-beta.16",
-      "oh-my-opencode-darwin-x64": "5.0.0-beta.16",
-      "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.16",
-      "oh-my-opencode-linux-arm64": "5.0.0-beta.16",
-      "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.16",
-      "oh-my-opencode-linux-x64": "5.0.0-beta.16",
-      "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.16",
-      "oh-my-opencode-linux-x64-musl": "5.0.0-beta.16",
-      "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.16",
-      "oh-my-opencode-windows-arm64": "5.0.0-beta.16",
-      "oh-my-opencode-windows-x64": "5.0.0-beta.16",
-      "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.16"
+      "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",
@@ -20397,13 +20397,14 @@ function resolveOmoTaskSettings(input, resolveParallelism = availableParallelism
   const record2 = record(string2(), unknown()).parse(input);
   return OmoTaskSettingsSchema.parse({
     ...record2,
-    residency_max_children: record2["residency_max_children"] ?? Math.max(8, resolveParallelism() * 3)
+    residency_max_children: record2["residency_max_children"] ?? Math.max(8, resolveParallelism() * 3),
+    global_concurrency: record2["global_concurrency"] ?? Math.max(8, resolveParallelism() * 2)
   });
 }
 var ResidencyMaxChildrenInputSchema, OmoTaskWaitSchema, OmoTaskTeamSettingsSchema, OmoTaskWarningsSchema, OmoTaskDagSettingsSchema, OmoTaskSettingsSchema, OmoTaskDagSettingsLayerSchema, OmoTaskWaitLayerSchema, OmoTaskTeamSettingsLayerSchema, OmoTaskWarningsLayerSchema, OmoTaskSettingsLayerSchema;
 var init_task = __esm(() => {
   init_zod();
-  ResidencyMaxChildrenInputSchema = union([number2().int().positive(), literal("unlimited")]);
+  ResidencyMaxChildrenInputSchema = union([number2().int().nonnegative(), literal("unlimited")]);
   OmoTaskWaitSchema = object({
     min_ms: number2().int().positive().default(5000),
     default_ms: number2().int().positive().default(60000),
@@ -20429,9 +20430,10 @@ var init_task = __esm(() => {
   }).strict();
   OmoTaskSettingsSchema = object({
     default_execution_mode: _enum2(["in-process", "process"]).default("in-process"),
-    default_concurrency: number2().int().positive().default(5),
-    provider_concurrency: record(string2(), number2().int().positive()).optional(),
-    model_concurrency: record(string2(), number2().int().positive()).optional(),
+    default_concurrency: number2().int().nonnegative().default(5),
+    global_concurrency: number2().int().nonnegative().default(8),
+    provider_concurrency: record(string2(), number2().int().nonnegative()).optional(),
+    model_concurrency: record(string2(), number2().int().nonnegative()).optional(),
     max_depth: number2().int().nonnegative().default(1),
     residency_max_children: ResidencyMaxChildrenInputSchema.default(8),
     ttl_ms: number2().int().positive().default(86400000),
@@ -20472,9 +20474,10 @@ var init_task = __esm(() => {
   }).strict();
   OmoTaskSettingsLayerSchema = object({
     default_execution_mode: _enum2(["in-process", "process"]).optional(),
-    default_concurrency: number2().int().positive().optional(),
-    provider_concurrency: record(string2(), number2().int().positive()).optional(),
-    model_concurrency: record(string2(), number2().int().positive()).optional(),
+    default_concurrency: number2().int().nonnegative().optional(),
+    global_concurrency: number2().int().nonnegative().optional(),
+    provider_concurrency: record(string2(), number2().int().nonnegative()).optional(),
+    model_concurrency: record(string2(), number2().int().nonnegative()).optional(),
     max_depth: number2().int().nonnegative().optional(),
     residency_max_children: ResidencyMaxChildrenInputSchema.optional(),
     ttl_ms: number2().int().positive().optional(),
@@ -94383,7 +94386,7 @@ var package_default2;
 var init_package2 = __esm(() => {
   package_default2 = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.0.0-beta.16",
+    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.",
@@ -103355,7 +103358,7 @@ function localLauncherCmdPath(homeDir = homedir10()) {
 }
 function renderLocalLauncher(options) {
   const brand = {
-    name: "omo",
+    name: "OmO",
     displayVersion: options.version ?? "local",
     configDir: ".omo",
     flatLayout: false,
@@ -107039,7 +107042,7 @@ var CircuitBreakerConfigSchema = exports_external.object({
   consecutiveThreshold: exports_external.number().int().min(5).optional()
 });
 var BackgroundTaskConfigSchema = exports_external.object({
-  defaultConcurrency: exports_external.number().min(1).optional(),
+  defaultConcurrency: exports_external.number().min(0).optional(),
   providerConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
   modelConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
   maxDepth: exports_external.number().int().min(1).optional(),
@@ -113975,6 +113978,333 @@ async function refreshModelCapabilities(options, deps = {}) {
   }
 }
 
+// packages/omo-opencode/src/cli/worktree-sweep/classify.ts
+import path15 from "node: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 "node: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 "node:fs";
+import { stat as stat8 } from "node:fs/promises";
+import os7 from "node:os";
+import { normalize as normalize2 } from "node: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();
@@ -113999,6 +114329,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/index.js

@@ -5619,12 +5619,13 @@ function resolveOmoTaskSettings(input, resolveParallelism = availableParallelism
   const record8 = z10.record(z10.string(), z10.unknown()).parse(input);
   return OmoTaskSettingsSchema.parse({
     ...record8,
-    residency_max_children: record8["residency_max_children"] ?? Math.max(8, resolveParallelism() * 3)
+    residency_max_children: record8["residency_max_children"] ?? Math.max(8, resolveParallelism() * 3),
+    global_concurrency: record8["global_concurrency"] ?? Math.max(8, resolveParallelism() * 2)
   });
 }
 var ResidencyMaxChildrenInputSchema, OmoTaskWaitSchema, OmoTaskTeamSettingsSchema, OmoTaskWarningsSchema, OmoTaskDagSettingsSchema, OmoTaskSettingsSchema, OmoTaskDagSettingsLayerSchema, OmoTaskWaitLayerSchema, OmoTaskTeamSettingsLayerSchema, OmoTaskWarningsLayerSchema, OmoTaskSettingsLayerSchema;
 var init_task = __esm(() => {
-  ResidencyMaxChildrenInputSchema = z10.union([z10.number().int().positive(), z10.literal("unlimited")]);
+  ResidencyMaxChildrenInputSchema = z10.union([z10.number().int().nonnegative(), z10.literal("unlimited")]);
   OmoTaskWaitSchema = z10.object({
     min_ms: z10.number().int().positive().default(5000),
     default_ms: z10.number().int().positive().default(60000),
@@ -5650,9 +5651,10 @@ var init_task = __esm(() => {
   }).strict();
   OmoTaskSettingsSchema = z10.object({
     default_execution_mode: z10.enum(["in-process", "process"]).default("in-process"),
-    default_concurrency: z10.number().int().positive().default(5),
-    provider_concurrency: z10.record(z10.string(), z10.number().int().positive()).optional(),
-    model_concurrency: z10.record(z10.string(), z10.number().int().positive()).optional(),
+    default_concurrency: z10.number().int().nonnegative().default(5),
+    global_concurrency: z10.number().int().nonnegative().default(8),
+    provider_concurrency: z10.record(z10.string(), z10.number().int().nonnegative()).optional(),
+    model_concurrency: z10.record(z10.string(), z10.number().int().nonnegative()).optional(),
     max_depth: z10.number().int().nonnegative().default(1),
     residency_max_children: ResidencyMaxChildrenInputSchema.default(8),
     ttl_ms: z10.number().int().positive().default(86400000),
@@ -5693,9 +5695,10 @@ var init_task = __esm(() => {
   }).strict();
   OmoTaskSettingsLayerSchema = z10.object({
     default_execution_mode: z10.enum(["in-process", "process"]).optional(),
-    default_concurrency: z10.number().int().positive().optional(),
-    provider_concurrency: z10.record(z10.string(), z10.number().int().positive()).optional(),
-    model_concurrency: z10.record(z10.string(), z10.number().int().positive()).optional(),
+    default_concurrency: z10.number().int().nonnegative().optional(),
+    global_concurrency: z10.number().int().nonnegative().optional(),
+    provider_concurrency: z10.record(z10.string(), z10.number().int().nonnegative()).optional(),
+    model_concurrency: z10.record(z10.string(), z10.number().int().nonnegative()).optional(),
     max_depth: z10.number().int().nonnegative().optional(),
     residency_max_children: ResidencyMaxChildrenInputSchema.optional(),
     ttl_ms: z10.number().int().positive().optional(),
@@ -27343,7 +27346,7 @@ var CircuitBreakerConfigSchema = z19.object({
   consecutiveThreshold: z19.number().int().min(5).optional()
 });
 var BackgroundTaskConfigSchema = z19.object({
-  defaultConcurrency: z19.number().min(1).optional(),
+  defaultConcurrency: z19.number().min(0).optional(),
   providerConcurrency: z19.record(z19.string(), z19.number().min(0)).optional(),
   modelConcurrency: z19.record(z19.string(), z19.number().min(0)).optional(),
   maxDepth: z19.number().int().min(1).optional(),
@@ -98669,7 +98672,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.0.0-beta.16",
+  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",
@@ -98850,7 +98853,7 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@code-yeongyu/senpi": "2026.8.22",
+    "@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:*",
@@ -98891,18 +98894,18 @@ var package_default = {
     typescript: "^7.0.2"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.16",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.16",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.16",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.16",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.16",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.16",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.16",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.16",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.16",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.16",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.16",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.16"
+    "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",

package/dist/oh-my-opencode.schema.json

@@ -9206,7 +9206,7 @@
       "properties": {
         "defaultConcurrency": {
           "type": "number",
-          "minimum": 1
+          "minimum": 0
         },
         "providerConcurrency": {
           "type": "object",

package/dist/skills/review-work/SKILL.md

@@ -90,7 +90,7 @@ Before launching agents, collect these inputs. Extract from conversation history
 </required_inputs>
 
 
-Review PRs and branches from a dedicated review worktree only: create or attach one with `git worktree add <path> <branch>` before collecting changed files, diff, file contents, or running checks. The main worktree is read-only context; never checkout, test, or edit the review branch there.
+Review PRs and branches from a dedicated review worktree only: create or attach one with `git worktree add <path> <branch>` before collecting changed files, diff, file contents, or running checks, then immediately lock it with `git worktree lock <path> --reason "review:<pr-or-branch>"`. The main worktree is read-only context; never checkout, test, or edit the review branch there.
 
 **Auto-collection sequence:**
 
@@ -530,8 +530,6 @@ OUTPUT FORMAT:
 """)
 ```
 
----
-
 ## Phase 2: Wait & Collect
 
 After launching all 5 agents in one turn, wait for completions in bounded
@@ -561,6 +559,8 @@ review result with the incomplete lane named. Do not spin in repeated
 wait/followup cycles. Do not use `multi_agent_v1.send_input` as an interrupt; queued
 followups are not cancellation.
 
+After ALL 5 lanes reach a terminal state and before delivering the verdict, tear down the review worktree: run `git worktree unlock <path>` followed by `git worktree remove <path>`. The lanes above run inside that worktree, so removing it earlier destroys their working directory; a crashed review leaves the locked tree as a recoverable marker for manual cleanup.
+
 ---
 
 ## Phase 3: Deliver Verdict