oh-my-opencode 4.16.0 → 4.16.2

package/dist/index.js

@@ -7945,7 +7945,10 @@ function finishPromptReservation(sessionID, reservation, dispatchAttempted, post
 function deletePromptReservation(sessionID) {
   promptAsyncReservations.delete(sessionID);
 }
-function reservationSourceMatches(reservationSource, expectedSource, expectedPrefix) {
+function isTransientRetryReservationOwner(reservationSource) {
+  return reservationSource === TRANSIENT_RETRY_RESERVATION_OWNER || reservationSource.startsWith(`${TRANSIENT_RETRY_RESERVATION_OWNER}:`);
+}
+function reservationSourceMatches(reservationSource, expectedSource, expectedPrefix, supersedeTransientRetryOwners) {
   if (typeof expectedSource === "string") {
     if (reservationSource === expectedSource) {
       return true;
@@ -7953,13 +7956,16 @@ function reservationSourceMatches(reservationSource, expectedSource, expectedPre
   } else if (expectedSource.includes(reservationSource)) {
     return true;
   }
+  if (supersedeTransientRetryOwners && isTransientRetryReservationOwner(reservationSource)) {
+    return true;
+  }
   if (expectedPrefix === undefined) {
     return false;
   }
   const prefixes = typeof expectedPrefix === "string" ? [expectedPrefix] : expectedPrefix;
   return prefixes.filter((prefix) => prefix.length > 0 && prefix.endsWith(":")).some((prefix) => reservationSource.startsWith(prefix));
 }
-var promptAsyncReservations, expiredReservationHandler;
+var promptAsyncReservations, expiredReservationHandler, TRANSIENT_RETRY_RESERVATION_OWNER = "model-suggestion-retry";
 var init_reservations = __esm(() => {
   promptAsyncReservations = new Map;
 });
@@ -8558,7 +8564,7 @@ function releasePromptAsyncReservation(sessionID, source, options) {
     return false;
   }
   const expectedSource = options?.reservedBy ?? source;
-  if (!reservationSourceMatches(existing.source, expectedSource, options?.reservedByPrefix)) {
+  if (!reservationSourceMatches(existing.source, expectedSource, options?.reservedByPrefix, options?.supersedeTransientRetryOwners)) {
     log("[prompt-async-gate] promptAsync reservation release skipped for different source", {
       sessionID,
       source,
@@ -13173,10 +13179,10 @@ var init_tolerant_fsync = __esm(() => {
 // packages/team-core/src/team-state-store/locks.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import { access as access3, open, readFile as readFile4, rename as rename3, rm as rm3, unlink as unlink2 } from "fs/promises";
-import { dirname as dirname23 } from "path";
+import { dirname as dirname24 } from "path";
 function delay4(ms) {
-  return new Promise((resolve19) => {
-    setTimeout(resolve19, ms);
+  return new Promise((resolve20) => {
+    setTimeout(resolve20, ms);
   });
 }
 function buildOwnerContent(ownerTag) {
@@ -13228,7 +13234,7 @@ async function assertRetryableLockOpenError(lockPath, error, deps) {
   if (code === "EPERM") {
     if (await pathMayExist(lockPath, deps))
       return;
-    if ((deps?.platform ?? process.platform) === "win32" && await pathMayExist(dirname23(lockPath), deps))
+    if ((deps?.platform ?? process.platform) === "win32" && await pathMayExist(dirname24(lockPath), deps))
       return;
   }
   throw error;
@@ -13560,18 +13566,18 @@ __export(exports_storage, {
   getStateFilePath: () => getStateFilePath,
   clearState: () => clearState
 });
-import { existsSync as existsSync69, readFileSync as readFileSync45, writeFileSync as writeFileSync17, unlinkSync as unlinkSync12, mkdirSync as mkdirSync17 } from "fs";
-import { dirname as dirname24, join as join83 } from "path";
+import { existsSync as existsSync74, readFileSync as readFileSync48, writeFileSync as writeFileSync18, unlinkSync as unlinkSync13, mkdirSync as mkdirSync18 } from "fs";
+import { dirname as dirname25, join as join86 } from "path";
 function getStateFilePath(directory, customPath) {
-  return customPath ? join83(directory, customPath) : join83(directory, DEFAULT_STATE_FILE);
+  return customPath ? join86(directory, customPath) : join86(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync69(filePath)) {
+  if (!existsSync74(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync45(filePath, "utf-8");
+    const content = readFileSync48(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -13617,9 +13623,9 @@ function readState(directory, customPath) {
 function writeState(directory, state3, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    const dir = dirname24(filePath);
-    if (!existsSync69(dir)) {
-      mkdirSync17(dir, { recursive: true });
+    const dir = dirname25(filePath);
+    if (!existsSync74(dir)) {
+      mkdirSync18(dir, { recursive: true });
     }
     const sessionIdLine = state3.session_id ? `session_id: "${state3.session_id}"
 ` : "";
@@ -13651,7 +13657,7 @@ ${initialCompletionPromiseLine}${verificationAttemptLine}${verificationAttemptSt
 ${sessionIdLine}${ultraworkLine}${verificationPendingLine}${strategyLine}${messageCountAtStartLine}---
 ${state3.prompt}
 `;
-    writeFileSync17(filePath, content, "utf-8");
+    writeFileSync18(filePath, content, "utf-8");
     return true;
   } catch (error) {
     if (!(error instanceof Error)) {
@@ -13663,8 +13669,8 @@ ${state3.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync69(filePath)) {
-      unlinkSync12(filePath);
+    if (existsSync74(filePath)) {
+      unlinkSync13(filePath);
     }
     return true;
   } catch (error) {
@@ -81981,6 +81987,7 @@ import { existsSync as existsSync40 } from "fs";
 
 // packages/omo-opencode/src/hooks/comment-checker/cli.ts
 init_bun_spawn_shim();
+init_bun_which_shim();
 import { join as join46 } from "path";
 import { existsSync as existsSync39 } from "fs";
 import * as fs8 from "fs";
@@ -82331,7 +82338,7 @@ function debugLog2(...args) {
 function getBinaryName2() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
-function resolveCommentCheckerPathFromPath(binaryName, which2 = Bun.which) {
+function resolveCommentCheckerPathFromPath(binaryName, which2 = bunWhich) {
   try {
     return which2(binaryName);
   } catch (error) {
@@ -87871,8 +87878,779 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
     ...Object.keys(accumulatedCommonFields).length > 0 ? accumulatedCommonFields : {}
   };
 }
+// packages/boulder-state/src/constants.ts
+var BOULDER_DIR = ".omo";
+var BOULDER_FILE = "boulder.json";
+var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
+var NOTEPAD_DIR = "notepads";
+var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
+var PROMETHEUS_PLANS_DIR = ".omo/plans";
+// packages/boulder-state/src/top-level-task.ts
+import { existsSync as existsSync56, readFileSync as readFileSync33 } from "fs";
+var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
+var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
+var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
+var UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
+var TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/;
+var FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i;
+function buildTaskRef(section, taskLabel) {
+  const pattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN;
+  const match = taskLabel.match(pattern);
+  if (!match) {
+    return null;
+  }
+  const rawLabel = match[1];
+  const title = match[2].trim();
+  return {
+    key: `${section}:${rawLabel.toLowerCase()}`,
+    section,
+    label: rawLabel,
+    title
+  };
+}
+function readCurrentTopLevelTask(planPath) {
+  if (!existsSync56(planPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync33(planPath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    let section = "other";
+    for (const line of lines) {
+      if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
+        section = TODO_HEADING_PATTERN.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN.test(line) ? "final-wave" : "other";
+      }
+      const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN);
+      if (!uncheckedTaskMatch || uncheckedTaskMatch[1].length > 0) {
+        continue;
+      }
+      if (section !== "todo" && section !== "final-wave") {
+        continue;
+      }
+      const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim());
+      if (taskRef) {
+        return taskRef;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+// packages/boulder-state/src/storage/path.ts
+import { existsSync as existsSync57 } from "fs";
+import { isAbsolute as isAbsolute12, join as join67, relative as relative11, resolve as resolve17 } from "path";
+function getBoulderFilePath(directory) {
+  return join67(directory, BOULDER_DIR, BOULDER_FILE);
+}
+function resolveTrackedPath(baseDirectory, trackedPath) {
+  return isAbsolute12(trackedPath) ? resolve17(trackedPath) : resolve17(baseDirectory, trackedPath);
+}
+function resolveBoulderPlanPath(directory, state3) {
+  const absolutePlanPath = resolveTrackedPath(directory, state3.active_plan);
+  const worktreePath = state3.worktree_path?.trim();
+  if (!worktreePath) {
+    return absolutePlanPath;
+  }
+  const absoluteDirectory = resolve17(directory);
+  const relativePlanPath = relative11(absoluteDirectory, absolutePlanPath);
+  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute12(relativePlanPath)) {
+    return absolutePlanPath;
+  }
+  const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
+  const worktreePlanPath = resolve17(absoluteWorktreePath, relativePlanPath);
+  return existsSync57(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+}
+function resolveBoulderPlanPathForWork(directory, work) {
+  return resolveBoulderPlanPath(directory, work);
+}
+// packages/boulder-state/src/storage/plan-progress.ts
+import { existsSync as existsSync58, readFileSync as readFileSync34, readdirSync as readdirSync18, statSync as statSync8 } from "fs";
+import { basename as basename12, join as join68 } from "path";
+var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
+var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
+var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
+var UNCHECKED_CHECKBOX_PATTERN2 = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
+var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
+var TODO_TASK_PATTERN2 = /^\d+\.\s+/;
+var FINAL_WAVE_TASK_PATTERN2 = /^F\d+\.\s+/i;
+var LEGACY_PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
+var PROMETHEUS_PLAN_DIRS = [PROMETHEUS_PLANS_DIR, LEGACY_PROMETHEUS_PLANS_DIR];
+function findPrometheusPlans(directory) {
+  try {
+    return PROMETHEUS_PLAN_DIRS.flatMap((planDir) => {
+      const plansDir = join68(directory, planDir);
+      if (!existsSync58(plansDir)) {
+        return [];
+      }
+      return readdirSync18(plansDir).filter((file2) => file2.endsWith(".md")).map((file2) => join68(plansDir, file2));
+    }).sort((left, right) => statSync8(right).mtimeMs - statSync8(left).mtimeMs);
+  } catch {
+    return [];
+  }
+}
+function getPlanName(planPath) {
+  return basename12(planPath, ".md");
+}
+function getPlanProgress(planPath) {
+  if (!existsSync58(planPath)) {
+    return { total: 0, completed: 0, isComplete: false };
+  }
+  try {
+    const content = readFileSync34(planPath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN2.test(line) || FINAL_VERIFICATION_HEADING_PATTERN2.test(line));
+    if (hasStructuredSections) {
+      return getStructuredPlanProgress(lines);
+    }
+    return getSimplePlanProgress(content);
+  } catch {
+    return { total: 0, completed: 0, isComplete: false };
+  }
+}
+function getStructuredPlanProgress(lines) {
+  let section = "other";
+  let total = 0;
+  let completed = 0;
+  for (const line of lines) {
+    if (SECOND_LEVEL_HEADING_PATTERN2.test(line)) {
+      section = TODO_HEADING_PATTERN2.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN2.test(line) ? "final-wave" : "other";
+      continue;
+    }
+    if (section !== "todo" && section !== "final-wave") {
+      continue;
+    }
+    const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN);
+    const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN2);
+    const match = checkedMatch ?? uncheckedMatch;
+    if (!match || match[1].length > 0) {
+      continue;
+    }
+    const taskBody = match[2].trim();
+    const labelPattern = section === "todo" ? TODO_TASK_PATTERN2 : FINAL_WAVE_TASK_PATTERN2;
+    if (!labelPattern.test(taskBody)) {
+      continue;
+    }
+    total += 1;
+    if (checkedMatch) {
+      completed += 1;
+    }
+  }
+  return { total, completed, isComplete: total > 0 && completed === total };
+}
+function getSimplePlanProgress(content) {
+  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) ?? [];
+  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) ?? [];
+  const total = uncheckedMatches.length + checkedMatches.length;
+  const completed = checkedMatches.length;
+  return { total, completed, isComplete: total > 0 && completed === total };
+}
+// packages/boulder-state/src/storage/shared.ts
+var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+var SESSION_ID_PREFIX_PATTERN = /^(codex|opencode):/;
+function normalizeSessionId(sessionId, platform2 = "opencode") {
+  if (SESSION_ID_PREFIX_PATTERN.test(sessionId)) {
+    return sessionId;
+  }
+  return `${platform2}:${sessionId}`;
+}
+function nowIsoString() {
+  return new Date().toISOString();
+}
+function parseIsoToMs(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function getElapsedMs(startedAt, endedAt) {
+  const startedMs = parseIsoToMs(startedAt);
+  const endedMs = parseIsoToMs(endedAt);
+  if (startedMs === null || endedMs === null) {
+    return;
+  }
+  return endedMs - startedMs;
+}
+function isValidWorkStatus(status) {
+  return status === "active" || status === "completed" || status === "paused" || status === "abandoned";
+}
+function buildWorkFromMirror(state3) {
+  const planName = state3.plan_name ?? state3.active_plan;
+  const workId = `${planName}-legacy`;
+  return {
+    work_id: workId,
+    active_plan: state3.active_plan,
+    plan_name: planName,
+    status: state3.status,
+    started_at: state3.started_at,
+    ended_at: state3.ended_at,
+    elapsed_ms: state3.elapsed_ms,
+    updated_at: state3.updated_at,
+    session_ids: Array.isArray(state3.session_ids) ? [...state3.session_ids] : [],
+    session_origins: state3.session_origins,
+    agent: state3.agent,
+    worktree_path: state3.worktree_path,
+    task_sessions: state3.task_sessions
+  };
+}
+function projectWorkToMirror(state3, work) {
+  state3.active_plan = work.active_plan;
+  state3.plan_name = work.plan_name;
+  state3.status = work.status;
+  state3.started_at = work.started_at;
+  state3.ended_at = work.ended_at;
+  state3.elapsed_ms = work.elapsed_ms;
+  state3.updated_at = work.updated_at;
+  state3.session_ids = [...work.session_ids];
+  state3.session_origins = work.session_origins ? { ...work.session_origins } : {};
+  state3.agent = work.agent;
+  state3.worktree_path = work.worktree_path;
+  state3.task_sessions = work.task_sessions ? { ...work.task_sessions } : {};
+}
+function selectMirrorWork(state3) {
+  const works = state3.works ? Object.values(state3.works) : [];
+  if (works.length === 0) {
+    return null;
+  }
+  if (state3.active_work_id) {
+    const matched = works.find((work) => work.work_id === state3.active_work_id);
+    if (matched) {
+      return matched;
+    }
+  }
+  const sorted = [...works].sort((left, right) => {
+    const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0;
+    const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0;
+    return rightMs - leftMs;
+  });
+  return sorted[0] ?? null;
+}
+// packages/boulder-state/src/storage/read-state.ts
+import { existsSync as existsSync59, readFileSync as readFileSync35 } from "fs";
+function readBoulderState(directory) {
+  const filePath = getBoulderFilePath(directory);
+  if (!existsSync59(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync35(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    normalizeState(parsed);
+    const state3 = parsed;
+    const mirrorWork = selectMirrorWork(state3);
+    if (mirrorWork) {
+      state3.active_work_id = mirrorWork.work_id;
+      projectWorkToMirror(state3, mirrorWork);
+    }
+    return state3;
+  } catch {
+    return null;
+  }
+}
+function normalizeState(state3) {
+  normalizeSessionFields(state3);
+  const sessionIds = Array.isArray(state3.session_ids) ? state3.session_ids : [];
+  const sessionOrigins = state3.session_origins && typeof state3.session_origins === "object" && !Array.isArray(state3.session_origins) ? state3.session_origins : {};
+  state3.session_origins = sessionOrigins;
+  if (sessionIds.length === 1) {
+    const soleSessionId = sessionIds[0];
+    if (typeof soleSessionId === "string" && sessionOrigins[soleSessionId] !== "appended" && sessionOrigins[soleSessionId] !== "direct") {
+      sessionOrigins[soleSessionId] = "direct";
+    }
+  }
+  if (!state3.task_sessions || typeof state3.task_sessions !== "object" || Array.isArray(state3.task_sessions)) {
+    state3.task_sessions = {};
+  }
+  normalizeWorkSessionFields(state3.works);
+}
+function normalizeSessionFields(target) {
+  const sessionIds = Array.isArray(target.session_ids) ? target.session_ids.filter((sessionId) => typeof sessionId === "string").map((sessionId) => normalizeSessionId(sessionId)) : [];
+  target.session_ids = sessionIds;
+  const sessionOrigins = target.session_origins && typeof target.session_origins === "object" && !Array.isArray(target.session_origins) ? normalizeSessionOrigins(target.session_origins) : {};
+  target.session_origins = sessionOrigins;
+}
+function normalizeSessionOrigins(sessionOrigins) {
+  return Object.fromEntries(Object.entries(sessionOrigins).map(([sessionId, origin]) => [normalizeSessionId(sessionId), origin]));
+}
+function normalizeWorkSessionFields(works) {
+  if (!works || typeof works !== "object" || Array.isArray(works)) {
+    return;
+  }
+  for (const work of Object.values(works)) {
+    if (work && typeof work === "object" && !Array.isArray(work)) {
+      normalizeSessionFields(work);
+    }
+  }
+}
+function getBoulderWorks(state3) {
+  if (state3.works && typeof state3.works === "object") {
+    return Object.values(state3.works).filter((work) => work != null);
+  }
+  if (!state3.active_plan || !state3.plan_name || !state3.started_at) {
+    return [];
+  }
+  return [buildWorkFromMirror(state3)];
+}
+function getActiveWorks(directory) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return [];
+  }
+  return getBoulderWorks(state3).filter((work) => work.status !== "completed" && work.status !== "abandoned");
+}
+function getWorkById(directory, workId) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  return getBoulderWorks(state3).find((work) => work.work_id === workId) ?? null;
+}
+function getWorkByPlanName(directory, planName, options) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const worktreePath = options?.worktreePath;
+  return getBoulderWorks(state3).find((work) => {
+    if (work.plan_name !== planName) {
+      return false;
+    }
+    return worktreePath ? work.worktree_path === worktreePath : true;
+  }) ?? null;
+}
+function getWorkForSession(directory, sessionId) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  let newestWork = null;
+  let newestWorkMs = 0;
+  for (const work of getBoulderWorks(state3)) {
+    if (!work.session_ids.includes(normalizedSessionId)) {
+      continue;
+    }
+    const workMs = parseIsoToMs(work.updated_at ?? work.started_at) ?? 0;
+    if (!newestWork || workMs > newestWorkMs) {
+      newestWork = work;
+      newestWorkMs = workMs;
+    }
+  }
+  if (newestWork) {
+    return newestWork;
+  }
+  return state3.session_ids.includes(normalizedSessionId) ? buildWorkFromMirror(state3) : null;
+}
+function getWorkResumeOptions(directory) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return [];
+  }
+  return getBoulderWorks(state3).filter((work) => work.status !== "completed" && work.status !== "abandoned").map((work) => {
+    const progress = getPlanProgress(resolveBoulderPlanPathForWork(directory, work));
+    return {
+      work_id: work.work_id,
+      plan_name: work.plan_name,
+      active_plan: work.active_plan,
+      worktree_path: work.worktree_path,
+      status: work.status && isValidWorkStatus(work.status) ? work.status : "active",
+      started_at: work.started_at,
+      updated_at: work.updated_at ?? work.started_at,
+      ended_at: work.ended_at,
+      elapsed_ms: work.elapsed_ms,
+      session_count: work.session_ids.length,
+      progress,
+      is_current_mirror: state3.active_work_id === work.work_id
+    };
+  });
+}
+function getTaskSessionState(directory, taskKey) {
+  const state3 = readBoulderState(directory);
+  if (state3?.active_work_id) {
+    const work = state3.works?.[state3.active_work_id];
+    const taskSession = work?.task_sessions?.[taskKey];
+    if (taskSession) {
+      return taskSession;
+    }
+  }
+  if (!state3?.task_sessions) {
+    return null;
+  }
+  return state3.task_sessions[taskKey] ?? null;
+}
+// packages/boulder-state/src/storage/write-state.ts
+import { existsSync as existsSync60, mkdirSync as mkdirSync13, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname18, join as join69 } from "path";
+function writeBoulderState(directory, state3) {
+  const filePath = getBoulderFilePath(directory);
+  try {
+    const dir = dirname18(filePath);
+    if (!existsSync60(dir)) {
+      mkdirSync13(dir, { recursive: true });
+      writeFileSync12(join69(dir, ".gitignore"), ["*", "!/rules/", "!/rules/**", ""].join(`
+`), "utf-8");
+    }
+    const stateToWrite = { ...state3 };
+    if (stateToWrite.works && stateToWrite.active_work_id) {
+      const activeWork = stateToWrite.works[stateToWrite.active_work_id];
+      if (activeWork) {
+        stateToWrite.works = {
+          ...stateToWrite.works,
+          [stateToWrite.active_work_id]: {
+            ...activeWork,
+            active_plan: stateToWrite.active_plan,
+            plan_name: stateToWrite.plan_name,
+            status: stateToWrite.status,
+            started_at: stateToWrite.started_at,
+            ended_at: stateToWrite.ended_at,
+            elapsed_ms: stateToWrite.elapsed_ms,
+            updated_at: stateToWrite.updated_at,
+            session_ids: [...stateToWrite.session_ids],
+            session_origins: stateToWrite.session_origins ? { ...stateToWrite.session_origins } : {},
+            agent: stateToWrite.agent,
+            worktree_path: stateToWrite.worktree_path,
+            task_sessions: stateToWrite.task_sessions ? { ...stateToWrite.task_sessions } : {}
+          }
+        };
+      }
+    }
+    writeFileSync12(filePath, JSON.stringify(stateToWrite, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearBoulderState(directory) {
+  const filePath = getBoulderFilePath(directory);
+  try {
+    if (existsSync60(filePath)) {
+      unlinkSync7(filePath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateWorkId(planName) {
+  const slug = planName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const randomHex = Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+  return `${slug.length > 0 ? slug : "work"}-${randomHex}`;
+}
+function createBoulderState(planPath, sessionId, agent, worktreePath) {
+  const startedAt = nowIsoString();
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  const workId = generateWorkId(getPlanName(planPath));
+  const work = {
+    work_id: workId,
+    active_plan: planPath,
+    plan_name: getPlanName(planPath),
+    status: "active",
+    started_at: startedAt,
+    updated_at: startedAt,
+    session_ids: [normalizedSessionId],
+    session_origins: { [normalizedSessionId]: "direct" },
+    ...agent !== undefined ? { agent } : {},
+    ...worktreePath !== undefined ? { worktree_path: worktreePath } : {},
+    task_sessions: {}
+  };
+  return {
+    schema_version: 2,
+    active_work_id: workId,
+    works: { [workId]: work },
+    active_plan: planPath,
+    started_at: startedAt,
+    status: "active",
+    updated_at: startedAt,
+    session_ids: [normalizedSessionId],
+    session_origins: { [normalizedSessionId]: "direct" },
+    plan_name: getPlanName(planPath),
+    task_sessions: {},
+    ...agent !== undefined ? { agent } : {},
+    ...worktreePath !== undefined ? { worktree_path: worktreePath } : {}
+  };
+}
+function selectActiveWork(directory, workId) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const works = getBoulderWorks(state3);
+  const nextWork = works.find((work) => work.work_id === workId);
+  if (!nextWork) {
+    return null;
+  }
+  const nextState = {
+    ...state3,
+    schema_version: 2,
+    active_work_id: workId,
+    works: state3.works ?? Object.fromEntries(works.map((work) => [work.work_id, work]))
+  };
+  projectWorkToMirror(nextState, nextWork);
+  return writeBoulderState(directory, nextState) ? nextState : null;
+}
+function addBoulderWork(directory, input) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const workId = generateWorkId(getPlanName(input.planPath));
+  const startedAt = input.startedAt ?? nowIsoString();
+  const normalizedSessionId = normalizeSessionId(input.sessionId);
+  const nextWork = {
+    work_id: workId,
+    active_plan: input.planPath,
+    plan_name: getPlanName(input.planPath),
+    status: "active",
+    started_at: startedAt,
+    updated_at: startedAt,
+    session_ids: [normalizedSessionId],
+    session_origins: { [normalizedSessionId]: "direct" },
+    ...input.agent !== undefined ? { agent: input.agent } : {},
+    ...input.worktreePath !== undefined ? { worktree_path: input.worktreePath } : {},
+    task_sessions: {}
+  };
+  const nextState = {
+    ...state3,
+    schema_version: 2,
+    works: { ...Object.fromEntries(getBoulderWorks(state3).map((work) => [work.work_id, work])), [workId]: nextWork },
+    active_work_id: workId
+  };
+  projectWorkToMirror(nextState, nextWork);
+  return writeBoulderState(directory, nextState) ? nextState : null;
+}
+function completeBoulder(directory, workId, endedAt) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const targetWorkId = workId ?? state3.active_work_id;
+  if (!targetWorkId) {
+    return null;
+  }
+  const work = state3.works?.[targetWorkId] ?? getBoulderWorks(state3).find((candidate) => candidate.work_id === targetWorkId);
+  if (!work) {
+    return null;
+  }
+  if (work.status === "completed" && work.ended_at !== undefined && work.elapsed_ms !== undefined) {
+    return state3;
+  }
+  const endAt = endedAt ?? nowIsoString();
+  work.ended_at = endAt;
+  work.elapsed_ms = getElapsedMs(work.started_at, endAt);
+  work.status = "completed";
+  work.updated_at = nowIsoString();
+  if (state3.active_work_id === targetWorkId) {
+    projectWorkToMirror(state3, work);
+  }
+  return writeBoulderState(directory, state3) ? state3 : null;
+}
 
+// packages/boulder-state/src/storage/session.ts
+function appendSessionId(directory, sessionId, origin = "direct") {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  const activeWorkId = readBoulderState(directory)?.active_work_id;
+  if (activeWorkId) {
+    return appendSessionIdForWork(directory, activeWorkId, normalizedSessionId, origin);
+  }
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  if (!state3.session_origins || typeof state3.session_origins !== "object" || Array.isArray(state3.session_origins)) {
+    state3.session_origins = {};
+  }
+  if (!state3.session_ids?.includes(normalizedSessionId)) {
+    if (!Array.isArray(state3.session_ids)) {
+      state3.session_ids = [];
+    }
+    const originalSessionIds = [...state3.session_ids];
+    const originalSessionOrigins = { ...state3.session_origins };
+    state3.session_ids.push(normalizedSessionId);
+    state3.session_origins[normalizedSessionId] = origin;
+    if (writeBoulderState(directory, state3)) {
+      return state3;
+    }
+    state3.session_ids = originalSessionIds;
+    state3.session_origins = originalSessionOrigins;
+    return null;
+  }
+  if (!state3.session_origins[normalizedSessionId]) {
+    state3.session_origins[normalizedSessionId] = origin;
+    if (!writeBoulderState(directory, state3)) {
+      return null;
+    }
+  }
+  return state3;
+}
+function appendSessionIdForWork(directory, workId, sessionId, origin = "direct") {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const works = getBoulderWorks(state3);
+  const targetWork = works.find((work) => work.work_id === workId);
+  if (!targetWork) {
+    return null;
+  }
+  const updatedWork = {
+    ...targetWork,
+    session_ids: targetWork.session_ids.includes(normalizedSessionId) ? [...targetWork.session_ids] : [...targetWork.session_ids, normalizedSessionId],
+    session_origins: { ...targetWork.session_origins ?? {}, [normalizedSessionId]: origin },
+    updated_at: nowIsoString()
+  };
+  const nextState = {
+    ...state3,
+    schema_version: 2,
+    works: {
+      ...Object.fromEntries(works.map((work) => [work.work_id, work])),
+      [workId]: updatedWork
+    }
+  };
+  if (state3.active_work_id === workId) {
+    projectWorkToMirror(nextState, updatedWork);
+  }
+  return writeBoulderState(directory, nextState) ? nextState : null;
+}
+// packages/boulder-state/src/storage/task.ts
+function upsertTaskSessionState(directory, input) {
+  const stateForWork = readBoulderState(directory);
+  if (stateForWork?.active_work_id) {
+    return upsertTaskSessionStateForWork(directory, stateForWork.active_work_id, input);
+  }
+  const state3 = readBoulderState(directory);
+  if (!state3 || RESERVED_KEYS.has(input.taskKey)) {
+    return null;
+  }
+  const normalizedSessionId = normalizeSessionId(input.sessionId);
+  const taskSessions = state3.task_sessions ?? {};
+  taskSessions[input.taskKey] = {
+    task_key: input.taskKey,
+    task_label: input.taskLabel,
+    task_title: input.taskTitle,
+    session_id: normalizedSessionId,
+    ...input.agent !== undefined ? { agent: input.agent } : {},
+    ...input.category !== undefined ? { category: input.category } : {},
+    updated_at: nowIsoString()
+  };
+  state3.task_sessions = taskSessions;
+  return writeBoulderState(directory, state3) ? state3 : null;
+}
+function upsertTaskSessionStateForWork(directory, workId, input) {
+  if (RESERVED_KEYS.has(input.taskKey)) {
+    return null;
+  }
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const works = getBoulderWorks(state3);
+  const targetWork = works.find((work) => work.work_id === workId);
+  if (!targetWork) {
+    return null;
+  }
+  const normalizedSessionId = normalizeSessionId(input.sessionId);
+  const previousTaskSession = targetWork.task_sessions?.[input.taskKey];
+  const nextTaskSession = {
+    task_key: input.taskKey,
+    task_label: input.taskLabel,
+    task_title: input.taskTitle,
+    session_id: normalizedSessionId,
+    ...input.agent !== undefined ? { agent: input.agent } : {},
+    ...input.category !== undefined ? { category: input.category } : {},
+    ...previousTaskSession?.started_at !== undefined ? { started_at: previousTaskSession.started_at } : {},
+    ...previousTaskSession?.ended_at !== undefined ? { ended_at: previousTaskSession.ended_at } : {},
+    ...previousTaskSession?.elapsed_ms !== undefined ? { elapsed_ms: previousTaskSession.elapsed_ms } : {},
+    ...previousTaskSession?.status !== undefined ? { status: previousTaskSession.status } : {},
+    updated_at: nowIsoString()
+  };
+  const nextWork = {
+    ...targetWork,
+    task_sessions: { ...targetWork.task_sessions ?? {}, [input.taskKey]: nextTaskSession },
+    updated_at: nowIsoString()
+  };
+  const nextState = {
+    ...state3,
+    schema_version: 2,
+    works: {
+      ...Object.fromEntries(works.map((work) => [work.work_id, work])),
+      [workId]: nextWork
+    }
+  };
+  if (state3.active_work_id === workId) {
+    projectWorkToMirror(nextState, nextWork);
+  }
+  return writeBoulderState(directory, nextState) ? nextState : null;
+}
+function startTaskTimer(directory, workId, input) {
+  const nextState = upsertTaskSessionStateForWork(directory, workId, {
+    ...input,
+    sessionId: normalizeSessionId(input.sessionId)
+  });
+  if (!nextState) {
+    return null;
+  }
+  const work = nextState.works?.[workId];
+  const taskSession = work?.task_sessions?.[input.taskKey];
+  if (!work || !taskSession) {
+    return null;
+  }
+  const startedAt = taskSession.started_at ?? input.startedAt ?? nowIsoString();
+  taskSession.started_at = startedAt;
+  taskSession.status = "running";
+  taskSession.updated_at = nowIsoString();
+  work.updated_at = nowIsoString();
+  return writeBoulderState(directory, nextState) ? nextState : null;
+}
+function endTaskTimer(directory, workId, taskKey, endedAt) {
+  const state3 = readBoulderState(directory);
+  if (!state3) {
+    return null;
+  }
+  const work = state3.works?.[workId] ?? getBoulderWorks(state3).find((candidate) => candidate.work_id === workId);
+  if (!work?.task_sessions?.[taskKey]) {
+    return null;
+  }
+  const taskSession = work.task_sessions[taskKey];
+  const endAt = endedAt ?? nowIsoString();
+  taskSession.ended_at = endAt;
+  taskSession.elapsed_ms = getElapsedMs(taskSession.started_at, endAt);
+  taskSession.status = "completed";
+  taskSession.updated_at = nowIsoString();
+  work.updated_at = nowIsoString();
+  if (state3.active_work_id === workId) {
+    projectWorkToMirror(state3, work);
+  }
+  return writeBoulderState(directory, state3) ? state3 : null;
+}
+// packages/omo-opencode/src/features/boulder-state/format-duration.ts
+init_src();
 // packages/omo-opencode/src/hooks/claude-code-hooks/handlers/tool-execute-before-handler.ts
+function nonBlankString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? value : null;
+}
+function resolvePreToolUseCwd(input, toolInput, ctx) {
+  if (input.tool.trim().toLowerCase() !== "bash") {
+    return ctx.directory;
+  }
+  const explicitCwd = nonBlankString(toolInput.cwd);
+  if (explicitCwd) {
+    return explicitCwd;
+  }
+  const trackedWorktree = nonBlankString(getWorkForSession(ctx.directory, input.sessionID)?.worktree_path);
+  if (trackedWorktree) {
+    return trackedWorktree;
+  }
+  return nonBlankString(ctx.worktree) ?? ctx.directory;
+}
 function createToolExecuteBeforeHandler(ctx, config) {
   return async (input, output) => {
     if (input.tool.trim() === "todowrite" && typeof output.args.todos === "string") {
@@ -87909,7 +88687,7 @@ function createToolExecuteBeforeHandler(ctx, config) {
       sessionId: input.sessionID,
       toolName: input.tool,
       toolInput: output.args,
-      cwd: ctx.directory,
+      cwd: resolvePreToolUseCwd(input, output.args, ctx),
       toolUseId: input.callID
     };
     const result = await executePreToolUseHooks(preCtx, claudeConfig, extendedConfig);
@@ -87952,28 +88730,28 @@ function createClaudeCodeHooksHook(ctx, config = {}, contextCollector) {
 }
 // packages/omo-opencode/src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync56,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync33,
-  writeFileSync as writeFileSync12,
-  unlinkSync as unlinkSync7
+  existsSync as existsSync61,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync36,
+  writeFileSync as writeFileSync13,
+  unlinkSync as unlinkSync8
 } from "fs";
-import { join as join68 } from "path";
+import { join as join71 } from "path";
 
 // packages/omo-opencode/src/hooks/rules-injector/constants.ts
-import { join as join67 } from "path";
-var RULES_INJECTOR_STORAGE = join67(OPENCODE_STORAGE, "rules-injector");
+import { join as join70 } from "path";
+var RULES_INJECTOR_STORAGE = join70(OPENCODE_STORAGE, "rules-injector");
 
 // packages/omo-opencode/src/hooks/rules-injector/storage.ts
 function getStoragePath(sessionID) {
-  return join68(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join71(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync56(filePath))
+  if (!existsSync61(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync33(filePath, "utf-8");
+    const content = readFileSync36(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -87993,21 +88771,21 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  mkdirSync13(RULES_INJECTOR_STORAGE, { recursive: true });
+  mkdirSync14(RULES_INJECTOR_STORAGE, { recursive: true });
   try {
-    writeFileSync12(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
+    writeFileSync13(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
     }
-    mkdirSync13(RULES_INJECTOR_STORAGE, { recursive: true });
-    writeFileSync12(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
+    mkdirSync14(RULES_INJECTOR_STORAGE, { recursive: true });
+    writeFileSync13(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
   }
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync56(filePath)) {
-    unlinkSync7(filePath);
+  if (existsSync61(filePath)) {
+    unlinkSync8(filePath);
   }
 }
 // packages/omo-opencode/src/hooks/rules-injector/cache.ts
@@ -88100,7 +88878,7 @@ function matchDecisionCacheKey(projectRoot, resolvedFilePath, realPath, statFing
 }
 
 // packages/omo-opencode/src/hooks/rules-injector/parsed-rule-cache.ts
-import { readFileSync as readFileSync34, statSync as statSync8 } from "fs";
+import { readFileSync as readFileSync37, statSync as statSync9 } from "fs";
 var MAX_PARSED_RULE_CACHE_ENTRIES = 256;
 var MAX_PARSED_RULE_CACHE_BODY_BYTES = 64 * 1024;
 var parsedRuleCache = new Map;
@@ -88108,8 +88886,8 @@ function clearParsedRuleCache() {
   parsedRuleCache.clear();
 }
 function createParsedRuleReader(options) {
-  const readRuleFileSync = options?.readFileSync ?? readFileSync34;
-  const statRuleSync = options?.statSync ?? statSync8;
+  const readRuleFileSync = options?.readFileSync ?? readFileSync37;
+  const statRuleSync = options?.statSync ?? statSync9;
   return (filePath, realPath) => {
     try {
       const stat2 = statRuleSync(filePath);
@@ -88154,13 +88932,13 @@ function setParsedRuleCacheEntry(realPath, entry) {
 }
 
 // packages/omo-opencode/src/hooks/rules-injector/path-resolution.ts
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 function resolveFilePath4(workspaceDirectory, path8) {
   if (!path8)
     return null;
   if (path8.startsWith("/"))
     return path8;
-  return resolve17(workspaceDirectory, path8);
+  return resolve18(workspaceDirectory, path8);
 }
 
 // packages/omo-opencode/src/hooks/rules-injector/rule-match-reason.ts
@@ -88720,7 +89498,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.16.0",
+  version: "4.16.2",
   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",
@@ -88766,10 +89544,11 @@ var package_default = {
     "dist",
     "bin",
     "postinstall.mjs",
+    "script/qa/strip-ansi.mjs",
     "script/qa/web-terminal-redaction.d.mts",
     "script/qa/web-terminal-redaction.mjs",
-    "script/qa/web-terminal-renderer.mjs",
     "script/qa/web-terminal-visual-qa.mjs",
+    "script/qa/xterm-live-terminal.mjs",
     "docs/reference/github-attachment-upload.md",
     "docs/reference/web-terminal-visual-qa.md",
     ".opencode/command",
@@ -88835,6 +89614,7 @@ var package_default = {
     "build:all": "bun run build && bun run build:binaries",
     "build:binaries": "bun run script/build-binaries.ts",
     "build:schema": "bun run script/build-schema.ts",
+    "build:omo-schema": "bun run script/build-omo-schema.ts",
     "build:model-capabilities": "bun run script/build-model-capabilities.ts",
     clean: "rm -rf dist",
     prepack: "bun run build:materialize-frontend",
@@ -88891,51 +89671,55 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@oh-my-opencode/git-bash-mcp": "workspace:*",
-    "@oh-my-opencode/lsp-core": "workspace:*",
-    "@oh-my-opencode/mcp-stdio-core": "workspace:*",
-    "@oh-my-opencode/mcp-client-core": "workspace:*",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
     "@oh-my-opencode/claude-code-compat-core": "workspace:*",
-    "@oh-my-opencode/skills-loader-core": "workspace:*",
     "@oh-my-opencode/comment-checker-core": "workspace:*",
     "@oh-my-opencode/delegate-core": "workspace:*",
+    "@oh-my-opencode/git-bash-mcp": "workspace:*",
     "@oh-my-opencode/hashline-core": "workspace:*",
-    "@oh-my-opencode/tmux-core": "workspace:*",
-    "@oh-my-opencode/team-core": "workspace:*",
-    "@oh-my-opencode/openclaw-core": "workspace:*",
+    "@oh-my-opencode/lsp-core": "workspace:*",
+    "@oh-my-opencode/mcp-client-core": "workspace:*",
+    "@oh-my-opencode/mcp-stdio-core": "workspace:*",
     "@oh-my-opencode/model-core": "workspace:*",
-    "@oh-my-opencode/omo-config-core": "workspace:*",
     "@oh-my-opencode/omo-codex": "workspace:*",
+    "@oh-my-opencode/omo-config-core": "workspace:*",
     "@oh-my-opencode/omo-senpi": "workspace:*",
-    "@oh-my-opencode/senpi-task": "workspace:*",
+    "@oh-my-opencode/openclaw-core": "workspace:*",
     "@oh-my-opencode/pi-goal": "workspace:*",
     "@oh-my-opencode/pi-webfetch": "workspace:*",
     "@oh-my-opencode/prompts-core": "workspace:*",
     "@oh-my-opencode/rules-engine": "workspace:*",
+    "@oh-my-opencode/senpi-task": "workspace:*",
     "@oh-my-opencode/shared-skills": "workspace:*",
+    "@oh-my-opencode/skills-loader-core": "workspace:*",
+    "@oh-my-opencode/team-core": "workspace:*",
     "@oh-my-opencode/telemetry-core": "workspace:*",
+    "@oh-my-opencode/tmux-core": "workspace:*",
     "@oh-my-opencode/utils": "workspace:*",
-    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "@types/js-yaml": "^4.0.9",
     "@types/picomatch": "^4.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
+    "@xterm/addon-unicode11": "^0.9.0",
+    "@xterm/xterm": "^6.0.0",
     "bun-types": "1.3.14",
+    "node-pty": "^1.1.0",
+    "puppeteer-core": "^25.3.0",
     typescript: "^6.0.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.16.0",
-    "oh-my-opencode-darwin-x64": "4.16.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.16.0",
-    "oh-my-opencode-linux-arm64": "4.16.0",
-    "oh-my-opencode-linux-arm64-musl": "4.16.0",
-    "oh-my-opencode-linux-x64": "4.16.0",
-    "oh-my-opencode-linux-x64-baseline": "4.16.0",
-    "oh-my-opencode-linux-x64-musl": "4.16.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.16.0",
-    "oh-my-opencode-windows-arm64": "4.16.0",
-    "oh-my-opencode-windows-x64": "4.16.0",
-    "oh-my-opencode-windows-x64-baseline": "4.16.0"
+    "oh-my-opencode-darwin-arm64": "4.16.2",
+    "oh-my-opencode-darwin-x64": "4.16.2",
+    "oh-my-opencode-darwin-x64-baseline": "4.16.2",
+    "oh-my-opencode-linux-arm64": "4.16.2",
+    "oh-my-opencode-linux-arm64-musl": "4.16.2",
+    "oh-my-opencode-linux-x64": "4.16.2",
+    "oh-my-opencode-linux-x64-baseline": "4.16.2",
+    "oh-my-opencode-linux-x64-musl": "4.16.2",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.16.2",
+    "oh-my-opencode-windows-arm64": "4.16.2",
+    "oh-my-opencode-windows-x64": "4.16.2",
+    "oh-my-opencode-windows-x64-baseline": "4.16.2"
   },
   overrides: {
     "@earendil-works/pi-agent-core": "0.80.3",
@@ -89116,13 +89900,13 @@ function syncCachePackageJsonToIntent(pluginInfo) {
   };
 }
 // packages/omo-opencode/src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync65 } from "fs";
-import { dirname as dirname22, join as join76 } from "path";
+import { existsSync as existsSync70 } from "fs";
+import { dirname as dirname23, join as join79 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 // packages/omo-opencode/src/shared/migrate-legacy-config-file.ts
 init_logger2();
-import { existsSync as existsSync62, readFileSync as readFileSync41, renameSync as renameSync6, rmSync as rmSync3 } from "fs";
-import { join as join73, dirname as dirname21, basename as basename12 } from "path";
+import { existsSync as existsSync67, readFileSync as readFileSync44, renameSync as renameSync6, rmSync as rmSync3 } from "fs";
+import { join as join76, dirname as dirname22, basename as basename13 } from "path";
 
 // packages/omo-opencode/src/shared/migration/migrations-sidecar.ts
 init_migrations_sidecar();
@@ -89130,9 +89914,9 @@ init_migrations_sidecar();
 // packages/omo-opencode/src/shared/migrate-legacy-config-file.ts
 init_plugin_identity();
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname21(legacyPath);
-  const ext = basename12(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join73(dir, `${CONFIG_BASENAME}${ext}`);
+  const dir = dirname22(legacyPath);
+  const ext = basename13(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
+  return join76(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -89165,13 +89949,13 @@ function archiveLegacyConfigFile(legacyPath) {
 }
 function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   const legacySidecarPath = getSidecarPath(legacyPath);
-  if (!existsSync62(legacySidecarPath))
+  if (!existsSync67(legacySidecarPath))
     return true;
   const canonicalSidecarPath = getSidecarPath(canonicalPath);
-  if (existsSync62(canonicalSidecarPath))
+  if (existsSync67(canonicalSidecarPath))
     return true;
   try {
-    const content = readFileSync41(legacySidecarPath, "utf-8");
+    const content = readFileSync44(legacySidecarPath, "utf-8");
     writeFileAtomically2(canonicalSidecarPath, content);
     log2("[migrateLegacyConfigFile] Migrated legacy migration sidecar to canonical path", {
       from: legacySidecarPath,
@@ -89188,15 +89972,15 @@ function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync62(legacyPath))
+  if (!existsSync67(legacyPath))
     return false;
-  if (!basename12(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
+  if (!basename13(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync62(canonicalPath))
+  if (existsSync67(canonicalPath))
     return false;
   try {
-    const content = readFileSync41(legacyPath, "utf-8");
+    const content = readFileSync44(legacyPath, "utf-8");
     writeFileAtomically2(canonicalPath, content);
     const migratedSidecar = migrateLegacySidecarFile(legacyPath, canonicalPath);
     const archivedLegacyConfig = archiveLegacyConfigFile(legacyPath);
@@ -89232,8 +90016,8 @@ function toReadableStream2(stream) {
 function wrapNodeProcess2(proc) {
   let resolveExited;
   let exitCode = null;
-  const exited = new Promise((resolve18, reject) => {
-    resolveExited = resolve18;
+  const exited = new Promise((resolve19, reject) => {
+    resolveExited = resolve19;
     proc.on("error", (error) => {
       if (exitCode === null) {
         exitCode = 1;
@@ -89285,13 +90069,13 @@ function spawnWithWindowsHide(command, options) {
   return wrapNodeProcess2(proc);
 }
 // packages/omo-opencode/src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync63 } from "fs";
-import { join as join74 } from "path";
+import { existsSync as existsSync68 } from "fs";
+import { join as join77 } from "path";
 init_logger2();
 var BUN_INSTALL_TIMEOUT_SECONDS = 60;
 var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
 function getDefaultWorkspaceDir() {
-  return join74(getOpenCodeCacheDir(), "packages");
+  return join77(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -89317,7 +90101,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync63(packageJsonPath)) {
+  if (!existsSync68(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -89332,8 +90116,8 @@ async function runBunInstallWithDetails(options) {
     });
     const outputPromise = Promise.all([readProcessOutput(proc.stdout), readProcessOutput(proc.stderr)]).then(([stdout, stderr]) => ({ stdout, stderr }));
     let timeoutId;
-    const timeoutPromise = new Promise((resolve18) => {
-      timeoutId = setTimeout(() => resolve18("timeout"), BUN_INSTALL_TIMEOUT_MS);
+    const timeoutPromise = new Promise((resolve19) => {
+      timeoutId = setTimeout(() => resolve19("timeout"), BUN_INSTALL_TIMEOUT_MS);
     });
     const exitPromise = proc.exited.then(() => "completed");
     const result = await Promise.race([exitPromise, timeoutPromise]);
@@ -89534,15 +90318,15 @@ Restart OpenCode to apply.`,
 // packages/omo-opencode/src/hooks/auto-update-checker/hook/background-update-check.ts
 function defaultGetModuleHostingWorkspace() {
   try {
-    const currentDir = dirname22(fileURLToPath4(import.meta.url));
+    const currentDir = dirname23(fileURLToPath4(import.meta.url));
     const pkgJsonPath = findPackageJsonUp(currentDir);
     if (!pkgJsonPath)
       return null;
-    const pkgDir = dirname22(pkgJsonPath);
-    const nodeModulesDir = dirname22(pkgDir);
+    const pkgDir = dirname23(pkgJsonPath);
+    const nodeModulesDir = dirname23(pkgDir);
     if (nodeModulesDir.split(/[\\/]/).pop() !== "node_modules")
       return null;
-    return dirname22(nodeModulesDir);
+    return dirname23(nodeModulesDir);
   } catch (error) {
     if (error instanceof Error) {
       return null;
@@ -89554,8 +90338,8 @@ function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
 }
 var defaultDeps2 = {
-  existsSync: existsSync65,
-  join: join76,
+  existsSync: existsSync70,
+  join: join79,
   runBunInstallWithDetails,
   log: log2,
   getOpenCodeCacheDir,
@@ -89827,7 +90611,7 @@ async function showSpinnerToast(ctx, version, message) {
         duration: frameInterval + 50
       }
     }).catch(ignoreToastError);
-    await new Promise((resolve18) => setTimeout(resolve18, frameInterval));
+    await new Promise((resolve19) => setTimeout(resolve19, frameInterval));
   }
 }
 
@@ -89926,9 +90710,9 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
 }
 // packages/omo-opencode/src/hooks/codegraph-bootstrap/hook.ts
 init_src();
-import { existsSync as existsSync66 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 import { homedir as homedir21 } from "os";
-import { join as join77 } from "path";
+import { join as join80 } from "path";
 
 // packages/omo-opencode/src/hooks/codegraph-bootstrap/command-runner.ts
 init_src();
@@ -89950,7 +90734,7 @@ function resolveExitCode(error) {
 async function runCodegraphCommand(projectRoot, command, args, options) {
   const { execFile: execFile3 } = await import("child_process");
   const invocation = resolveCodegraphCommandInvocation(command, args);
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     execFile3(invocation.command, [...invocation.args], {
       cwd: projectRoot,
       encoding: "utf8",
@@ -89960,10 +90744,10 @@ async function runCodegraphCommand(projectRoot, command, args, options) {
       windowsHide: true
     }, (error, stdout, stderr) => {
       if (error === null) {
-        resolve18({ exitCode: 0, stderr: toOutputText(stderr), stdout: toOutputText(stdout), timedOut: false });
+        resolve19({ exitCode: 0, stderr: toOutputText(stderr), stdout: toOutputText(stdout), timedOut: false });
         return;
       }
-      resolve18({
+      resolve19({
         exitCode: resolveExitCode(error),
         stderr: toOutputText(stderr),
         stdout: toOutputText(stdout),
@@ -89985,7 +90769,7 @@ function resolveCodegraphCommandInvocation(command, args, platform2 = process.pl
 
 // packages/omo-opencode/src/hooks/codegraph-bootstrap/project-root.ts
 init_src();
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 var PROJECT_ROOT_KEYS = ["directory", "worktree", "cwd", "projectRoot", "projectPath"];
 function readStringField(record, key) {
   const value = record[key];
@@ -90018,8 +90802,8 @@ function readRecordRoot(record) {
 }
 function resolveCodegraphProjectRoot(properties, fallbackDirectory) {
   if (!isRecord(properties))
-    return resolve18(fallbackDirectory);
-  return resolve18(readRecordRoot(properties) ?? fallbackDirectory);
+    return resolve19(fallbackDirectory);
+  return resolve19(readRecordRoot(properties) ?? fallbackDirectory);
 }
 
 // packages/omo-opencode/src/hooks/codegraph-bootstrap/status.ts
@@ -90081,14 +90865,14 @@ function defaultSchedule(task) {
   timer.unref?.();
 }
 function defaultInstallDir2() {
-  return join77(homedir21(), ".omo", "codegraph");
+  return join80(homedir21(), ".omo", "codegraph");
 }
 function provisionedBinFromInstallDir(installDir) {
   if (installDir === undefined)
     return null;
   const binaryName = process.platform === "win32" ? "codegraph.cmd" : "codegraph";
-  const candidate = join77(installDir, "bin", binaryName);
-  return existsSync66(candidate) ? candidate : null;
+  const candidate = join80(installDir, "bin", binaryName);
+  return existsSync71(candidate) ? candidate : null;
 }
 function codegraphEnv(deps, config) {
   const env2 = deps.buildEnv();
@@ -90117,7 +90901,7 @@ async function resolveOrProvisionCommand(deps, config) {
   const installDir = config.install_dir ?? defaultInstallDir2();
   const provisioned = await deps.ensureProvisioned({
     installDir,
-    lockDir: join77(installDir, "locks"),
+    lockDir: join80(installDir, "locks"),
     version: CODEGRAPH_VERSION
   });
   if (!provisioned.provisioned || provisioned.binPath === undefined) {
@@ -90132,8 +90916,8 @@ async function resolveOrProvisionCommand(deps, config) {
 async function runBootstrap(projectRoot, config, deps) {
   try {
     const autoInit = config.auto_init !== false;
-    const codegraphPath = join77(projectRoot, ".codegraph");
-    if (!autoInit && !existsSync66(codegraphPath)) {
+    const codegraphPath = join80(projectRoot, ".codegraph");
+    if (!autoInit && !existsSync71(codegraphPath)) {
       deps.log("[codegraph-bootstrap] CodeGraph auto_init disabled and .codegraph not present; skipping bootstrap", {
         projectRoot
       });
@@ -90221,7 +91005,7 @@ function createCodegraphBootstrapHook(ctx, config, depsOverride = {}) {
 // packages/omo-opencode/src/hooks/ast-grep-sg-provision/hook.ts
 init_src();
 import { homedir as homedir22 } from "os";
-import { join as join78 } from "path";
+import { join as join81 } from "path";
 var provisionedTargets = new Set;
 function defaultSchedule2(task) {
   const timer = setTimeout(() => {
@@ -90248,7 +91032,7 @@ var defaultDeps5 = {
 function createAstGrepSgProvisionHook(depsOverride = {}) {
   const deps = { ...defaultDeps5, ...depsOverride };
   const platform2 = deps.platform ?? process.platform;
-  const targetDir = astGrepRuntimeDir(join78(deps.homeDir(), ".omo"), platform2, deps.arch ?? process.arch);
+  const targetDir = astGrepRuntimeDir(join81(deps.homeDir(), ".omo"), platform2, deps.arch ?? process.arch);
   return {
     event(input) {
       try {
@@ -90269,17 +91053,17 @@ function createAstGrepSgProvisionHook(depsOverride = {}) {
 }
 // packages/omo-opencode/src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync67,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync43,
-  writeFileSync as writeFileSync15,
-  unlinkSync as unlinkSync10
+  existsSync as existsSync72,
+  mkdirSync as mkdirSync16,
+  readFileSync as readFileSync46,
+  writeFileSync as writeFileSync16,
+  unlinkSync as unlinkSync11
 } from "fs";
-import { join as join80 } from "path";
+import { join as join83 } from "path";
 
 // packages/omo-opencode/src/hooks/agent-usage-reminder/constants.ts
-import { join as join79 } from "path";
-var AGENT_USAGE_REMINDER_STORAGE = join79(OPENCODE_STORAGE, "agent-usage-reminder");
+import { join as join82 } from "path";
+var AGENT_USAGE_REMINDER_STORAGE = join82(OPENCODE_STORAGE, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -90325,14 +91109,14 @@ ALWAYS prefer: Multiple parallel task calls > Direct tool calls
 
 // packages/omo-opencode/src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath2(sessionID) {
-  return join80(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join83(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync67(filePath))
+  if (!existsSync72(filePath))
     return null;
   try {
-    const content = readFileSync43(filePath, "utf-8");
+    const content = readFileSync46(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     error instanceof Error;
@@ -90340,16 +91124,16 @@ function loadAgentUsageState(sessionID) {
   }
 }
 function saveAgentUsageState(state3) {
-  if (!existsSync67(AGENT_USAGE_REMINDER_STORAGE)) {
-    mkdirSync15(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
+  if (!existsSync72(AGENT_USAGE_REMINDER_STORAGE)) {
+    mkdirSync16(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath2(state3.sessionID);
-  writeFileSync15(filePath, JSON.stringify(state3, null, 2));
+  writeFileSync16(filePath, JSON.stringify(state3, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync67(filePath)) {
-    unlinkSync10(filePath);
+  if (existsSync72(filePath)) {
+    unlinkSync11(filePath);
   }
 }
 
@@ -93963,7 +94747,7 @@ Tests are the FLOOR (always required). Surface artifact is the CEILING (also req
 | Changes build output | Run the build. Verify the output files exist and are correct. |
 | Modifies API behavior | Call the endpoint. Show the response. |
 | Changes UI rendering | Use Chrome to drive the REAL page; if Chrome is not available, download and use agent-browser (https://github.com/vercel-labs/agent-browser). Capture screenshot + action log. |
-| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or \`tmux capture-pane\` (TUI), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
+| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or the xterm.js web terminal render (TUI; NEVER \`tmux capture-pane\` - it degrades color and CJK width), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
 | Changes a desktop/GUI (non-page) surface | Computer use: OS-level GUI automation against the running app. Capture action log + screenshot. |
 | Adds a new tool/hook/feature | Test it end-to-end in a real scenario. |
 | Modifies config handling | Load the config. Verify it parses correctly. |
@@ -94325,7 +95109,7 @@ Trigger if user said "\uC5C4\uBC00"/"strictly"/"rigorously"/"properly review", o
 | Changes build output | Run the build. Verify output files exist and are correct. |
 | Modifies API behavior | Call the endpoint. Show the response. |
 | Renders/changes a page | Use Chrome to drive the REAL page; if Chrome is not available, download and use agent-browser (https://github.com/vercel-labs/agent-browser). Capture screenshot + action log. |
-| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or \`tmux capture-pane\` (TUI), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
+| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or the xterm.js web terminal render (TUI; NEVER \`tmux capture-pane\` - it degrades color and CJK width), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
 | Drives a desktop/GUI (non-page) surface | Computer use: OS-level GUI automation against the running app. Capture action log + screenshot. |
 | Adds a new tool/hook/feature | Test it end-to-end in a real scenario. |
 | Modifies config handling | Load the config. Verify it parses correctly. |
@@ -94545,7 +95329,7 @@ Tests are necessary and insufficient. Exercise the real surface.
 | CLI | Run the command and show stdout/stderr. |
 | API | Call the endpoint and show status/body. |
 | UI | Drive the page in a browser and capture a screenshot or trace. |
-| TUI | Capture the terminal pane and verify layout. |
+| TUI | Render through the xterm.js web terminal and screenshot it (NEVER \`tmux capture-pane\`); verify color, layout, and CJK width. |
 | Config | Load the config and verify the parsed shape. |
 | Prompt or mode | Verify the prompt loads or the registry resolves it. |
 | Build output | Run build and verify exit code 0. |
@@ -94740,7 +95524,7 @@ lsp_diagnostics catches type errors only. Logic bugs, missing behavior, broken f
 | Changes build output | Run build. Verify output files. |
 | Modifies API behavior | Call the endpoint. Show response. |
 | Renders/changes a page | Use Chrome to drive the page; if Chrome is not available, download and use agent-browser (https://github.com/vercel-labs/agent-browser). Screenshot + action log. |
-| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or \`tmux capture-pane\` (TUI), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
+| Changes UI rendering or a TUI/terminal layout (incl. CJK/Korean/Japanese/Chinese text) | Load the visual-qa skill: capture reference + actual screenshots (web) or the xterm.js web terminal render (TUI; NEVER \`tmux capture-pane\` - it degrades color and CJK width), run its bundled pixel-diff / column-width script, and get the dual read-only verdict (design-system + functional integrity, and visual fidelity + CJK precision). Record the diff/score artifact. |
 | Drives a desktop GUI | Computer use: OS-level GUI automation against the running app. Action log + screenshot. |
 | Adds tool/hook/feature | Test end-to-end in a real scenario. |
 | Modifies config handling | Load config. Verify parsed shape. |
@@ -95299,17 +96083,17 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // packages/omo-opencode/src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync68,
-  mkdirSync as mkdirSync16,
-  readFileSync as readFileSync44,
-  writeFileSync as writeFileSync16,
-  unlinkSync as unlinkSync11
+  existsSync as existsSync73,
+  mkdirSync as mkdirSync17,
+  readFileSync as readFileSync47,
+  writeFileSync as writeFileSync17,
+  unlinkSync as unlinkSync12
 } from "fs";
-import { join as join82 } from "path";
+import { join as join85 } from "path";
 
 // packages/omo-opencode/src/hooks/interactive-bash-session/constants.ts
-import { join as join81 } from "path";
-var INTERACTIVE_BASH_SESSION_STORAGE = join81(OPENCODE_STORAGE, "interactive-bash-session");
+import { join as join84 } from "path";
+var INTERACTIVE_BASH_SESSION_STORAGE = join84(OPENCODE_STORAGE, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -95321,14 +96105,14 @@ function buildSessionReminderMessage(sessions) {
 
 // packages/omo-opencode/src/hooks/interactive-bash-session/storage.ts
 function getStoragePath3(sessionID) {
-  return join82(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join85(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync68(filePath))
+  if (!existsSync73(filePath))
     return null;
   try {
-    const content = readFileSync44(filePath, "utf-8");
+    const content = readFileSync47(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -95343,8 +96127,8 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state3) {
-  if (!existsSync68(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync16(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync73(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync17(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath3(state3.sessionID);
   const serialized = {
@@ -95352,12 +96136,12 @@ function saveInteractiveBashSessionState(state3) {
     tmuxSessions: Array.from(state3.tmuxSessions),
     updatedAt: state3.updatedAt
   };
-  writeFileSync16(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync17(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync68(filePath)) {
-    unlinkSync11(filePath);
+  if (existsSync73(filePath)) {
+    unlinkSync12(filePath);
   }
 }
 
@@ -96415,7 +97199,7 @@ async function withTimeout(promise, timeoutMs) {
 var USER_MESSAGE_IN_PROGRESS_WINDOW_MS = 2000;
 var RAPID_IDLE_DEDUP_MS = 500;
 function sleep2(ms) {
-  return ms > 0 ? new Promise((resolve19) => setTimeout(resolve19, ms)) : Promise.resolve();
+  return ms > 0 ? new Promise((resolve20) => setTimeout(resolve20, ms)) : Promise.resolve();
 }
 function hasActiveBackgroundTasks(backgroundManager, sessionID) {
   return backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "pending" || task.status === "running") : false;
@@ -97299,7 +98083,7 @@ async function handleDetectedCompletion(ctx, input) {
 init_logger2();
 init_constants3();
 init_constants3();
-import { existsSync as existsSync70, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync75, readFileSync as readFileSync49 } from "fs";
 function extractTranscriptEntryText(entry) {
   if (typeof entry.content === "string")
     return entry.content;
@@ -97337,9 +98121,9 @@ function detectCompletionInTranscript(transcriptPath, promise, startedAt) {
   if (!transcriptPath)
     return false;
   try {
-    if (!existsSync70(transcriptPath))
+    if (!existsSync75(transcriptPath))
       return false;
-    const content = readFileSync46(transcriptPath, "utf-8");
+    const content = readFileSync49(transcriptPath, "utf-8");
     const pattern = buildPromisePattern(promise);
     const lines = content.split(`
 `).filter((line) => line.trim());
@@ -98066,7 +98850,9 @@ function createRalphLoopEventHandlerImpl(ctx, options) {
     const runtimeRetryActivitySessionID = getRuntimeRetryActivitySessionID(event.type, props);
     if (runtimeRetryActivitySessionID) {
       runtime5.runtimeErrorRetriedSessions.delete(runtimeRetryActivitySessionID);
-      releasePromptAsyncReservation(runtimeRetryActivitySessionID, "ralph-loop");
+      releasePromptAsyncReservation(runtimeRetryActivitySessionID, "ralph-loop", {
+        supersedeTransientRetryOwners: true
+      });
       runtime5.recentHandledSyntheticIdleAt.delete(runtimeRetryActivitySessionID);
     }
     if (event.type === "session.idle") {
@@ -98436,13 +99222,13 @@ function findSlashCommandPartIndex(parts) {
   return -1;
 }
 // packages/omo-opencode/src/hooks/auto-slash-command/executor.ts
-import { dirname as dirname30 } from "path";
+import { dirname as dirname31 } from "path";
 
 // packages/omo-opencode/src/shared/command-executor/resolve-commands-in-text.ts
 init_resolve_commands_in_text();
 // packages/skills-loader-core/src/features/opencode-skill-loader/loader.ts
 init_src();
-import { join as join90 } from "path";
+import { join as join93 } from "path";
 
 // packages/shared-skills/index.mjs
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -98452,21 +99238,21 @@ function sharedSkillsRootPath() {
 
 // packages/skills-loader-core/src/shared/claude-config-dir.ts
 init_src();
-import { join as join84 } from "path";
+import { join as join87 } from "path";
 function getClaudeConfigDir2() {
   const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
   if (envConfigDir) {
     return envConfigDir;
   }
-  return join84(getHomeDirectory(), ".claude");
+  return join87(getHomeDirectory(), ".claude");
 }
 // packages/skills-loader-core/src/shared/opencode-command-dirs.ts
-import { basename as basename13, dirname as dirname25, join as join86 } from "path";
+import { basename as basename14, dirname as dirname26, join as join89 } from "path";
 
 // packages/skills-loader-core/src/shared/opencode-config-dir.ts
-import { existsSync as existsSync71, realpathSync as realpathSync12 } from "fs";
+import { existsSync as existsSync76, realpathSync as realpathSync12 } from "fs";
 import { homedir as homedir24 } from "os";
-import { join as join85, posix as posix4, resolve as resolve19, win32 as win325 } from "path";
+import { join as join88, posix as posix4, resolve as resolve20, win32 as win325 } from "path";
 
 // packages/skills-loader-core/src/shared/plugin-identity.ts
 init_src();
@@ -98499,15 +99285,15 @@ function getTauriConfigDir2(identifier) {
   const platform2 = process.platform;
   switch (platform2) {
     case "darwin":
-      return join85(homedir24(), "Library", "Application Support", identifier);
+      return join88(homedir24(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join85(homedir24(), "AppData", "Roaming");
+      const appData = process.env.APPDATA || join88(homedir24(), "AppData", "Roaming");
       return win325.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join85(homedir24(), ".config");
-      return join85(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join88(homedir24(), ".config");
+      return join88(xdgConfig, identifier);
     }
   }
 }
@@ -98515,8 +99301,8 @@ function resolveConfigPath2(pathValue) {
   if (isWslEnvironment2() && pathValue.startsWith("/")) {
     return posix4.normalize(pathValue);
   }
-  const resolvedPath = resolve19(pathValue);
-  if (!existsSync71(resolvedPath))
+  const resolvedPath = resolve20(pathValue);
+  if (!existsSync76(resolvedPath))
     return resolvedPath;
   try {
     return realpathSync12(resolvedPath);
@@ -98550,8 +99336,8 @@ function getWslLinuxHomeDir2(windowsConfigRoot) {
 function getCliDefaultConfigDir2() {
   const envXdgConfig = process.env.XDG_CONFIG_HOME?.trim();
   const shouldIgnoreWindowsXdg = envXdgConfig !== undefined && envXdgConfig.length > 0 && isWslEnvironment2() && isWindowsUserConfigRoot2(envXdgConfig);
-  const xdgConfig = shouldIgnoreWindowsXdg ? posix4.join(getWslLinuxHomeDir2(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join85(homedir24(), ".config");
-  const configDir = isWslEnvironment2() ? posix4.join(xdgConfig, "opencode") : join85(xdgConfig, "opencode");
+  const xdgConfig = shouldIgnoreWindowsXdg ? posix4.join(getWslLinuxHomeDir2(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join88(homedir24(), ".config");
+  const configDir = isWslEnvironment2() ? posix4.join(xdgConfig, "opencode") : join88(xdgConfig, "opencode");
   return resolveConfigPath2(configDir);
 }
 function getCliCustomConfigDir2() {
@@ -98584,9 +99370,9 @@ function getOpenCodeConfigDir2(options) {
   const tauriDir = process.platform === "win32" ? win325.isAbsolute(tauriDirBase) ? win325.normalize(tauriDirBase) : win325.resolve(tauriDirBase) : resolveConfigPath2(tauriDirBase);
   if (checkExisting) {
     const legacyDir = getCliConfigDir2();
-    const legacyConfig = join85(legacyDir, "opencode.json");
-    const legacyConfigC = join85(legacyDir, "opencode.jsonc");
-    if (existsSync71(legacyConfig) || existsSync71(legacyConfigC)) {
+    const legacyConfig = join88(legacyDir, "opencode.json");
+    const legacyConfigC = join88(legacyDir, "opencode.jsonc");
+    if (existsSync76(legacyConfig) || existsSync76(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -98595,11 +99381,11 @@ function getOpenCodeConfigDir2(options) {
 
 // packages/skills-loader-core/src/shared/opencode-command-dirs.ts
 function getParentOpencodeConfigDir2(configDir) {
-  const parentDir = dirname25(configDir);
-  if (basename13(parentDir) !== "profiles") {
+  const parentDir = dirname26(configDir);
+  if (basename14(parentDir) !== "profiles") {
     return null;
   }
-  return dirname25(parentDir);
+  return dirname26(parentDir);
 }
 function getOpenCodeSkillDirs(options) {
   const configDirs = getOpenCodeConfigDirs2(options);
@@ -98607,21 +99393,21 @@ function getOpenCodeSkillDirs(options) {
     ...configDirs.flatMap((configDir) => {
       const parentConfigDir = getParentOpencodeConfigDir2(configDir);
       return [
-        join86(configDir, "skills"),
-        join86(configDir, "skill"),
-        ...parentConfigDir ? [join86(parentConfigDir, "skills"), join86(parentConfigDir, "skill")] : []
+        join89(configDir, "skills"),
+        join89(configDir, "skill"),
+        ...parentConfigDir ? [join89(parentConfigDir, "skills"), join89(parentConfigDir, "skill")] : []
       ];
     })
   ]));
 }
 // packages/skills-loader-core/src/shared/project-discovery-dirs.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync72, realpathSync as realpathSync13 } from "fs";
-import { dirname as dirname26, join as join87, resolve as resolve20, win32 as win326 } from "path";
+import { existsSync as existsSync77, realpathSync as realpathSync13 } from "fs";
+import { dirname as dirname27, join as join90, resolve as resolve21, win32 as win326 } from "path";
 var worktreePathCache2 = new Map;
 function normalizePath4(path17) {
-  const resolvedPath = process.platform !== "win32" && win326.isAbsolute(path17) ? path17 : resolve20(path17);
-  if (!existsSync72(resolvedPath)) {
+  const resolvedPath = process.platform !== "win32" && win326.isAbsolute(path17) ? path17 : resolve21(path17);
+  if (!existsSync77(resolvedPath)) {
     return resolvedPath;
   }
   try {
@@ -98652,8 +99438,8 @@ function findAncestorDirectories2(startDirectory, targetPaths, stopDirectory) {
   const stopDirectoryKey = resolvedStopDirectory ? pathKey2(resolvedStopDirectory) : undefined;
   while (true) {
     for (const targetPath of targetPaths) {
-      const candidateDirectory = join87(currentDirectory, ...targetPath);
-      if (!existsSync72(candidateDirectory)) {
+      const candidateDirectory = join90(currentDirectory, ...targetPath);
+      if (!existsSync77(candidateDirectory)) {
         continue;
       }
       const normalizedCandidateDirectory = normalizePath4(candidateDirectory);
@@ -98667,7 +99453,7 @@ function findAncestorDirectories2(startDirectory, targetPaths, stopDirectory) {
     if (stopDirectoryKey === pathKey2(currentDirectory)) {
       return directories;
     }
-    const parentDirectory = dirname26(currentDirectory);
+    const parentDirectory = dirname27(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return directories;
     }
@@ -98675,7 +99461,7 @@ function findAncestorDirectories2(startDirectory, targetPaths, stopDirectory) {
   }
 }
 function detectWorktreePath2(directory) {
-  const resolvedDirectory = resolve20(directory);
+  const resolvedDirectory = resolve21(directory);
   const cacheKey = pathKey2(normalizePath4(resolvedDirectory));
   if (worktreePathCache2.has(cacheKey)) {
     return worktreePathCache2.get(cacheKey);
@@ -98711,7 +99497,7 @@ function findProjectOpencodeSkillDirs(startDirectory, stopDirectory) {
   ], stopDirectory ?? detectWorktreePath2(startDirectory));
 }
 // packages/skills-loader-core/src/shared/skill-path-resolver.ts
-import { isAbsolute as isAbsolute12, posix as posix5, relative as relative11, resolve as resolve21, win32 as win327 } from "path";
+import { isAbsolute as isAbsolute13, posix as posix5, relative as relative12, resolve as resolve22, win32 as win327 } from "path";
 function toDisplayPath2(path17) {
   return path17.replaceAll("\\", "/");
 }
@@ -98750,9 +99536,9 @@ function resolveSkillPathReferences2(content, basePath) {
       }
       return relativePath.endsWith("/") && !resolvedPath2.endsWith("/") ? `${resolvedPath2}/` : resolvedPath2;
     }
-    const resolvedPath = resolve21(normalizedBase, relativePath);
-    const relativePathFromBase = relative11(normalizedBase, resolvedPath);
-    if (relativePathFromBase.startsWith("..") || isAbsolute12(relativePathFromBase)) {
+    const resolvedPath = resolve22(normalizedBase, relativePath);
+    const relativePathFromBase = relative12(normalizedBase, resolvedPath);
+    if (relativePathFromBase.startsWith("..") || isAbsolute13(relativePathFromBase)) {
       return match;
     }
     const displayPath = toDisplayPath2(resolvedPath);
@@ -98875,12 +99661,12 @@ function deduplicateSkillsByName(skills) {
 // packages/skills-loader-core/src/features/opencode-skill-loader/skill-directory-loader.ts
 init_src();
 import * as fs19 from "fs/promises";
-import { join as join89 } from "path";
+import { join as join92 } from "path";
 
 // packages/skills-loader-core/src/features/opencode-skill-loader/loaded-skill-from-path.ts
 init_src();
 import * as fs18 from "fs/promises";
-import { basename as basename14 } from "path";
+import { basename as basename15 } from "path";
 
 // packages/skills-loader-core/src/features/opencode-skill-loader/allowed-tools-parser.ts
 function parseAllowedTools(allowedTools) {
@@ -98895,7 +99681,7 @@ function parseAllowedTools(allowedTools) {
 // packages/skills-loader-core/src/features/opencode-skill-loader/skill-mcp-config.ts
 init_js_yaml();
 import * as fs17 from "fs/promises";
-import { join as join88 } from "path";
+import { join as join91 } from "path";
 function parseSkillMcpConfigFromFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch)
@@ -98914,7 +99700,7 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   return;
 }
 async function loadMcpJsonFromDir(skillDir) {
-  const mcpJsonPath = join88(skillDir, "mcp.json");
+  const mcpJsonPath = join91(skillDir, "mcp.json");
   try {
     const content = await fs17.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -98996,7 +99782,7 @@ $ARGUMENTS
   }
 }
 function inferSkillNameFromFileName(filePath) {
-  return basename14(filePath, ".md");
+  return basename15(filePath, ".md");
 }
 
 // packages/skills-loader-core/src/features/opencode-skill-loader/skill-directory-loader.ts
@@ -99030,10 +99816,10 @@ async function loadSkillsFromDir(options) {
   const directories = entries.filter((entry) => !entry.name.startsWith(".") && (entry.isDirectory() || entry.isSymbolicLink()));
   const files = entries.filter((entry) => !entry.name.startsWith(".") && !entry.isDirectory() && !entry.isSymbolicLink() && isMarkdownFile(entry));
   for (const entry of directories) {
-    const entryPath = join89(options.skillsDir, entry.name);
+    const entryPath = join92(options.skillsDir, entry.name);
     const resolvedPath = await resolveSymlinkAsync(entryPath);
     const dirName = entry.name;
-    const skillMdPath = join89(resolvedPath, "SKILL.md");
+    const skillMdPath = join92(resolvedPath, "SKILL.md");
     if (await canAccessFile(skillMdPath)) {
       const skill = await loadSkillFromPath({
         skillPath: skillMdPath,
@@ -99047,7 +99833,7 @@ async function loadSkillsFromDir(options) {
       }
       continue;
     }
-    const namedSkillMdPath = join89(resolvedPath, `${dirName}.md`);
+    const namedSkillMdPath = join92(resolvedPath, `${dirName}.md`);
     if (await canAccessFile(namedSkillMdPath)) {
       const skill = await loadSkillFromPath({
         skillPath: namedSkillMdPath,
@@ -99078,7 +99864,7 @@ async function loadSkillsFromDir(options) {
     }
   }
   for (const entry of files) {
-    const entryPath = join89(options.skillsDir, entry.name);
+    const entryPath = join92(options.skillsDir, entry.name);
     const baseName = inferSkillNameFromFileName(entryPath);
     const skill = await loadSkillFromPath({
       skillPath: entryPath,
@@ -99096,7 +99882,7 @@ async function loadSkillsFromDir(options) {
 
 // packages/skills-loader-core/src/features/opencode-skill-loader/loader.ts
 async function loadUserSkills() {
-  const userSkillsDir = join90(getClaudeConfigDir2(), "skills");
+  const userSkillsDir = join93(getClaudeConfigDir2(), "skills");
   const skills = await loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" });
   return skillsToCommandDefinitionRecord(skills);
 }
@@ -99121,7 +99907,7 @@ async function loadProjectAgentsSkills(directory) {
   return skillsToCommandDefinitionRecord(deduplicateSkillsByName(allSkills.flat()));
 }
 async function loadGlobalAgentsSkills(homeDirectory = getHomeDirectory()) {
-  const agentsGlobalDir = join90(homeDirectory, ".agents", "skills");
+  const agentsGlobalDir = join93(homeDirectory, ".agents", "skills");
   const skills = await loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" });
   return skillsToCommandDefinitionRecord(skills);
 }
@@ -99192,7 +99978,7 @@ async function discoverSkills(options = {}) {
   ]);
 }
 async function discoverUserClaudeSkills() {
-  const userSkillsDir = join90(getClaudeConfigDir2(), "skills");
+  const userSkillsDir = join93(getClaudeConfigDir2(), "skills");
   return loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" });
 }
 async function discoverProjectClaudeSkills(directory) {
@@ -99219,17 +100005,17 @@ async function discoverProjectAgentsSkills(directory) {
   return deduplicateSkillsByName(allSkills.flat());
 }
 async function discoverGlobalAgentsSkills(homeDirectory = getHomeDirectory()) {
-  const agentsGlobalDir = join90(homeDirectory, ".agents", "skills");
+  const agentsGlobalDir = join93(homeDirectory, ".agents", "skills");
   return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" });
 }
 // packages/skills-loader-core/src/features/opencode-skill-loader/merger/builtin-skill-converter.ts
-import { existsSync as existsSync73 } from "fs";
-import { join as join91 } from "path";
+import { existsSync as existsSync78 } from "fs";
+import { join as join94 } from "path";
 function resolveBuiltinSkillPath(builtin) {
   if (builtin.resolvedPath !== undefined)
     return builtin.resolvedPath;
-  const sharedSkillPath = join91(sharedSkillsRootPath(), builtin.name);
-  return existsSync73(sharedSkillPath) ? sharedSkillPath : undefined;
+  const sharedSkillPath = join94(sharedSkillsRootPath(), builtin.name);
+  return existsSync78(sharedSkillPath) ? sharedSkillPath : undefined;
 }
 function builtinToLoadedSkill(builtin) {
   const definition = {
@@ -99256,8 +100042,8 @@ function builtinToLoadedSkill(builtin) {
 
 // packages/skills-loader-core/src/features/opencode-skill-loader/merger/config-skill-entry-loader.ts
 init_src();
-import { existsSync as existsSync74, readFileSync as readFileSync47 } from "fs";
-import { dirname as dirname27, isAbsolute as isAbsolute13, resolve as resolve22 } from "path";
+import { existsSync as existsSync79, readFileSync as readFileSync50 } from "fs";
+import { dirname as dirname28, isAbsolute as isAbsolute14, resolve as resolve23 } from "path";
 import { homedir as homedir25 } from "os";
 function resolveFilePath5(from, configDir) {
   let filePath = from;
@@ -99265,19 +100051,19 @@ function resolveFilePath5(from, configDir) {
     filePath = filePath.slice(6, -1);
   }
   if (filePath.startsWith("~/")) {
-    return resolve22(homedir25(), filePath.slice(2));
+    return resolve23(homedir25(), filePath.slice(2));
   }
-  if (isAbsolute13(filePath)) {
+  if (isAbsolute14(filePath)) {
     return filePath;
   }
   const baseDir = configDir || process.cwd();
-  return resolve22(baseDir, filePath);
+  return resolve23(baseDir, filePath);
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync74(filePath))
+    if (!existsSync79(filePath))
       return null;
-    const content = readFileSync47(filePath, "utf-8");
+    const content = readFileSync50(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch (error) {
@@ -99313,7 +100099,7 @@ function configEntryToLoadedSkill(name, entry, configDir) {
     return null;
   }
   const description = entry.description || fileMetadata.description || "";
-  const resolvedPath = sourcePath ? dirname27(sourcePath) : configDir || process.cwd();
+  const resolvedPath = sourcePath ? dirname28(sourcePath) : configDir || process.cwd();
   const resolvedTemplate = resolveSkillPathReferences2(template.trim(), resolvedPath);
   const wrappedTemplate = `<skill-instruction>
 Base directory for this skill: ${resolvedPath}/
@@ -100143,17 +100929,17 @@ playwright-cli close
   allowedTools: ["Bash(playwright-cli:*)"]
 };
 // packages/skills-loader-core/src/features/builtin-skills/skill-file-loader.ts
-import { readFileSync as readFileSync48 } from "fs";
-import { join as join92 } from "path";
+import { readFileSync as readFileSync51 } from "fs";
+import { join as join95 } from "path";
 init_src();
-function createSharedSkillTemplateLoader(readFile9 = readFileSync48, skillsRootPath = sharedSkillsRootPath()) {
+function createSharedSkillTemplateLoader(readFile9 = readFileSync51, skillsRootPath = sharedSkillsRootPath()) {
   const cache2 = new Map;
   return (skillName) => {
     const cached = cache2.get(skillName);
     if (cached !== undefined)
       return cached;
     try {
-      const { body } = parseFrontmatter(readFile9(join92(skillsRootPath, skillName, "SKILL.md"), "utf8"));
+      const { body } = parseFrontmatter(readFile9(join95(skillsRootPath, skillName, "SKILL.md"), "utf8"));
       cache2.set(skillName, body);
       return body;
     } catch (error) {
@@ -101290,9 +102076,9 @@ var gitMasterSkill = {
   template: GIT_MASTER_TEMPLATE
 };
 // packages/skills-loader-core/src/features/builtin-skills/skills/dev-browser.ts
-import { dirname as dirname28, join as join93 } from "path";
+import { dirname as dirname29, join as join96 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var CURRENT_DIR = dirname28(fileURLToPath6(import.meta.url));
+var CURRENT_DIR = dirname29(fileURLToPath6(import.meta.url));
 var devBrowserSkill = {
   name: "dev-browser",
   description: "Browser automation with persistent page state. Use when users ask to navigate websites, fill forms, take screenshots, extract web data, test web apps, or automate browser workflows. Trigger phrases include 'go to [url]', 'click on', 'fill out the form', 'take a screenshot', 'scrape', 'automate', 'test the website', 'log into', or any browser interaction request.",
@@ -101510,7 +102296,7 @@ console.log({
 await client.disconnect();
 EOF
 \`\`\``,
-  resolvedPath: join93(CURRENT_DIR, "..", "dev-browser")
+  resolvedPath: join96(CURRENT_DIR, "..", "dev-browser")
 };
 // packages/skills-loader-core/src/features/builtin-skills/skills/review-work.ts
 var reviewWorkSkill = {
@@ -102187,13 +102973,13 @@ function mergeSkills(builtinSkills, config, configSourceSkills, userClaudeSkills
 }
 // packages/skills-loader-core/src/features/opencode-skill-loader/loaded-skill-template-extractor.ts
 init_src();
-import { readFileSync as readFileSync49 } from "fs";
+import { readFileSync as readFileSync52 } from "fs";
 function extractSkillTemplate(skill) {
   if (skill.scope === "config" && skill.definition.template) {
     return skill.definition.template;
   }
   if (skill.path) {
-    const content = readFileSync49(skill.path, "utf-8");
+    const content = readFileSync52(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -102510,7 +103296,7 @@ init_src();
 var import_picomatch2 = __toESM(require_picomatch2(), 1);
 import * as fs20 from "fs/promises";
 import { homedir as homedir26 } from "os";
-import { dirname as dirname29, extname as extname2, isAbsolute as isAbsolute14, join as join94, relative as relative12 } from "path";
+import { dirname as dirname30, extname as extname2, isAbsolute as isAbsolute15, join as join97, relative as relative13 } from "path";
 var MAX_RECURSIVE_DEPTH = 10;
 function isHttpUrl(path17) {
   return path17.startsWith("http://") || path17.startsWith("https://");
@@ -102520,12 +103306,12 @@ function toAbsolutePath(path17, configDir) {
     return homedir26();
   }
   if (path17.startsWith("~/")) {
-    return join94(homedir26(), path17.slice(2));
+    return join97(homedir26(), path17.slice(2));
   }
-  if (isAbsolute14(path17)) {
+  if (isAbsolute15(path17)) {
     return path17;
   }
-  return join94(configDir, path17);
+  return join97(configDir, path17);
 }
 function isMarkdownPath(path17) {
   return extname2(path17).toLowerCase() === ".md";
@@ -102539,7 +103325,7 @@ function filterByGlob(skills, sourceBaseDir, globPattern) {
   return skills.filter((skill) => {
     if (!skill.path)
       return false;
-    const rel = normalizePathForGlob(relative12(sourceBaseDir, skill.path));
+    const rel = normalizePathForGlob(relative13(sourceBaseDir, skill.path));
     return import_picomatch2.default.isMatch(rel, globPattern, { dot: true, bash: true });
   });
 }
@@ -102565,13 +103351,13 @@ async function loadSourcePath(options) {
       return [];
     const loaded = await loadSkillFromPath({
       skillPath: realSourcePath,
-      resolvedPath: dirname29(realSourcePath),
+      resolvedPath: dirname30(realSourcePath),
       defaultName: inferSkillNameFromFileName(realSourcePath),
       scope: "config"
     });
     if (!loaded)
       return [];
-    return filterByGlob([loaded], dirname29(realSourcePath), options.globPattern);
+    return filterByGlob([loaded], dirname30(realSourcePath), options.globPattern);
   }
   if (!stat5.isDirectory())
     return [];
@@ -102652,8 +103438,8 @@ function readOpencodeConfigSkills(directory) {
   return { paths, urls };
 }
 // packages/omo-opencode/src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync76, readdirSync as readdirSync19, readFileSync as readFileSync51, statSync as statSync10 } from "fs";
-import { basename as basename15, join as join96 } from "path";
+import { existsSync as existsSync81, readdirSync as readdirSync20, readFileSync as readFileSync54, statSync as statSync11 } from "fs";
+import { basename as basename16, join as join99 } from "path";
 
 // packages/omo-opencode/src/tools/slashcommand/command-discovery-deps.ts
 init_frontmatter2();
@@ -102893,13 +103679,15 @@ This command includes examples for the OpenCode harness. In Codex, do not call O
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent(agent_type="explorer", task_name="...", message="...")\` |
-| \`call_omo_agent(subagent_type="librarian", ...)\` | \`spawn_agent(agent_type="librarian", task_name="...", message="...")\` |
-| \`task(subagent_type="plan", ...)\` | \`spawn_agent(agent_type="plan", task_name="...", message="...")\` |
+| \`call_omo_agent(subagent_type="explore", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})\` |
+| \`call_omo_agent(subagent_type="librarian", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})\` |
+| \`task(subagent_type="plan", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})\` |
 | \`task(subagent_type="oracle", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})\` |
-| \`task(category="...", ...)\` | \`spawn_agent(agent_type="worker", task_name="...", message="...")\` |
-| \`background_output(task_id="...")\` | \`wait_agent(...)\` to wait for subagent completion and mailbox updates |
-| \`team_*(...)\` | Use Codex native subagents plus \`send_message\`, \`followup_task\`, \`wait_agent\`, and \`close_agent\` |
+| \`task(category="...", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})\` |
+| \`background_output(task_id="...")\` | \`multi_agent_v1.wait_agent(...)\` for mailbox signals |
+| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\`, \`multi_agent_v1.send_input\`, \`multi_agent_v1.wait_agent\`, and \`multi_agent_v1.close_agent\` |
+
+Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If \`multi_agent_v1.*\` tools exist, use the table above as written. If instead a flat \`spawn_agent\` with a required \`task_name\` exists (\`multi_agent_v2\`), rewrite every \`multi_agent_v1.*\` example: \`multi_agent_v1.spawn_agent({...,"fork_context":false})\` becomes \`spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})\` (\`"all"\` only when full parent history is truly required); \`send_input\` becomes \`send_message\`; do not call \`close_agent\`/\`resume_agent\` (finished agents end on their own; \`followup_task\` re-tasks one, \`interrupt_agent\` stops one); \`wait_agent\` takes only \`timeout_ms\` and returns on any child mailbox activity. \`agent_type\` works the same on both surfaces. If a code block below conflicts with this section, this section wins.
 
 When translating \`load_skills=[...]\`, include the requested skill names in the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
 
@@ -103523,7 +104311,7 @@ Append to the 6.6 summary a "Dispatch path" line and, when team path was used, t
 var REFACTOR_TEMPLATE = REFACTOR_INTRO_AND_ANALYSIS + REFACTOR_CODEMAP_AND_TESTS + REFACTOR_PLAN_AND_EXECUTION + REFACTOR_VERIFICATION_AND_TOOLING;
 
 // packages/omo-opencode/src/features/builtin-commands/templates/start-work.ts
-var START_WORK_TEMPLATE = `You are starting a Sisyphus work session.
+var START_WORK_TEMPLATE = `You are starting an Atlas work session.
 
 ## ARGUMENTS
 
@@ -103863,13 +104651,15 @@ This command includes examples for the OpenCode harness. In Codex, do not call O
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent(agent_type="explorer", task_name="...", message="...")\` |
-| \`call_omo_agent(subagent_type="librarian", ...)\` | \`spawn_agent(agent_type="librarian", task_name="...", message="...")\` |
-| \`task(subagent_type="plan", ...)\` | \`spawn_agent(agent_type="plan", task_name="...", message="...")\` |
+| \`call_omo_agent(subagent_type="explore", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})\` |
+| \`call_omo_agent(subagent_type="librarian", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})\` |
+| \`task(subagent_type="plan", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})\` |
 | \`task(subagent_type="oracle", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})\` |
-| \`task(category="...", ...)\` | \`spawn_agent(agent_type="worker", task_name="...", message="...")\` |
-| \`background_output(task_id="...")\` | \`wait_agent(...)\` to wait for subagent completion and mailbox updates |
-| \`team_*(...)\` | Use Codex native subagents plus \`send_message\`, \`followup_task\`, \`wait_agent\`, and \`close_agent\` |
+| \`task(category="...", ...)\` | \`multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})\` |
+| \`background_output(task_id="...")\` | \`multi_agent_v1.wait_agent(...)\` for mailbox signals |
+| \`team_*(...)\` | Use Codex native subagents via \`multi_agent_v1.spawn_agent\`, \`multi_agent_v1.send_input\`, \`multi_agent_v1.wait_agent\`, and \`multi_agent_v1.close_agent\` |
+
+Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If \`multi_agent_v1.*\` tools exist, use the table above as written. If instead a flat \`spawn_agent\` with a required \`task_name\` exists (\`multi_agent_v2\`), rewrite every \`multi_agent_v1.*\` example: \`multi_agent_v1.spawn_agent({...,"fork_context":false})\` becomes \`spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})\` (\`"all"\` only when full parent history is truly required); \`send_input\` becomes \`send_message\`; do not call \`close_agent\`/\`resume_agent\` (finished agents end on their own; \`followup_task\` re-tasks one, \`interrupt_agent\` stops one); \`wait_agent\` takes only \`timeout_ms\` and returns on any child mailbox activity. \`agent_type\` works the same on both surfaces. If a code block below conflicts with this section, this section wins.
 
 When translating \`load_skills=[...]\`, include the requested skill names in the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
 
@@ -104140,7 +104930,7 @@ ${refactorContent}
       argumentHint: "<refactoring-target> [--scope=<file|module|project>] [--strategy=<safe|aggressive>]"
     },
     "start-work": {
-      description: "(builtin) Start Sisyphus work session from Prometheus plan",
+      description: "(builtin) Start Atlas work session from Prometheus plan",
       agent: resolveStartWorkAgent(options),
       template: `<command-instruction>
 ${START_WORK_TEMPLATE}
@@ -104213,13 +105003,13 @@ function loadBuiltinCommands(disabledCommands, options) {
 // packages/omo-opencode/src/tools/slashcommand/command-discovery.ts
 var NESTED_COMMAND_SEPARATOR = "/";
 function discoverCommandsFromDir(commandsDir, scope, prefix = "") {
-  if (!existsSync76(commandsDir))
+  if (!existsSync81(commandsDir))
     return [];
-  if (!statSync10(commandsDir).isDirectory()) {
+  if (!statSync11(commandsDir).isDirectory()) {
     log2(`[command-discovery] Skipping non-directory path: ${commandsDir}`);
     return [];
   }
-  const entries = readdirSync19(commandsDir, { withFileTypes: true });
+  const entries = readdirSync20(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (entry.isDirectory()) {
@@ -104228,16 +105018,16 @@ function discoverCommandsFromDir(commandsDir, scope, prefix = "") {
       if (entry.name.startsWith("."))
         continue;
       const nestedPrefix = prefix ? `${prefix}${NESTED_COMMAND_SEPARATOR}${entry.name}` : entry.name;
-      commands.push(...discoverCommandsFromDir(join96(commandsDir, entry.name), scope, nestedPrefix));
+      commands.push(...discoverCommandsFromDir(join99(commandsDir, entry.name), scope, nestedPrefix));
       continue;
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join96(commandsDir, entry.name);
-    const baseCommandName = basename15(entry.name, ".md");
+    const commandPath = join99(commandsDir, entry.name);
+    const baseCommandName = basename16(entry.name, ".md");
     const commandName = prefix ? `${prefix}${NESTED_COMMAND_SEPARATOR}${baseCommandName}` : baseCommandName;
     try {
-      const content = readFileSync51(commandPath, "utf-8");
+      const content = readFileSync54(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -104292,8 +105082,8 @@ function deduplicateCommandInfosByName(commands) {
   return deduplicatedCommands;
 }
 function discoverCommandsSync(directory, options) {
-  const userCommandsDir = join96(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join96(directory ?? process.cwd(), ".claude", "commands");
+  const userCommandsDir = join99(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join99(directory ?? process.cwd(), ".claude", "commands");
   const opencodeGlobalDirs = getOpenCodeCommandDirs({ binary: "opencode" });
   const opencodeProjectDirs = findProjectOpencodeCommandDirs(directory ?? process.cwd());
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
@@ -104397,7 +105187,7 @@ async function formatCommandTemplate(cmd, args) {
   if (!content && cmd.lazyContentLoader) {
     content = await cmd.lazyContentLoader.load();
   }
-  const commandDir = cmd.path ? dirname30(cmd.path) : process.cwd();
+  const commandDir = cmd.path ? dirname31(cmd.path) : process.cwd();
   const withFileRefs = await resolveFileReferencesInText(content, commandDir);
   const resolvedContent = await resolveCommandsInText(withFileRefs);
   const resolvedArguments = args;
@@ -104773,757 +105563,7 @@ If you skipped steps, STOP NOW. Go back and complete them.
 `;
 // packages/omo-opencode/src/hooks/prometheus-md-only/hook.ts
 init_logger2();
-// packages/boulder-state/src/constants.ts
-var BOULDER_DIR = ".omo";
-var BOULDER_FILE = "boulder.json";
-var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
-var NOTEPAD_DIR = "notepads";
-var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
-var PROMETHEUS_PLANS_DIR = ".omo/plans";
-// packages/boulder-state/src/top-level-task.ts
-import { existsSync as existsSync77, readFileSync as readFileSync52 } from "fs";
-var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
-var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
-var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
-var UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
-var TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/;
-var FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i;
-function buildTaskRef(section, taskLabel) {
-  const pattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN;
-  const match = taskLabel.match(pattern);
-  if (!match) {
-    return null;
-  }
-  const rawLabel = match[1];
-  const title = match[2].trim();
-  return {
-    key: `${section}:${rawLabel.toLowerCase()}`,
-    section,
-    label: rawLabel,
-    title
-  };
-}
-function readCurrentTopLevelTask(planPath) {
-  if (!existsSync77(planPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync52(planPath, "utf-8");
-    const lines = content.split(/\r?\n/);
-    let section = "other";
-    for (const line of lines) {
-      if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
-        section = TODO_HEADING_PATTERN.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN.test(line) ? "final-wave" : "other";
-      }
-      const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN);
-      if (!uncheckedTaskMatch || uncheckedTaskMatch[1].length > 0) {
-        continue;
-      }
-      if (section !== "todo" && section !== "final-wave") {
-        continue;
-      }
-      const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim());
-      if (taskRef) {
-        return taskRef;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-// packages/boulder-state/src/storage/path.ts
-import { existsSync as existsSync78 } from "fs";
-import { isAbsolute as isAbsolute15, join as join97, relative as relative13, resolve as resolve23 } from "path";
-function getBoulderFilePath(directory) {
-  return join97(directory, BOULDER_DIR, BOULDER_FILE);
-}
-function resolveTrackedPath(baseDirectory, trackedPath) {
-  return isAbsolute15(trackedPath) ? resolve23(trackedPath) : resolve23(baseDirectory, trackedPath);
-}
-function resolveBoulderPlanPath(directory, state3) {
-  const absolutePlanPath = resolveTrackedPath(directory, state3.active_plan);
-  const worktreePath = state3.worktree_path?.trim();
-  if (!worktreePath) {
-    return absolutePlanPath;
-  }
-  const absoluteDirectory = resolve23(directory);
-  const relativePlanPath = relative13(absoluteDirectory, absolutePlanPath);
-  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute15(relativePlanPath)) {
-    return absolutePlanPath;
-  }
-  const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
-  const worktreePlanPath = resolve23(absoluteWorktreePath, relativePlanPath);
-  return existsSync78(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
-}
-function resolveBoulderPlanPathForWork(directory, work) {
-  return resolveBoulderPlanPath(directory, work);
-}
-// packages/boulder-state/src/storage/plan-progress.ts
-import { existsSync as existsSync79, readFileSync as readFileSync53, readdirSync as readdirSync20, statSync as statSync11 } from "fs";
-import { basename as basename16, join as join98 } from "path";
-var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
-var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
-var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
-var UNCHECKED_CHECKBOX_PATTERN2 = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/;
-var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
-var TODO_TASK_PATTERN2 = /^\d+\.\s+/;
-var FINAL_WAVE_TASK_PATTERN2 = /^F\d+\.\s+/i;
-var LEGACY_PROMETHEUS_PLANS_DIR = ".sisyphus/plans";
-var PROMETHEUS_PLAN_DIRS = [PROMETHEUS_PLANS_DIR, LEGACY_PROMETHEUS_PLANS_DIR];
-function findPrometheusPlans(directory) {
-  try {
-    return PROMETHEUS_PLAN_DIRS.flatMap((planDir) => {
-      const plansDir = join98(directory, planDir);
-      if (!existsSync79(plansDir)) {
-        return [];
-      }
-      return readdirSync20(plansDir).filter((file2) => file2.endsWith(".md")).map((file2) => join98(plansDir, file2));
-    }).sort((left, right) => statSync11(right).mtimeMs - statSync11(left).mtimeMs);
-  } catch {
-    return [];
-  }
-}
-function getPlanName(planPath) {
-  return basename16(planPath, ".md");
-}
-function getPlanProgress(planPath) {
-  if (!existsSync79(planPath)) {
-    return { total: 0, completed: 0, isComplete: false };
-  }
-  try {
-    const content = readFileSync53(planPath, "utf-8");
-    const lines = content.split(/\r?\n/);
-    const hasStructuredSections = lines.some((line) => TODO_HEADING_PATTERN2.test(line) || FINAL_VERIFICATION_HEADING_PATTERN2.test(line));
-    if (hasStructuredSections) {
-      return getStructuredPlanProgress(lines);
-    }
-    return getSimplePlanProgress(content);
-  } catch {
-    return { total: 0, completed: 0, isComplete: false };
-  }
-}
-function getStructuredPlanProgress(lines) {
-  let section = "other";
-  let total = 0;
-  let completed = 0;
-  for (const line of lines) {
-    if (SECOND_LEVEL_HEADING_PATTERN2.test(line)) {
-      section = TODO_HEADING_PATTERN2.test(line) ? "todo" : FINAL_VERIFICATION_HEADING_PATTERN2.test(line) ? "final-wave" : "other";
-      continue;
-    }
-    if (section !== "todo" && section !== "final-wave") {
-      continue;
-    }
-    const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN);
-    const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN2);
-    const match = checkedMatch ?? uncheckedMatch;
-    if (!match || match[1].length > 0) {
-      continue;
-    }
-    const taskBody = match[2].trim();
-    const labelPattern = section === "todo" ? TODO_TASK_PATTERN2 : FINAL_WAVE_TASK_PATTERN2;
-    if (!labelPattern.test(taskBody)) {
-      continue;
-    }
-    total += 1;
-    if (checkedMatch) {
-      completed += 1;
-    }
-  }
-  return { total, completed, isComplete: total > 0 && completed === total };
-}
-function getSimplePlanProgress(content) {
-  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) ?? [];
-  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) ?? [];
-  const total = uncheckedMatches.length + checkedMatches.length;
-  const completed = checkedMatches.length;
-  return { total, completed, isComplete: total > 0 && completed === total };
-}
-// packages/boulder-state/src/storage/shared.ts
-var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
-var SESSION_ID_PREFIX_PATTERN = /^(codex|opencode):/;
-function normalizeSessionId(sessionId, platform2 = "opencode") {
-  if (SESSION_ID_PREFIX_PATTERN.test(sessionId)) {
-    return sessionId;
-  }
-  return `${platform2}:${sessionId}`;
-}
-function nowIsoString() {
-  return new Date().toISOString();
-}
-function parseIsoToMs(value) {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? null : parsed;
-}
-function getElapsedMs(startedAt, endedAt) {
-  const startedMs = parseIsoToMs(startedAt);
-  const endedMs = parseIsoToMs(endedAt);
-  if (startedMs === null || endedMs === null) {
-    return;
-  }
-  return endedMs - startedMs;
-}
-function isValidWorkStatus(status) {
-  return status === "active" || status === "completed" || status === "paused" || status === "abandoned";
-}
-function buildWorkFromMirror(state3) {
-  const planName = state3.plan_name ?? state3.active_plan;
-  const workId = `${planName}-legacy`;
-  return {
-    work_id: workId,
-    active_plan: state3.active_plan,
-    plan_name: planName,
-    status: state3.status,
-    started_at: state3.started_at,
-    ended_at: state3.ended_at,
-    elapsed_ms: state3.elapsed_ms,
-    updated_at: state3.updated_at,
-    session_ids: Array.isArray(state3.session_ids) ? [...state3.session_ids] : [],
-    session_origins: state3.session_origins,
-    agent: state3.agent,
-    worktree_path: state3.worktree_path,
-    task_sessions: state3.task_sessions
-  };
-}
-function projectWorkToMirror(state3, work) {
-  state3.active_plan = work.active_plan;
-  state3.plan_name = work.plan_name;
-  state3.status = work.status;
-  state3.started_at = work.started_at;
-  state3.ended_at = work.ended_at;
-  state3.elapsed_ms = work.elapsed_ms;
-  state3.updated_at = work.updated_at;
-  state3.session_ids = [...work.session_ids];
-  state3.session_origins = work.session_origins ? { ...work.session_origins } : {};
-  state3.agent = work.agent;
-  state3.worktree_path = work.worktree_path;
-  state3.task_sessions = work.task_sessions ? { ...work.task_sessions } : {};
-}
-function selectMirrorWork(state3) {
-  const works = state3.works ? Object.values(state3.works) : [];
-  if (works.length === 0) {
-    return null;
-  }
-  if (state3.active_work_id) {
-    const matched = works.find((work) => work.work_id === state3.active_work_id);
-    if (matched) {
-      return matched;
-    }
-  }
-  const sorted = [...works].sort((left, right) => {
-    const leftMs = parseIsoToMs(left.updated_at ?? left.started_at) ?? 0;
-    const rightMs = parseIsoToMs(right.updated_at ?? right.started_at) ?? 0;
-    return rightMs - leftMs;
-  });
-  return sorted[0] ?? null;
-}
-// packages/boulder-state/src/storage/read-state.ts
-import { existsSync as existsSync80, readFileSync as readFileSync54 } from "fs";
-function readBoulderState(directory) {
-  const filePath = getBoulderFilePath(directory);
-  if (!existsSync80(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync54(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    normalizeState(parsed);
-    const state3 = parsed;
-    const mirrorWork = selectMirrorWork(state3);
-    if (mirrorWork) {
-      state3.active_work_id = mirrorWork.work_id;
-      projectWorkToMirror(state3, mirrorWork);
-    }
-    return state3;
-  } catch {
-    return null;
-  }
-}
-function normalizeState(state3) {
-  normalizeSessionFields(state3);
-  const sessionIds = Array.isArray(state3.session_ids) ? state3.session_ids : [];
-  const sessionOrigins = state3.session_origins && typeof state3.session_origins === "object" && !Array.isArray(state3.session_origins) ? state3.session_origins : {};
-  state3.session_origins = sessionOrigins;
-  if (sessionIds.length === 1) {
-    const soleSessionId = sessionIds[0];
-    if (typeof soleSessionId === "string" && sessionOrigins[soleSessionId] !== "appended" && sessionOrigins[soleSessionId] !== "direct") {
-      sessionOrigins[soleSessionId] = "direct";
-    }
-  }
-  if (!state3.task_sessions || typeof state3.task_sessions !== "object" || Array.isArray(state3.task_sessions)) {
-    state3.task_sessions = {};
-  }
-  normalizeWorkSessionFields(state3.works);
-}
-function normalizeSessionFields(target) {
-  const sessionIds = Array.isArray(target.session_ids) ? target.session_ids.filter((sessionId) => typeof sessionId === "string").map((sessionId) => normalizeSessionId(sessionId)) : [];
-  target.session_ids = sessionIds;
-  const sessionOrigins = target.session_origins && typeof target.session_origins === "object" && !Array.isArray(target.session_origins) ? normalizeSessionOrigins(target.session_origins) : {};
-  target.session_origins = sessionOrigins;
-}
-function normalizeSessionOrigins(sessionOrigins) {
-  return Object.fromEntries(Object.entries(sessionOrigins).map(([sessionId, origin]) => [normalizeSessionId(sessionId), origin]));
-}
-function normalizeWorkSessionFields(works) {
-  if (!works || typeof works !== "object" || Array.isArray(works)) {
-    return;
-  }
-  for (const work of Object.values(works)) {
-    if (work && typeof work === "object" && !Array.isArray(work)) {
-      normalizeSessionFields(work);
-    }
-  }
-}
-function getBoulderWorks(state3) {
-  if (state3.works && typeof state3.works === "object") {
-    return Object.values(state3.works).filter((work) => work != null);
-  }
-  if (!state3.active_plan || !state3.plan_name || !state3.started_at) {
-    return [];
-  }
-  return [buildWorkFromMirror(state3)];
-}
-function getActiveWorks(directory) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return [];
-  }
-  return getBoulderWorks(state3).filter((work) => work.status !== "completed" && work.status !== "abandoned");
-}
-function getWorkById(directory, workId) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  return getBoulderWorks(state3).find((work) => work.work_id === workId) ?? null;
-}
-function getWorkByPlanName(directory, planName, options) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const worktreePath = options?.worktreePath;
-  return getBoulderWorks(state3).find((work) => {
-    if (work.plan_name !== planName) {
-      return false;
-    }
-    return worktreePath ? work.worktree_path === worktreePath : true;
-  }) ?? null;
-}
-function getWorkForSession(directory, sessionId) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  let newestWork = null;
-  let newestWorkMs = 0;
-  for (const work of getBoulderWorks(state3)) {
-    if (!work.session_ids.includes(normalizedSessionId)) {
-      continue;
-    }
-    const workMs = parseIsoToMs(work.updated_at ?? work.started_at) ?? 0;
-    if (!newestWork || workMs > newestWorkMs) {
-      newestWork = work;
-      newestWorkMs = workMs;
-    }
-  }
-  if (newestWork) {
-    return newestWork;
-  }
-  return state3.session_ids.includes(normalizedSessionId) ? buildWorkFromMirror(state3) : null;
-}
-function getWorkResumeOptions(directory) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return [];
-  }
-  return getBoulderWorks(state3).filter((work) => work.status !== "completed" && work.status !== "abandoned").map((work) => {
-    const progress = getPlanProgress(resolveBoulderPlanPathForWork(directory, work));
-    return {
-      work_id: work.work_id,
-      plan_name: work.plan_name,
-      active_plan: work.active_plan,
-      worktree_path: work.worktree_path,
-      status: work.status && isValidWorkStatus(work.status) ? work.status : "active",
-      started_at: work.started_at,
-      updated_at: work.updated_at ?? work.started_at,
-      ended_at: work.ended_at,
-      elapsed_ms: work.elapsed_ms,
-      session_count: work.session_ids.length,
-      progress,
-      is_current_mirror: state3.active_work_id === work.work_id
-    };
-  });
-}
-function getTaskSessionState(directory, taskKey) {
-  const state3 = readBoulderState(directory);
-  if (state3?.active_work_id) {
-    const work = state3.works?.[state3.active_work_id];
-    const taskSession = work?.task_sessions?.[taskKey];
-    if (taskSession) {
-      return taskSession;
-    }
-  }
-  if (!state3?.task_sessions) {
-    return null;
-  }
-  return state3.task_sessions[taskKey] ?? null;
-}
-// packages/boulder-state/src/storage/write-state.ts
-import { existsSync as existsSync81, mkdirSync as mkdirSync18, unlinkSync as unlinkSync13, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname31, join as join99 } from "path";
-function writeBoulderState(directory, state3) {
-  const filePath = getBoulderFilePath(directory);
-  try {
-    const dir = dirname31(filePath);
-    if (!existsSync81(dir)) {
-      mkdirSync18(dir, { recursive: true });
-      writeFileSync18(join99(dir, ".gitignore"), ["*", "!/rules/", "!/rules/**", ""].join(`
-`), "utf-8");
-    }
-    const stateToWrite = { ...state3 };
-    if (stateToWrite.works && stateToWrite.active_work_id) {
-      const activeWork = stateToWrite.works[stateToWrite.active_work_id];
-      if (activeWork) {
-        stateToWrite.works = {
-          ...stateToWrite.works,
-          [stateToWrite.active_work_id]: {
-            ...activeWork,
-            active_plan: stateToWrite.active_plan,
-            plan_name: stateToWrite.plan_name,
-            status: stateToWrite.status,
-            started_at: stateToWrite.started_at,
-            ended_at: stateToWrite.ended_at,
-            elapsed_ms: stateToWrite.elapsed_ms,
-            updated_at: stateToWrite.updated_at,
-            session_ids: [...stateToWrite.session_ids],
-            session_origins: stateToWrite.session_origins ? { ...stateToWrite.session_origins } : {},
-            agent: stateToWrite.agent,
-            worktree_path: stateToWrite.worktree_path,
-            task_sessions: stateToWrite.task_sessions ? { ...stateToWrite.task_sessions } : {}
-          }
-        };
-      }
-    }
-    writeFileSync18(filePath, JSON.stringify(stateToWrite, null, 2), "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function clearBoulderState(directory) {
-  const filePath = getBoulderFilePath(directory);
-  try {
-    if (existsSync81(filePath)) {
-      unlinkSync13(filePath);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-function generateWorkId(planName) {
-  const slug = planName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  const randomHex = Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
-  return `${slug.length > 0 ? slug : "work"}-${randomHex}`;
-}
-function createBoulderState(planPath, sessionId, agent, worktreePath) {
-  const startedAt = nowIsoString();
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  const workId = generateWorkId(getPlanName(planPath));
-  const work = {
-    work_id: workId,
-    active_plan: planPath,
-    plan_name: getPlanName(planPath),
-    status: "active",
-    started_at: startedAt,
-    updated_at: startedAt,
-    session_ids: [normalizedSessionId],
-    session_origins: { [normalizedSessionId]: "direct" },
-    ...agent !== undefined ? { agent } : {},
-    ...worktreePath !== undefined ? { worktree_path: worktreePath } : {},
-    task_sessions: {}
-  };
-  return {
-    schema_version: 2,
-    active_work_id: workId,
-    works: { [workId]: work },
-    active_plan: planPath,
-    started_at: startedAt,
-    status: "active",
-    updated_at: startedAt,
-    session_ids: [normalizedSessionId],
-    session_origins: { [normalizedSessionId]: "direct" },
-    plan_name: getPlanName(planPath),
-    task_sessions: {},
-    ...agent !== undefined ? { agent } : {},
-    ...worktreePath !== undefined ? { worktree_path: worktreePath } : {}
-  };
-}
-function selectActiveWork(directory, workId) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const works = getBoulderWorks(state3);
-  const nextWork = works.find((work) => work.work_id === workId);
-  if (!nextWork) {
-    return null;
-  }
-  const nextState = {
-    ...state3,
-    schema_version: 2,
-    active_work_id: workId,
-    works: state3.works ?? Object.fromEntries(works.map((work) => [work.work_id, work]))
-  };
-  projectWorkToMirror(nextState, nextWork);
-  return writeBoulderState(directory, nextState) ? nextState : null;
-}
-function addBoulderWork(directory, input) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const workId = generateWorkId(getPlanName(input.planPath));
-  const startedAt = input.startedAt ?? nowIsoString();
-  const normalizedSessionId = normalizeSessionId(input.sessionId);
-  const nextWork = {
-    work_id: workId,
-    active_plan: input.planPath,
-    plan_name: getPlanName(input.planPath),
-    status: "active",
-    started_at: startedAt,
-    updated_at: startedAt,
-    session_ids: [normalizedSessionId],
-    session_origins: { [normalizedSessionId]: "direct" },
-    ...input.agent !== undefined ? { agent: input.agent } : {},
-    ...input.worktreePath !== undefined ? { worktree_path: input.worktreePath } : {},
-    task_sessions: {}
-  };
-  const nextState = {
-    ...state3,
-    schema_version: 2,
-    works: { ...Object.fromEntries(getBoulderWorks(state3).map((work) => [work.work_id, work])), [workId]: nextWork },
-    active_work_id: workId
-  };
-  projectWorkToMirror(nextState, nextWork);
-  return writeBoulderState(directory, nextState) ? nextState : null;
-}
-function completeBoulder(directory, workId, endedAt) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const targetWorkId = workId ?? state3.active_work_id;
-  if (!targetWorkId) {
-    return null;
-  }
-  const work = state3.works?.[targetWorkId] ?? getBoulderWorks(state3).find((candidate) => candidate.work_id === targetWorkId);
-  if (!work) {
-    return null;
-  }
-  if (work.status === "completed" && work.ended_at !== undefined && work.elapsed_ms !== undefined) {
-    return state3;
-  }
-  const endAt = endedAt ?? nowIsoString();
-  work.ended_at = endAt;
-  work.elapsed_ms = getElapsedMs(work.started_at, endAt);
-  work.status = "completed";
-  work.updated_at = nowIsoString();
-  if (state3.active_work_id === targetWorkId) {
-    projectWorkToMirror(state3, work);
-  }
-  return writeBoulderState(directory, state3) ? state3 : null;
-}
 
-// packages/boulder-state/src/storage/session.ts
-function appendSessionId(directory, sessionId, origin = "direct") {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  const activeWorkId = readBoulderState(directory)?.active_work_id;
-  if (activeWorkId) {
-    return appendSessionIdForWork(directory, activeWorkId, normalizedSessionId, origin);
-  }
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  if (!state3.session_origins || typeof state3.session_origins !== "object" || Array.isArray(state3.session_origins)) {
-    state3.session_origins = {};
-  }
-  if (!state3.session_ids?.includes(normalizedSessionId)) {
-    if (!Array.isArray(state3.session_ids)) {
-      state3.session_ids = [];
-    }
-    const originalSessionIds = [...state3.session_ids];
-    const originalSessionOrigins = { ...state3.session_origins };
-    state3.session_ids.push(normalizedSessionId);
-    state3.session_origins[normalizedSessionId] = origin;
-    if (writeBoulderState(directory, state3)) {
-      return state3;
-    }
-    state3.session_ids = originalSessionIds;
-    state3.session_origins = originalSessionOrigins;
-    return null;
-  }
-  if (!state3.session_origins[normalizedSessionId]) {
-    state3.session_origins[normalizedSessionId] = origin;
-    if (!writeBoulderState(directory, state3)) {
-      return null;
-    }
-  }
-  return state3;
-}
-function appendSessionIdForWork(directory, workId, sessionId, origin = "direct") {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const works = getBoulderWorks(state3);
-  const targetWork = works.find((work) => work.work_id === workId);
-  if (!targetWork) {
-    return null;
-  }
-  const updatedWork = {
-    ...targetWork,
-    session_ids: targetWork.session_ids.includes(normalizedSessionId) ? [...targetWork.session_ids] : [...targetWork.session_ids, normalizedSessionId],
-    session_origins: { ...targetWork.session_origins ?? {}, [normalizedSessionId]: origin },
-    updated_at: nowIsoString()
-  };
-  const nextState = {
-    ...state3,
-    schema_version: 2,
-    works: {
-      ...Object.fromEntries(works.map((work) => [work.work_id, work])),
-      [workId]: updatedWork
-    }
-  };
-  if (state3.active_work_id === workId) {
-    projectWorkToMirror(nextState, updatedWork);
-  }
-  return writeBoulderState(directory, nextState) ? nextState : null;
-}
-// packages/boulder-state/src/storage/task.ts
-function upsertTaskSessionState(directory, input) {
-  const stateForWork = readBoulderState(directory);
-  if (stateForWork?.active_work_id) {
-    return upsertTaskSessionStateForWork(directory, stateForWork.active_work_id, input);
-  }
-  const state3 = readBoulderState(directory);
-  if (!state3 || RESERVED_KEYS.has(input.taskKey)) {
-    return null;
-  }
-  const normalizedSessionId = normalizeSessionId(input.sessionId);
-  const taskSessions = state3.task_sessions ?? {};
-  taskSessions[input.taskKey] = {
-    task_key: input.taskKey,
-    task_label: input.taskLabel,
-    task_title: input.taskTitle,
-    session_id: normalizedSessionId,
-    ...input.agent !== undefined ? { agent: input.agent } : {},
-    ...input.category !== undefined ? { category: input.category } : {},
-    updated_at: nowIsoString()
-  };
-  state3.task_sessions = taskSessions;
-  return writeBoulderState(directory, state3) ? state3 : null;
-}
-function upsertTaskSessionStateForWork(directory, workId, input) {
-  if (RESERVED_KEYS.has(input.taskKey)) {
-    return null;
-  }
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const works = getBoulderWorks(state3);
-  const targetWork = works.find((work) => work.work_id === workId);
-  if (!targetWork) {
-    return null;
-  }
-  const normalizedSessionId = normalizeSessionId(input.sessionId);
-  const previousTaskSession = targetWork.task_sessions?.[input.taskKey];
-  const nextTaskSession = {
-    task_key: input.taskKey,
-    task_label: input.taskLabel,
-    task_title: input.taskTitle,
-    session_id: normalizedSessionId,
-    ...input.agent !== undefined ? { agent: input.agent } : {},
-    ...input.category !== undefined ? { category: input.category } : {},
-    ...previousTaskSession?.started_at !== undefined ? { started_at: previousTaskSession.started_at } : {},
-    ...previousTaskSession?.ended_at !== undefined ? { ended_at: previousTaskSession.ended_at } : {},
-    ...previousTaskSession?.elapsed_ms !== undefined ? { elapsed_ms: previousTaskSession.elapsed_ms } : {},
-    ...previousTaskSession?.status !== undefined ? { status: previousTaskSession.status } : {},
-    updated_at: nowIsoString()
-  };
-  const nextWork = {
-    ...targetWork,
-    task_sessions: { ...targetWork.task_sessions ?? {}, [input.taskKey]: nextTaskSession },
-    updated_at: nowIsoString()
-  };
-  const nextState = {
-    ...state3,
-    schema_version: 2,
-    works: {
-      ...Object.fromEntries(works.map((work) => [work.work_id, work])),
-      [workId]: nextWork
-    }
-  };
-  if (state3.active_work_id === workId) {
-    projectWorkToMirror(nextState, nextWork);
-  }
-  return writeBoulderState(directory, nextState) ? nextState : null;
-}
-function startTaskTimer(directory, workId, input) {
-  const nextState = upsertTaskSessionStateForWork(directory, workId, {
-    ...input,
-    sessionId: normalizeSessionId(input.sessionId)
-  });
-  if (!nextState) {
-    return null;
-  }
-  const work = nextState.works?.[workId];
-  const taskSession = work?.task_sessions?.[input.taskKey];
-  if (!work || !taskSession) {
-    return null;
-  }
-  const startedAt = taskSession.started_at ?? input.startedAt ?? nowIsoString();
-  taskSession.started_at = startedAt;
-  taskSession.status = "running";
-  taskSession.updated_at = nowIsoString();
-  work.updated_at = nowIsoString();
-  return writeBoulderState(directory, nextState) ? nextState : null;
-}
-function endTaskTimer(directory, workId, taskKey, endedAt) {
-  const state3 = readBoulderState(directory);
-  if (!state3) {
-    return null;
-  }
-  const work = state3.works?.[workId] ?? getBoulderWorks(state3).find((candidate) => candidate.work_id === workId);
-  if (!work?.task_sessions?.[taskKey]) {
-    return null;
-  }
-  const taskSession = work.task_sessions[taskKey];
-  const endAt = endedAt ?? nowIsoString();
-  taskSession.ended_at = endAt;
-  taskSession.elapsed_ms = getElapsedMs(taskSession.started_at, endAt);
-  taskSession.status = "completed";
-  taskSession.updated_at = nowIsoString();
-  work.updated_at = nowIsoString();
-  if (state3.active_work_id === workId) {
-    projectWorkToMirror(state3, work);
-  }
-  return writeBoulderState(directory, state3) ? state3 : null;
-}
-// packages/omo-opencode/src/features/boulder-state/format-duration.ts
-init_src();
 // packages/omo-opencode/src/hooks/prometheus-md-only/agent-resolution.ts
 function isCompactionAgent2(agent) {
   return agent.toLowerCase() === "compaction";
@@ -106350,7 +106390,7 @@ async function findRecentSessionPlanPath(input) {
 
 // packages/omo-opencode/src/hooks/start-work/start-work-hook.ts
 var HOOK_NAME6 = "start-work";
-var START_WORK_TEMPLATE_MARKER = "You are starting a Sisyphus work session.";
+var START_WORK_TEMPLATE_MARKER = "You are starting an Atlas work session.";
 var CONTEXT_INFO_MARKER = "<!-- omo-start-work-context -->";
 function resolveWorktreeContext(explicitWorktreePath) {
   if (explicitWorktreePath === null) {
@@ -110651,7 +110691,8 @@ function createAbortSessionRequest(deps) {
       await ctx.client.session.abort({ path: { id: sessionID } });
       releasePromptAsyncReservation(sessionID, `runtime-fallback-abort:${source}`, {
         reservedBy: `runtime-fallback:${source}`,
-        reservedByPrefix: "runtime-fallback:"
+        reservedByPrefix: "runtime-fallback:",
+        supersedeTransientRetryOwners: true
       });
       log2(`[${HOOK_NAME11}] Aborted in-flight session request (${source})`, { sessionID });
     } catch (error) {
@@ -110897,6 +110938,7 @@ function createAutoRetryDispatcher(deps, scheduleSessionFallbackTimeout, clearSe
     sessionStates,
     sessionRetryInFlight,
     sessionAwaitingFallbackResult,
+    internallyAbortedSessions,
     pluginConfig
   } = deps;
   return async (sessionID, newModel, resolvedAgent, source) => {
@@ -110966,6 +111008,7 @@ function createAutoRetryDispatcher(deps, scheduleSessionFallbackTimeout, clearSe
         },
         query: { directory: ctx.directory }
       };
+      const wasInternallyAborted = internallyAbortedSessions.has(sessionID);
       const dispatchRetryPrompt = (retrySource, queueBehavior) => dispatchInternalPrompt({
         mode: "async",
         client: ctx.client,
@@ -110973,6 +111016,7 @@ function createAutoRetryDispatcher(deps, scheduleSessionFallbackTimeout, clearSe
         source: retrySource,
         settleMs: 0,
         ...queueBehavior ? { queueBehavior } : {},
+        ...wasInternallyAborted ? { checkToolState: false } : {},
         input: retryPromptInput
       });
       let promptResult = await dispatchRetryPrompt(`runtime-fallback:${source}`, "defer");
@@ -111733,6 +111777,7 @@ function createEventHandler(deps, helpers) {
     }
     sessionRetryInFlight.delete(sessionID);
     sessionAwaitingFallbackResult.delete(sessionID);
+    deps.internallyAbortedSessions.delete(sessionID);
     sessionStatusRetryKeys.delete(sessionID);
     helpers.clearSessionFallbackTimeout(sessionID);
   };
@@ -111766,6 +111811,7 @@ function createEventHandler(deps, helpers) {
       sessionLastAccess.delete(sessionID);
       sessionRetryInFlight.delete(sessionID);
       sessionAwaitingFallbackResult.delete(sessionID);
+      deps.internallyAbortedSessions.delete(sessionID);
       helpers.clearSessionFallbackTimeout(sessionID);
       sessionStatusRetryKeys.delete(sessionID);
       SessionCategoryRegistry.remove(sessionID);
@@ -127695,6 +127741,7 @@ function cloneParentWake(wake) {
     promptContext,
     notifications: [...wake.notifications],
     shouldReply: wake.shouldReply,
+    ...wake.queuedAt !== undefined ? { queuedAt: wake.queuedAt } : {},
     ...wake.dispatchedAt !== undefined ? { dispatchedAt: wake.dispatchedAt } : {},
     ...wake.noReplyAdmittedAt !== undefined ? { noReplyAdmittedAt: wake.noReplyAdmittedAt } : {},
     ...wake.toolCallDeferralStartedAt !== undefined ? { toolCallDeferralStartedAt: wake.toolCallDeferralStartedAt } : {},
@@ -128037,7 +128084,7 @@ async function sendParentWakePrompt(input) {
       ...input.emptyAssistantTurnRetry ? { dedupeKey: createEmptyAssistantTurnRetryDedupeKey(input.latestWake) } : {},
       settleMs: 0,
       queueBehavior: "defer",
-      checkStatus: input.forceNoReply !== true,
+      checkStatus: input.forceNoReply !== true && input.skipPromptGateStatusCheck !== true,
       checkToolState: input.forceNoReply !== true && !input.toolWaitDecision.skipPromptGateToolStateCheck,
       input: {
         path: { id: input.sessionID },
@@ -128120,6 +128167,8 @@ function createTrackedDispatchedWake(wake, forceNoReply) {
 }
 
 // packages/omo-opencode/src/features/background-agent/parent-wake-flush-runner.ts
+var PENDING_PARENT_WAKE_MAX_ACTIVE_DEFER_MS = 60000;
+
 class ParentWakeFlushRunner {
   deps;
   constructor(deps) {
@@ -128149,14 +128198,16 @@ class ParentWakeFlushRunner {
     if (await this.dropAdmittedWakeConsumedByParent(sessionID, latestWake)) {
       return;
     }
-    if (sessionActive) {
+    const emptyAssistantTurnRetry = latestWake.allowEmptyAssistantTurnRetry === true;
+    const forceDispatchAfterActiveDefer = sessionActive && this.shouldForceDispatchAfterActiveDefer(latestWake);
+    if (sessionActive && !forceDispatchAfterActiveDefer) {
       this.schedulePendingParentWakeFlush(sessionID);
       log2("[background-agent] Deferred parent wake because parent session is active:", {
         sessionID
       });
       return;
     }
-    if (this.hasRecentParentSessionActivity(sessionID)) {
+    if (!forceDispatchAfterActiveDefer && this.hasRecentParentSessionActivity(sessionID)) {
       if (this.deferReplyWakeWhileUnsafe(sessionID, latestWake)) {
         return;
       }
@@ -128174,7 +128225,6 @@ class ParentWakeFlushRunner {
       }
       return;
     }
-    const emptyAssistantTurnRetry = latestWake.allowEmptyAssistantTurnRetry === true;
     const toolWaitDecision = await this.shouldDeferParentWakeForSessionHistory(sessionID, latestWake);
     if (toolWaitDecision.defer) {
       if (this.deferReplyWakeWhileUnsafe(sessionID, latestWake)) {
@@ -128227,8 +128277,15 @@ class ParentWakeFlushRunner {
     }
     await this.sendParentWakePrompt(sessionID, latestWake, {
       emptyAssistantTurnRetry,
-      toolWaitDecision: finalToolWaitDecision
+      toolWaitDecision: finalToolWaitDecision,
+      ...forceDispatchAfterActiveDefer ? { skipPromptGateStatusCheck: true } : {}
     });
+    if (forceDispatchAfterActiveDefer) {
+      log2("[background-agent] Sent parent wake after active-session defer ceiling:", {
+        sessionID,
+        queuedAgeMs: this.getQueuedAgeMs(latestWake)
+      });
+    }
   }
   schedulePendingParentWakeFlush(sessionID, delayMs) {
     this.deps.pendingQueue.scheduleFlush(sessionID, async () => {
@@ -128280,6 +128337,7 @@ class ParentWakeFlushRunner {
         latestWake,
         ...options.forceNoReply !== undefined ? { forceNoReply: options.forceNoReply } : {},
         ...options.retainPendingWake !== undefined ? { retainPendingWake: options.retainPendingWake } : {},
+        ...options.skipPromptGateStatusCheck !== undefined ? { skipPromptGateStatusCheck: options.skipPromptGateStatusCheck } : {},
         emptyAssistantTurnRetry: options.emptyAssistantTurnRetry,
         toolWaitDecision: options.toolWaitDecision,
         getDispatchedWake: () => this.deps.dispatchedTracker.getWake(sessionID),
@@ -128295,6 +128353,12 @@ class ParentWakeFlushRunner {
   async isSessionActive(sessionID) {
     return isSessionActive(this.deps.notifierDeps.client, sessionID);
   }
+  shouldForceDispatchAfterActiveDefer(wake) {
+    return wake.shouldReply && this.getQueuedAgeMs(wake) >= PENDING_PARENT_WAKE_MAX_ACTIVE_DEFER_MS;
+  }
+  getQueuedAgeMs(wake) {
+    return Date.now() - (wake.queuedAt ?? Date.now());
+  }
   hasRecentParentSessionActivity(sessionID) {
     return this.deps.sessionInspector.hasRecentActivity(sessionID);
   }
@@ -128339,9 +128403,11 @@ class ParentWakePendingQueue {
     this.pendingParentWakes.delete(sessionID);
   }
   queueWake(sessionID, notification, promptContext, shouldReply) {
+    const now = Date.now();
     const resolvedPromptContext = resolveParentWakePromptContext(promptContext);
     const pendingWake = this.pendingParentWakes.get(sessionID);
     if (pendingWake) {
+      pendingWake.queuedAt ??= now;
       const mergedNotifications = mergeParentWakeNotifications(pendingWake.notifications, notification);
       const notificationsChanged = mergedNotifications.length !== pendingWake.notifications.length || mergedNotifications.some((merged, index) => merged !== pendingWake.notifications[index]);
       pendingWake.notifications = mergedNotifications;
@@ -128356,12 +128422,17 @@ class ParentWakePendingQueue {
     this.pendingParentWakes.set(sessionID, {
       promptContext: resolvedPromptContext,
       notifications: [notification],
-      shouldReply
+      shouldReply,
+      queuedAt: now
     });
   }
   requeueWake(sessionID, latestWake) {
+    const now = Date.now();
     const pendingWake = this.pendingParentWakes.get(sessionID);
     if (pendingWake) {
+      const existingQueuedAt = pendingWake.queuedAt ?? now;
+      const latestQueuedAt = latestWake.queuedAt ?? now;
+      pendingWake.queuedAt = Math.min(existingQueuedAt, latestQueuedAt);
       pendingWake.notifications = pendingWake.notifications.reduce((notifications, notification) => mergeParentWakeNotifications(notifications, notification), [...latestWake.notifications]);
       pendingWake.shouldReply = pendingWake.shouldReply || latestWake.shouldReply;
       pendingWake.promptContext = latestWake.promptContext;
@@ -128374,7 +128445,9 @@ class ParentWakePendingQueue {
       }
       return;
     }
-    this.pendingParentWakes.set(sessionID, cloneParentWake(latestWake));
+    const clonedWake = cloneParentWake(latestWake);
+    clonedWake.queuedAt ??= now;
+    this.pendingParentWakes.set(sessionID, clonedWake);
   }
   scheduleFlush(sessionID, operation, delayMs) {
     if (this.pendingParentWakeTimers.has(sessionID)) {
@@ -133073,6 +133146,7 @@ function createMonitorPipeline(components, deps) {
 }
 
 // packages/omo-opencode/src/features/monitor/process.ts
+init_bun_spawn_shim();
 var KILL_GRACE_MS = 5000;
 function killProcessGroup(pid, signal) {
   try {
@@ -133094,7 +133168,7 @@ function spawnMonitoredProcess(opts, deps) {
   if (argv.length === 0) {
     throw new Error("Cannot spawn an empty monitor command");
   }
-  const subprocess = spawnDetachedProcess(argv, opts, deps.spawn ?? Bun.spawn);
+  const subprocess = spawnDetachedProcess(argv, opts, deps.spawn ?? spawn);
   let actualExited = false;
   let publicExitSettled = false;
   let watchdogTimer;
@@ -133124,11 +133198,15 @@ function spawnMonitoredProcess(opts, deps) {
   function kill(signal = "SIGTERM") {
     if (actualExited)
       return;
-    killProcessGroup(subprocess.pid, signal);
+    if (subprocess.pid !== undefined) {
+      killProcessGroup(subprocess.pid, signal);
+    }
     if (graceTimer === undefined) {
       graceTimer = deps.setTimer(() => {
         if (!actualExited) {
-          killProcessGroup(subprocess.pid, "SIGKILL");
+          if (subprocess.pid !== undefined) {
+            killProcessGroup(subprocess.pid, "SIGKILL");
+          }
         }
       }, KILL_GRACE_MS);
     }
@@ -133142,7 +133220,7 @@ function spawnMonitoredProcess(opts, deps) {
     actualExited = true;
     clearWatchdog();
     clearGraceTimer();
-    settlePublicExit({ code, signal: subprocess.signalCode });
+    settlePublicExit({ code, signal: subprocess.signalCode ?? null });
   }).catch((error) => {
     actualExited = true;
     clearWatchdog();
@@ -160299,7 +160377,7 @@ function extractPromptText5(parts) {
 }
 
 // packages/omo-opencode/src/plugin/chat-message/start-work-message.ts
-var START_WORK_TEMPLATE_MARKER2 = "You are starting a Sisyphus work session.";
+var START_WORK_TEMPLATE_MARKER2 = "You are starting an Atlas work session.";
 function isStartWorkHookOutput(value) {
   if (typeof value !== "object" || value === null)
     return false;