@askexenow/exe-os 0.9.341 → 0.9.342

package/dist/{chunk-KKOLHBNC.js → chunk-UP75Z5X7.js}

@@ -1,16 +1,19 @@
 import {
   ensureAgentSymlink
-} from "./chunk-ATKW3SYL.js";
+} from "./chunk-L2R3LN2P.js";
 import {
   ensureWorktree,
+  ensureWorktreeAsync,
   getGitRoot,
+  isInsideGitRepo,
   isWorktreeDirty
-} from "./chunk-BJOBR6P2.js";
+} from "./chunk-I26FWCSP.js";
 import {
   incrementSkillSuccess
-} from "./chunk-6D2PI4QD.js";
+} from "./chunk-EV46QTD3.js";
 import {
   LEASE_MINUTES,
+  isLeaseExpired,
   leaseExpiryIso
 } from "./chunk-E23LNUWJ.js";
 import {
@@ -24,35 +27,35 @@ import {
 import {
   listSessions,
   registerSession
-} from "./chunk-HNLXMD2V.js";
+} from "./chunk-KGWRTRKC.js";
 import {
   getTransport
-} from "./chunk-RMOBQ6A5.js";
+} from "./chunk-AD2VCHSS.js";
 import {
   listTmuxSessions
-} from "./chunk-SSTLTIF3.js";
+} from "./chunk-SKGMF2SO.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WH7XN5ER.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   assertRuntimeModelCompatible,
   getAgentRuntime,
   normalizeCcModelName,
   resolveSpawnRuntimeConfig
-} from "./chunk-GFDGDFBF.js";
-import {
-  RUNTIME_TABLE
-} from "./chunk-NGP6LSV2.js";
+} from "./chunk-HA5R6USD.js";
 import {
   PlanLimitError,
   assertEmployeeLimitSync
-} from "./chunk-2UGGBIDL.js";
+} from "./chunk-JGIPOUIK.js";
+import {
+  BUSY_PATTERN
+} from "./chunk-GWDSB25T.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
 import {
   writeMemoryViaDaemon
-} from "./chunk-LLU6WZLK.js";
+} from "./chunk-JLZ4RYSD.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
@@ -72,23 +75,27 @@ import {
   getEmployee,
   isCoordinatorName,
   loadEmployees,
+  loadEmployeesState,
   loadEmployeesSync,
   offloadReadIfMain
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
+import {
+  RUNTIME_TABLE
+} from "./chunk-NGP6LSV2.js";
 import {
   loadDeviceId
-} from "./chunk-7SEC2AG5.js";
+} from "./chunk-PQIDGXSG.js";
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 import {
   atomicWriteJsonSync,
   atomicWriteSync
-} from "./chunk-SHIICYJW.js";
+} from "./chunk-BYTDMAGB.js";
 
 // src/lib/tmux-routing.ts
-import { execFile, execFileSync as execFileSync2 } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
+import { promisify as promisify3 } from "util";
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync9, appendFileSync as appendFileSync3, openSync as openSync2, closeSync as closeSync2, writeSync as writeSync2, renameSync as renameSync3, constants as constants2, statSync as statSync4 } from "fs";
 import path8 from "path";
 import os6 from "os";
@@ -412,6 +419,7 @@ var QUEUE_PATH = path3.join(os3.homedir(), ".exe-os", "intercom-queue.json");
 var QUEUE_LOCK_PATH = `${QUEUE_PATH}.lock`;
 var MAX_RETRIES = 10;
 var TTL_MS = 60 * 60 * 1e3;
+var HARD_TTL_MS = 2 * TTL_MS;
 function ensureDir() {
   const dir = path3.dirname(QUEUE_PATH);
   if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
@@ -555,7 +563,7 @@ function drainQueue(isSessionBusy2, sendKeys, notifyExpiry = notifyExpiredInterc
   }
   return { drained, failed };
 }
-async function drainQueueAsync(isSessionBusy2, sendKeys, notifyExpiry = notifyExpiredIntercom, yieldEvery = 10) {
+async function drainQueueAsync(isSessionBusy2, sendKeys, notifyExpiry = notifyExpiredIntercom, yieldEvery = 10, disposition = async () => "declined") {
   if (_draining) {
     logQueue("SKIP_DRAIN \u2014 previous drain still running (possible tmux hang)");
     return { drained: 0, failed: 0 };
@@ -579,7 +587,25 @@ async function drainQueueAsync(isSessionBusy2, sendKeys, notifyExpiry = notifyEx
       processed++;
       const age = Date.now() - new Date(item.queuedAt).getTime();
       if (age > TTL_MS) {
-        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+        let outcome = "declined";
+        try {
+          outcome = await disposition(item);
+        } catch (err) {
+          logQueue(`DISPOSITION_FAILED \u2192 ${item.targetSession}: ${err instanceof Error ? err.message : String(err)}`);
+          outcome = "error";
+        }
+        if (outcome === "dispositioned") {
+          logQueue(`DISPOSITIONED (expired) \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old \u2192 task routed to blocked, reason: ${item.reason})`);
+          failed++;
+          continue;
+        }
+        if (outcome === "error" && age <= HARD_TTL_MS) {
+          logQueue(`TTL_DEFERRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, disposition error \u2014 retrying; hard cap ${Math.round(HARD_TTL_MS / 6e4)}min)`);
+          remaining.push(item);
+          failed++;
+          continue;
+        }
+        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason}${outcome === "error" ? "; disposition erroring past hard cap" : ""})`);
         try {
           notifyExpiry(item);
         } catch (err) {
@@ -601,7 +627,19 @@ async function drainQueueAsync(isSessionBusy2, sendKeys, notifyExpiry = notifyEx
       }
       item.attempts++;
       if (item.attempts >= MAX_RETRIES) {
-        logQueue(`PENDING \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, keeping queued, reason: ${item.reason})`);
+        let outcome = "declined";
+        try {
+          outcome = await disposition(item);
+        } catch (err) {
+          logQueue(`DISPOSITION_FAILED \u2192 ${item.targetSession}: ${err instanceof Error ? err.message : String(err)}`);
+          outcome = "error";
+        }
+        if (outcome === "dispositioned") {
+          logQueue(`DISPOSITIONED \u2192 ${item.targetSession} (${MAX_RETRIES} attempts exhausted \u2192 task routed to blocked, reason: ${item.reason})`);
+          failed++;
+          continue;
+        }
+        logQueue(`PENDING \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, keeping queued, reason: ${item.reason}${outcome === "error" ? "; disposition error" : ""})`);
         item.attempts = MAX_RETRIES;
         remaining.push(item);
         failed++;
@@ -800,7 +838,8 @@ import { homedir as homedir2 } from "os";
 import crypto2 from "crypto";
 import path5 from "path";
 import os5 from "os";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync2, execFile as execFileCb } from "child_process";
+import { promisify } from "util";
 import { mkdir, writeFile, appendFile } from "fs/promises";
 import { existsSync as existsSync6, readFileSync as readFileSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
 
@@ -890,6 +929,7 @@ function clearStaleReviewEscalation(taskId) {
 }
 
 // src/lib/tasks-crud.ts
+var execFileAsync = promisify(execFileCb);
 var DEFAULT_TASK_PRIORITY = "p1";
 function normalizeTaskPriority(value) {
   const v = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -1293,7 +1333,7 @@ async function createTaskCore(input) {
         if (isCoordinatorSession) {
           earlySessionScope = resolved;
         } else {
-          const { getSessionProject } = await import("./session-scope-3MEOO557.js");
+          const { getSessionProject } = await import("./session-scope-5EAPUT45.js");
           const sessionProject = getSessionProject(resolved);
           if (sessionProject && sessionProject !== input.projectName) {
             scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
@@ -1374,10 +1414,26 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   const complexity = input.complexity ?? "standard";
   const priority = normalizeTaskPriority(input.priority);
   const sessionScope = earlySessionScope;
+  const idempotencyKey = input.idempotencyKey ? input.idempotencyKey : input.idempotencyWindow ? crypto2.createHash("sha256").update(
+    // PREIMAGE MUST BE INJECTIVE. A NUL-joined concatenation is NOT: nothing
+    // rejects a NUL inside these fields (they arrive as plain z.string()), so two
+    // DIFFERENT tuples can produce the SAME joined string and therefore the same
+    // key — silently collapsing two distinct tasks into one. JSON.stringify of the
+    // array is injective: each field is quoted, escaped and delimited by the encoding.
+    JSON.stringify([
+      input.assignedTo,
+      input.title,
+      input.projectName,
+      sessionScope ?? "",
+      input.idempotencyWindow
+    ])
+  ).digest("hex") : null;
   try {
-    await client.execute({
-      sql: `INSERT OR IGNORE INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, spawn_runtime, spawn_model, device_id, founder_id, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    const res = await client.execute({
+      sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, spawn_runtime, spawn_model, device_id, founder_id, idempotency_key, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
+            RETURNING id`,
       args: [
         id,
         input.title,
@@ -1401,10 +1457,43 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
         input.spawnModel ?? null,
         loadDeviceId(),
         input.founderId ?? null,
+        idempotencyKey,
         now,
         now
       ]
     });
+    if (res.rows.length === 0 && idempotencyKey) {
+      const existing = await client.execute({
+        sql: "SELECT * FROM tasks WHERE idempotency_key = ? LIMIT 1",
+        args: [idempotencyKey]
+      });
+      if (existing.rows.length > 0) {
+        const r = existing.rows[0];
+        return {
+          id: String(r.id),
+          title: String(r.title),
+          assignedTo: String(r.assigned_to),
+          assignedBy: String(r.assigned_by),
+          reviewer: r.reviewer !== null && r.reviewer !== void 0 ? String(r.reviewer) : null,
+          projectName: String(r.project_name),
+          priority: String(r.priority),
+          status: String(r.status),
+          taskFile: String(r.task_file),
+          createdAt: String(r.created_at),
+          updatedAt: String(r.updated_at),
+          checkpointCount: Number(r.checkpoint_count ?? 0),
+          warning: "idempotent no-op: existing task returned for reused idempotency key",
+          budgetTokens: r.budget_tokens !== null ? Number(r.budget_tokens) : null,
+          budgetFallbackModel: r.budget_fallback_model !== null ? String(r.budget_fallback_model) : null,
+          tokensUsed: Number(r.tokens_used ?? 0),
+          tokensWarnedAt: r.tokens_warned_at !== null ? Number(r.tokens_warned_at) : null,
+          spawnRuntime: r.spawn_runtime !== null && r.spawn_runtime !== void 0 ? String(r.spawn_runtime) : null,
+          spawnModel: r.spawn_model !== null && r.spawn_model !== void 0 ? String(r.spawn_model) : null,
+          sessionScope: r.session_scope !== null && r.session_scope !== void 0 ? String(r.session_scope) : null,
+          deduplicated: true
+        };
+      }
+    }
   } catch (dbErr) {
     process.stderr.write(
       `[create-task] DB insert failed for "${input.title}": ${dbErr instanceof Error ? dbErr.message : String(dbErr)}
@@ -1491,8 +1580,7 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
     sessionScope
   };
 }
-async function queryTaskRows(opts) {
-  const client = getClient();
+async function buildTaskRowsStatement(opts) {
   const conditions = [];
   const args = [];
   if (opts.assignedTo) {
@@ -1542,7 +1630,7 @@ async function queryTaskRows(opts) {
   }
   if (opts.founderId !== null) {
     try {
-      const { founderScopeFilter } = await import("./founder-context-HWPLMZVR.js");
+      const { founderScopeFilter } = await import("./founder-context-7L3CFPYN.js");
       const founderFilter = founderScopeFilter(opts.founderId);
       const cleaned = founderFilter.sql.replace(/^\s*AND\s+/, "");
       conditions.push(cleaned);
@@ -1560,12 +1648,15 @@ async function queryTaskRows(opts) {
   const cols = opts.columns ?? "*";
   const order = opts.orderBy ?? "priority ASC, created_at DESC";
   const limit = opts.limit ?? 100;
-  const result = await offloadReadIfMain(
-    client,
-    `SELECT ${cols} FROM tasks ${where} ORDER BY ${order} LIMIT ?`,
-    [...args, limit],
-    true
-  );
+  return {
+    sql: `SELECT ${cols} FROM tasks ${where} ORDER BY ${order} LIMIT ?`,
+    args: [...args, limit]
+  };
+}
+async function queryTaskRows(opts) {
+  const client = getClient();
+  const stmt = await buildTaskRowsStatement(opts);
+  const result = await offloadReadIfMain(client, stmt.sql, stmt.args, true);
   return result.rows;
 }
 function getProjectNameSafe() {
@@ -1584,12 +1675,29 @@ async function listTasks(input) {
   }
   const callerSession = input.callerSession?.trim();
   if (input.isOwnQuery && callerSession) {
-    extraConditions.push("(instance_id IS NULL OR instance_id = ?)");
-    extraArgs.push(callerSession);
-    extraConditions.push(
-      "(assigned_tmux IS NULL OR assigned_tmux = 'unknown' OR assigned_tmux = ? OR assigned_tmux LIKE ?)"
-    );
-    extraArgs.push(callerSession, `${callerSession}:%`);
+    const live = await resolveLiveTmuxSessions();
+    const liveForeign = live.verified ? [...live.sessions].filter((s) => s !== callerSession) : null;
+    if (liveForeign === null) {
+      extraConditions.push("(instance_id IS NULL OR instance_id = ?)");
+      extraArgs.push(callerSession);
+      extraConditions.push(
+        "(assigned_tmux IS NULL OR assigned_tmux = 'unknown' OR assigned_tmux = ? OR assigned_tmux LIKE ?)"
+      );
+      extraArgs.push(callerSession, `${callerSession}:%`);
+    } else if (liveForeign.length === 0) {
+    } else {
+      const ph = liveForeign.map(() => "?").join(", ");
+      extraConditions.push(
+        `(instance_id IS NULL OR instance_id = ? OR instance_id NOT IN (${ph}))`
+      );
+      extraArgs.push(callerSession, ...liveForeign);
+      const notLive = liveForeign.map(() => "(assigned_tmux <> ? AND assigned_tmux NOT LIKE ?)").join(" AND ");
+      extraConditions.push(
+        `(assigned_tmux IS NULL OR assigned_tmux = 'unknown' OR assigned_tmux = ? OR assigned_tmux LIKE ? OR (${notLive}))`
+      );
+      extraArgs.push(callerSession, `${callerSession}:%`);
+      for (const s of liveForeign) extraArgs.push(s, `${s}:%`);
+    }
   }
   const callerRoot = callerSession ? callerSession.includes("-") ? callerSession.split("-").pop() || null : callerSession : null;
   const queryOpts = {
@@ -1618,9 +1726,11 @@ async function listTasks(input) {
     sessionScope: input.crossSession ? null : callerRoot ?? void 0,
     columns: "*",
     limit: 1e3,
-    orderBy: input.status ? "priority ASC, created_at DESC" : "CASE status WHEN 'blocked' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'open' THEN 2 ELSE 3 END, priority ASC, created_at DESC",
-    // When no status filter, listTasks defaults to active + blocked
-    ...input.status ? {} : { status: ["open", "in_progress", "blocked"] },
+    orderBy: input.status ? "priority ASC, created_at DESC" : "CASE status WHEN 'blocked' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'open' THEN 2 WHEN 'needs_review' THEN 3 ELSE 4 END, priority ASC, created_at DESC",
+    // When no status filter, listTasks defaults to active + blocked + review queue.
+    // needs_review MUST be included or a coordinator's default list hides the
+    // review queue (bug 50ce5079: "No tasks found" while reviews stall).
+    ...input.status ? {} : { status: ["open", "in_progress", "blocked", "needs_review"] },
     ...extraConditions.length > 0 ? { extraConditions, extraArgs } : {}
   };
   const rows = await queryTaskRows(queryOpts);
@@ -1655,6 +1765,63 @@ function tmuxCmd(args) {
   const sock = process.env.EXE_TMUX_SOCKET;
   return sock ? `tmux -L ${sock} ${args}` : `tmux ${args}`;
 }
+var _liveSessionsCacheTs = 0;
+var _liveSessionsCache = { sessions: /* @__PURE__ */ new Set(), verified: false };
+var _liveSessionsInflight = null;
+var _liveSessionsCacheSocket = void 0;
+var _liveSessionsTmuxCalls = 0;
+function __getLiveSessionsTmuxCalls() {
+  return _liveSessionsTmuxCalls;
+}
+function __resetLiveSessionsCache() {
+  _liveSessionsCacheTs = 0;
+  _liveSessionsCache = { sessions: /* @__PURE__ */ new Set(), verified: false };
+  _liveSessionsInflight = null;
+  _liveSessionsTmuxCalls = 0;
+}
+async function tmuxListLiveSessions() {
+  _liveSessionsTmuxCalls += 1;
+  const sock = process.env.EXE_TMUX_SOCKET;
+  const args = [
+    ...sock ? ["-L", sock] : [],
+    "list-panes",
+    "-a",
+    "-F",
+    "#{session_name}	#{pane_dead}"
+  ];
+  try {
+    const { stdout } = await execFileAsync("tmux", args, { timeout: 2e3, encoding: "utf8" });
+    const sessions = /* @__PURE__ */ new Set();
+    let verified = false;
+    for (const line of stdout.split("\n")) {
+      const [session, paneDead] = line.split("	");
+      if (!session) continue;
+      verified = true;
+      if (paneDead !== "1") sessions.add(session);
+    }
+    return { sessions, verified };
+  } catch {
+    return { sessions: /* @__PURE__ */ new Set(), verified: false };
+  }
+}
+async function resolveLiveTmuxSessions() {
+  const now = Date.now();
+  const sock = process.env.EXE_TMUX_SOCKET;
+  const rawTtl = process.env.EXE_TMUX_ALIVE_CACHE_TTL_MS;
+  const ttl = rawTtl !== void 0 && rawTtl !== "" ? Number(rawTtl) : 2e3;
+  const fresh = now - _liveSessionsCacheTs < ttl;
+  if (fresh && sock === _liveSessionsCacheSocket) return _liveSessionsCache;
+  if (_liveSessionsInflight) return _liveSessionsInflight;
+  _liveSessionsInflight = tmuxListLiveSessions().then((result) => {
+    _liveSessionsCache = result;
+    _liveSessionsCacheTs = Date.now();
+    _liveSessionsCacheSocket = sock;
+    return result;
+  }).finally(() => {
+    _liveSessionsInflight = null;
+  });
+  return _liveSessionsInflight;
+}
 function refreshTmuxAliveCacheSync() {
   const now = Date.now();
   if (now - _tmuxAliveCacheTs < TMUX_ALIVE_CACHE_TTL_MS) return;
@@ -1682,13 +1849,40 @@ function refreshTmuxAliveCacheSync() {
 }
 function isTmuxSessionAlive(identifier) {
   if (!identifier || identifier === "unknown") return true;
+  const sessionIdentifier = identifier.startsWith("%") ? identifier : identifier.split(":")[0] ?? identifier;
   refreshTmuxAliveCacheSync();
   if (!_tmuxAliveCacheVerified) return true;
-  if (identifier.startsWith("%")) return _tmuxAlivePanes.has(identifier);
-  return _tmuxAliveSessions.has(identifier);
+  if (sessionIdentifier.startsWith("%")) return _tmuxAlivePanes.has(sessionIdentifier);
+  return _tmuxAliveSessions.has(sessionIdentifier);
 }
 var DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
 var TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
+var TASK_SIDECHAIN_WRITE_BLOCKED_PREFIX = "TASK_SIDECHAIN_WRITE_BLOCKED";
+var OWNER_RECLAIM_MAX_CHURN = 5;
+var OWNER_RECLAIM_CHURN_WINDOW_MS = 1e4;
+var _ownerReclaimChurn = /* @__PURE__ */ new Map();
+function instanceToken(session, employees) {
+  const s = (session ?? "").trim();
+  if (!s || s === "unknown" || s.startsWith("%")) return null;
+  const name = (s.split(":")[0] ?? s).trim();
+  if (!name) return null;
+  const lower = name.toLowerCase();
+  const roster = employees ?? loadEmployeesSync();
+  const sorted = [...roster].sort((a, b) => b.name.length - a.name.length);
+  for (const emp of sorted) {
+    const empName = emp.name.toLowerCase();
+    if (lower === empName) return empName;
+    if (lower.startsWith(empName)) {
+      const rest = lower.slice(empName.length);
+      const m = rest.match(/^(\d*)(?:-|$)/);
+      if (m) return empName + m[1];
+    }
+  }
+  const lastDash = name.lastIndexOf("-");
+  const token = (lastDash > 0 ? name.slice(0, lastDash) : name).toLowerCase();
+  if (token.includes("-")) return null;
+  return token || null;
+}
 var VALID_TASK_STATUSES = [
   "open",
   "in_progress",
@@ -1737,6 +1931,11 @@ async function updateTaskStatus(input) {
   const row = await resolveTask(client, input.taskId);
   const taskId = String(row.id);
   const taskFile = String(row.task_file);
+  if (input.callerIsSidechain && !String(row.assigned_to ?? "").startsWith("subagent:")) {
+    throw new Error(
+      `${TASK_SIDECHAIN_WRITE_BLOCKED_PREFIX}: task ${taskId} belongs to the parent session; a sub-agent/sidechain may not change its status. Report findings back to the parent \u2014 the owning employee updates the task.`
+    );
+  }
   const requestedStatus = input.status;
   const eventSessionScope = row.session_scope ? String(row.session_scope) : null;
   const eventProjectName = row.project_name ? String(row.project_name) : null;
@@ -1850,25 +2049,30 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     });
     if (claim2.rowsAffected === 0) {
       const current = await client.execute({
-        sql: "SELECT status, assigned_tmux, assigned_by FROM tasks WHERE id = ?",
+        sql: "SELECT status, assigned_tmux, assigned_by, lease_expires_at FROM tasks WHERE id = ?",
         args: [taskId]
       });
       const cur = current.rows[0];
       const curStatus = cur?.status ?? "unknown";
       const claimedBySession = cur?.assigned_tmux ?? "";
       const assignedBy = cur?.assigned_by ?? "";
-      if (curStatus === "open" && claimedBySession && !isTmuxSessionAlive(claimedBySession)) {
+      const claimExpired = isLeaseExpired(cur?.lease_expires_at ?? null, Date.parse(now));
+      if ((curStatus === "open" || curStatus === "blocked") && claimedBySession && (claimExpired || !isTmuxSessionAlive(claimedBySession))) {
         process.stderr.write(
-          `[tasks] Auto-clearing dead open-task pre-bind on ${taskId} (was ${claimedBySession})
+          `[tasks] Auto-clearing dead/expired ${curStatus}-task pre-bind on ${taskId} (was ${claimedBySession})
 `
         );
         await client.execute({
           sql: `UPDATE tasks
                 SET assigned_tmux = NULL,
                     instance_id = NULL,
+                    claimed_by = NULL,
+                    claimed_at = NULL,
+                    last_heartbeat_at = NULL,
+                    lease_expires_at = NULL,
                     updated_at = ?
                 WHERE id = ?
-                  AND status = 'open'
+                  AND status IN ('open', 'blocked')
                   AND assigned_tmux = ?`,
           args: [now, taskId, claimedBySession]
         });
@@ -1963,49 +2167,158 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
           return { row, taskFile, now, taskId, previousStatus, requestedStatus };
         }
       }
+      const reclaimRoster = loadEmployeesSync();
+      const callerInstance = instanceToken(input.callerSession ?? tmuxSession, reclaimRoster);
+      const holderInstance = instanceToken(claimedBySession, reclaimRoster);
+      const rowInstanceId = row.instance_id ? String(row.instance_id) : "";
+      const ownerReclaim = curStatus === "in_progress" && !!input.callerAgentId && input.callerAgentId === String(row.assigned_to ?? "") && callerInstance !== null && holderInstance !== null && holderInstance === callerInstance && (rowInstanceId === "" || instanceToken(rowInstanceId, reclaimRoster) === callerInstance);
+      if (ownerReclaim) {
+        const nowMs = Date.parse(now);
+        const churn = _ownerReclaimChurn.get(taskId);
+        if (churn && nowMs - churn.windowStart <= OWNER_RECLAIM_CHURN_WINDOW_MS) {
+          churn.count += 1;
+          if (churn.count > OWNER_RECLAIM_MAX_CHURN) {
+            process.stderr.write(
+              `[tasks] Owner-reclaim CONTENTION on ${taskId}: ${churn.count} reclaims within ${OWNER_RECLAIM_CHURN_WINDOW_MS}ms \u2014 refusing to rebind; leaving holder ${claimedBySession} in place
+`
+            );
+            recordOrchestrationEventBestEffort({
+              eventType: "claim.contention",
+              source: "tasks-crud.updateTaskStatus",
+              severity: "warn",
+              taskId,
+              agentId: eventAgentId,
+              sessionScope: eventSessionScope,
+              projectName: eventProjectName,
+              tmuxSession,
+              result: "owner_reclaim_livelock",
+              payload: { reclaims: churn.count, holder: claimedBySession }
+            });
+            throw new Error(
+              `${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is contended \u2014 ${churn.count} owner-reclaims within ${OWNER_RECLAIM_CHURN_WINDOW_MS}ms; leaving current holder ${claimedBySession} in place to break the rebind loop.`
+            );
+          }
+        } else {
+          if (_ownerReclaimChurn.size > 512) {
+            for (const [k, v] of _ownerReclaimChurn) {
+              if (nowMs - v.windowStart > OWNER_RECLAIM_CHURN_WINDOW_MS) _ownerReclaimChurn.delete(k);
+            }
+          }
+          _ownerReclaimChurn.set(taskId, { count: 1, windowStart: nowMs });
+        }
+        process.stderr.write(
+          `[tasks] Owner reclaim: ${input.callerAgentId} (${input.callerSession ?? tmuxSession}) reclaiming own task ${taskId} from live session ${claimedBySession}
+`
+        );
+        const reclaimed = await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
+                    claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
+                    lease_expires_at = ?,
+                    claim_count = COALESCE(claim_count, 0) + 1
+                WHERE id = ? AND status = 'in_progress'
+                  AND assigned_to IS ? AND session_scope IS ? AND assigned_tmux IS ?`,
+          args: [
+            tmuxSession,
+            now,
+            claimAgent,
+            now,
+            now,
+            leaseExpiry,
+            taskId,
+            row.assigned_to != null ? String(row.assigned_to) : null,
+            eventSessionScope,
+            cur?.assigned_tmux ?? null
+          ]
+        });
+        if (reclaimed.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "owner_reclaim",
+              contextSummary: `Task reclaimed by true owner ${input.callerAgentId} from live session ${claimedBySession}.`
+            });
+          } catch {
+          }
+          recordOrchestrationEventBestEffort({
+            eventType: "task.claimed",
+            source: "tasks-crud.updateTaskStatus",
+            taskId,
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "owner_reclaim",
+            payload: { previousAssignedTmux: claimedBySession }
+          });
+          recordOrchestrationEventBestEffort({
+            eventType: "task.in_progress",
+            source: "tasks-crud.updateTaskStatus",
+            taskId,
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "owner_reclaim"
+          });
+          return { row, taskFile, now, taskId, previousStatus, requestedStatus };
+        }
+      }
       if (curStatus === "in_progress" && input.callerAgentId && (input.callerAgentId === assignedBy || isCoordinatorName(input.callerAgentId))) {
         process.stderr.write(
           `[tasks] Assigner override: ${input.callerAgentId} reclaiming ${taskId}
 `
         );
-        await client.execute({
+        const overridden = await client.execute({
           sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
                     claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
                     lease_expires_at = ?,
                     claim_count = COALESCE(claim_count, 0) + 1
-                WHERE id = ?`,
-          args: [tmuxSession, now, claimAgent, now, now, leaseExpiry, taskId]
+                WHERE id = ? AND status = 'in_progress'
+                  AND assigned_by IS ? AND session_scope IS ?`,
+          args: [
+            tmuxSession,
+            now,
+            claimAgent,
+            now,
+            now,
+            leaseExpiry,
+            taskId,
+            cur?.assigned_by ?? null,
+            eventSessionScope
+          ]
         });
-        try {
-          await writeCheckpoint({
+        if (overridden.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "assigner_override",
+              contextSummary: `Task force-reclaimed by assigner ${input.callerAgentId}.`
+            });
+          } catch {
+          }
+          recordOrchestrationEventBestEffort({
+            eventType: "task.claimed",
+            source: "tasks-crud.updateTaskStatus",
+            taskId,
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "assigner_override",
+            payload: { callerAgentId: input.callerAgentId }
+          });
+          recordOrchestrationEventBestEffort({
+            eventType: "task.in_progress",
+            source: "tasks-crud.updateTaskStatus",
             taskId,
-            step: "assigner_override",
-            contextSummary: `Task force-reclaimed by assigner ${input.callerAgentId}.`
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "assigner_override"
           });
-        } catch {
+          return { row, taskFile, now, taskId, previousStatus, requestedStatus };
         }
-        recordOrchestrationEventBestEffort({
-          eventType: "task.claimed",
-          source: "tasks-crud.updateTaskStatus",
-          taskId,
-          agentId: eventAgentId,
-          sessionScope: eventSessionScope,
-          projectName: eventProjectName,
-          tmuxSession,
-          result: "assigner_override",
-          payload: { callerAgentId: input.callerAgentId }
-        });
-        recordOrchestrationEventBestEffort({
-          eventType: "task.in_progress",
-          source: "tasks-crud.updateTaskStatus",
-          taskId,
-          agentId: eventAgentId,
-          sessionScope: eventSessionScope,
-          projectName: eventProjectName,
-          tmuxSession,
-          result: "assigner_override"
-        });
-        return { row, taskFile, now, taskId, previousStatus, requestedStatus };
       }
       const claimedBy = claimedBySession ? ` (claimed by ${claimedBySession})` : "";
       recordOrchestrationEventBestEffort({
@@ -2139,12 +2452,42 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
       }
     }
   }
-  const buildStatusStatement = () => input.result ? {
-    sql: `UPDATE tasks SET status = ?, result = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
-    args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
-  } : {
-    sql: `UPDATE tasks SET status = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
-    args: [input.status, now, ...actualMinutesArgs, taskId]
+  if ((input.status === "needs_review" || input.status === "closed" || input.status === "cancelled") && (previousStatus === "in_progress" || previousStatus === "blocked")) {
+    const claimHolder = row.assigned_tmux ? String(row.assigned_tmux) : "";
+    const leaseExpired = isLeaseExpired(
+      row.lease_expires_at ? String(row.lease_expires_at) : null,
+      Date.parse(now)
+    );
+    if (claimHolder && (leaseExpired || !isTmuxSessionAlive(claimHolder))) {
+      process.stderr.write(
+        `[tasks] Clearing dead/expired lease on completing task ${taskId} (was ${claimHolder})
+`
+      );
+      await client.execute({
+        sql: `UPDATE tasks SET assigned_tmux = NULL, lease_expires_at = NULL, updated_at = ?
+              WHERE id = ? AND assigned_tmux = ?`,
+        args: [now, taskId, claimHolder]
+      });
+    }
+  }
+  const buildStatusStatement = () => {
+    const hasResult = typeof input.result === "string" && input.result.trim().length > 0;
+    if (!hasResult) {
+      return {
+        sql: `UPDATE tasks SET status = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+        args: [input.status, now, ...actualMinutesArgs, taskId]
+      };
+    }
+    if (input.preserveResultIfPresent) {
+      return {
+        sql: `UPDATE tasks SET status = ?, result = CASE WHEN result IS NULL OR trim(result, char(32)||char(9)||char(10)||char(13)) = '' THEN ? ELSE result END, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+        args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
+      };
+    }
+    return {
+      sql: `UPDATE tasks SET status = ?, result = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+      args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
+    };
   };
   const writeStatements = [];
   if (structuredSerialized) {
@@ -3007,21 +3350,25 @@ function isStale(isoTimestamp) {
   if (!isoTimestamp) return false;
   return Date.now() - new Date(isoTimestamp).getTime() > STALE_REVIEW_AGE_MS;
 }
-async function countPendingReviews(sessionScope, reviewer) {
-  const extraConditions = reviewer ? ["reviewer = ?"] : void 0;
-  const extraArgs = reviewer ? [reviewer] : void 0;
-  const rows = await queryTaskRows({
+function pendingReviewsCountOpts(sessionScope, reviewer) {
+  return {
     status: "needs_review",
     columns: "COUNT(*) as cnt",
     sessionScope: sessionScope ?? null,
     strictSession: sessionScope !== void 0,
     projectName: null,
     // no project filter for review counts
-    extraConditions,
-    extraArgs,
+    extraConditions: reviewer ? ["reviewer = ?"] : void 0,
+    extraArgs: reviewer ? [reviewer] : void 0,
     limit: 1,
     orderBy: "1"
-  });
+  };
+}
+async function buildPendingReviewsCountStatement(sessionScope, reviewer) {
+  return buildTaskRowsStatement(pendingReviewsCountOpts(sessionScope, reviewer));
+}
+async function countPendingReviews(sessionScope, reviewer) {
+  const rows = await queryTaskRows(pendingReviewsCountOpts(sessionScope, reviewer));
   return Number(rows[0]?.cnt) || 0;
 }
 async function countNewPendingReviewsSince(sinceIso, sessionScope, reviewer) {
@@ -3346,7 +3693,10 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
     "- **Needs work:** re-open with notes"
   ].join("\n");
   const originalTaskId = String(row.id);
-  const updatedResult = (result ?? "No result summary provided") + reviewNotes;
+  const persistedResult = row.result != null ? String(row.result) : "";
+  const argResult = result != null ? String(result) : "";
+  const baseResult = persistedResult.trim().length > 0 ? persistedResult : argResult.trim().length > 0 ? argResult : "No result summary provided";
+  const updatedResult = baseResult + reviewNotes;
   await client.execute({
     sql: `UPDATE tasks SET result = ?, status = 'needs_review', updated_at = ?
           WHERE id = ?`,
@@ -3477,10 +3827,27 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
 }
 
 // src/lib/worktree-guard.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { execFile, execFileSync } from "child_process";
+import { promisify as promisify2 } from "util";
+import { existsSync as existsSync8, realpathSync } from "fs";
 import path7 from "path";
 var GIT_TIMEOUT_MS = 1e4;
+var execFileAsync2 = promisify2(execFile);
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+var defaultGitExecutor = async (args, cwd) => {
+  const { stdout } = await execFileAsync2("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUT_MS
+  });
+  return String(stdout ?? "");
+};
 function listWorktreesPorcelain(repoRoot) {
   try {
     const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
@@ -3561,6 +3928,90 @@ function checkWorktreeCollisions(repoPath) {
   }
   return warnings;
 }
+async function getGitRootAsync(dir, git) {
+  try {
+    const root = (await git(["rev-parse", "--show-toplevel"], dir)).trim();
+    return root ? realpath(root) : null;
+  } catch {
+    return null;
+  }
+}
+async function listWorktreesPorcelainAsync(repoRoot, git) {
+  try {
+    const output = await git(["worktree", "list", "--porcelain"], repoRoot);
+    const worktrees = [];
+    let currentPath = "";
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        currentPath = line.slice("worktree ".length);
+      } else if (line.startsWith("branch ") && currentPath) {
+        const branch = line.slice("branch refs/heads/".length);
+        worktrees.push({ path: currentPath, branch });
+        currentPath = "";
+      }
+    }
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+async function isWorktreeDirtyAsync(wtPath, git) {
+  try {
+    return (await git(["status", "--porcelain"], wtPath)).trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+async function hasUnpushedCommitsAsync(wtPath, branch, git) {
+  for (const mainRef of ["main", "master"]) {
+    try {
+      const ahead = (await git(["-C", wtPath, "rev-list", `${mainRef}..${branch}`, "--count"], wtPath)).trim();
+      return parseInt(ahead, 10) > 0;
+    } catch {
+    }
+  }
+  return true;
+}
+async function checkWorktreeCollisionsAsync(repoPath, git = defaultGitExecutor) {
+  const worktreeListCache = /* @__PURE__ */ new Map();
+  const listWorktreesOnce = (root) => {
+    let cached = worktreeListCache.get(root);
+    if (!cached) {
+      cached = listWorktreesPorcelainAsync(root, git);
+      worktreeListCache.set(root, cached);
+    }
+    return cached;
+  };
+  const repoRoot = await getGitRootAsync(repoPath, git);
+  if (!repoRoot) return [];
+  const warnings = [];
+  const worktrees = await listWorktreesOnce(repoRoot);
+  for (const wt of worktrees) {
+    if (!wt.path.includes("/.worktrees/")) continue;
+    if (!existsSync8(wt.path)) continue;
+    const owner = inferSessionOwner(wt.path, wt.branch);
+    const dirty = await isWorktreeDirtyAsync(wt.path, git);
+    const hasCommits = await hasUnpushedCommitsAsync(wt.path, wt.branch, git);
+    if (dirty) {
+      warnings.push({
+        worktreePath: wt.path,
+        branch: wt.branch,
+        sessionOwner: owner,
+        dirty: true,
+        reason: `Worktree has uncommitted changes (agent: ${owner ?? "unknown"}, branch: ${wt.branch})`
+      });
+    } else if (hasCommits) {
+      warnings.push({
+        worktreePath: wt.path,
+        branch: wt.branch,
+        sessionOwner: owner,
+        dirty: false,
+        reason: `Worktree has unpushed commits on branch ${wt.branch} (agent: ${owner ?? "unknown"})`
+      });
+    }
+  }
+  return warnings;
+}
 
 // src/lib/intercom-prompts.ts
 function formatIntercomPrompt(reason = "nudge") {
@@ -3578,6 +4029,15 @@ function formatIntercomPrompt(reason = "nudge") {
   }
 }
 
+// src/lib/session-scope-token.ts
+var VALID_SESSION_SCOPE_RE = /^[a-zA-Z0-9_]+$/;
+function isValidSessionScope(scope) {
+  return typeof scope === "string" && scope.length > 0 && scope.length <= 64 && VALID_SESSION_SCOPE_RE.test(scope);
+}
+function sanitizeSessionScope(scope) {
+  return isValidSessionScope(scope) ? scope : null;
+}
+
 // src/lib/tmux-routing.ts
 var _cachedExeBinDir;
 function resolveExeBinDir() {
@@ -3746,7 +4206,7 @@ async function exportBehaviorsAsync(agentId, projectName, sessionKey) {
   const script = resolveBehaviorsExporterScript();
   if (!script) return null;
   try {
-    const { stdout } = await execFileAsync(
+    const { stdout } = await execFileAsync3(
       process.execPath,
       [script, agentId, projectName, sessionKey],
       { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
@@ -3827,6 +4287,13 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
     mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
+  if (!isValidSessionScope(rootExe)) {
+    process.stderr.write(
+      `[tmux-routing] ERROR: refusing to cache corrupted parent session ${JSON.stringify(String(parentExe).slice(0, 60))} for key "${sessionKey}" \u2014 not a valid session token (bug 4941abba).
+`
+    );
+    return;
+  }
   const filePath = path8.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   atomicWriteJsonSync(filePath, {
     parentExe: rootExe,
@@ -3861,14 +4328,28 @@ function getDispatchedBy(sessionKey) {
 function resolveExeSession() {
   const mySession = getMySession();
   const fromSessionName = mySession ? extractRootExe(mySession) ?? null : null;
-  const alsHint = (() => {
+  const agentCtx = (() => {
     try {
-      return getAgentContext()?.sessionHint ?? "";
+      return getAgentContext();
     } catch {
-      return "";
+      return void 0;
     }
   })();
-  const envHint = process.env.EXE_SESSION_NAME || "";
+  const inDaemonRequest = agentCtx !== void 0;
+  const alsHint = agentCtx?.sessionHint ?? "";
+  if (agentCtx && !alsHint) {
+    logSessionResolve({
+      caller: "resolveExeSession",
+      mySession,
+      alsHint: "",
+      envHint: process.env.EXE_SESSION_NAME || "",
+      cacheHit: null,
+      resolved: null,
+      path: "daemon_request_no_hint (daemon env/tmux residue refused)"
+    });
+    return null;
+  }
+  const envHint = inDaemonRequest ? "" : process.env.EXE_SESSION_NAME || "";
   const validateLiveHint = (hint, source) => {
     if (!hint || !isRootSession(hint)) return hint || null;
     try {
@@ -3898,7 +4379,17 @@ function resolveExeSession() {
       return hint;
     }
   };
-  const sessionHintRaw = alsHint || envHint || "";
+  let sessionHintRaw = alsHint || envHint || "";
+  if (sessionHintRaw) {
+    const hintRoot = extractRootExe(sessionHintRaw) ?? sessionHintRaw;
+    if (!isValidSessionScope(hintRoot)) {
+      process.stderr.write(
+        `[tmux-routing] ERROR: ignoring corrupted session hint ${JSON.stringify(String(sessionHintRaw).slice(0, 60))} (source=${alsHint ? "ALS" : "env"}) \u2014 not a valid session token (bug 4941abba); using tmux/cache resolution.
+`
+      );
+      sessionHintRaw = "";
+    }
+  }
   if (sessionHintRaw) {
     const fromEnv = extractRootExe(sessionHintRaw) ?? sessionHintRaw;
     if (fromEnv) {
@@ -4101,7 +4592,7 @@ async function verifyPaneAtCapacity(sessionName) {
       reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const { isAtCapacity } = await import("./capacity-monitor-MG3FTUD5.js");
+  const { isAtCapacity } = await import("./capacity-monitor-ZG5GGFR2.js");
   if (!isAtCapacity(pane)) {
     return {
       atCapacity: false,
@@ -4117,7 +4608,7 @@ var INTERCOM_DEBOUNCE_MS = 3e5;
 var CODEX_DEBOUNCE_MS = 3e5;
 var INTERCOM_LOG2 = path8.join(os6.homedir(), ".exe-os", "intercom.log");
 var INTERCOM_LOG_MAX_BYTES2 = 1024 * 1024;
-var execFileAsync = promisify(execFile);
+var execFileAsync3 = promisify3(execFile2);
 var DEBOUNCE_FILE = path8.join(SESSION_CACHE, "intercom-debounce.json");
 var DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
 function readDebounceState() {
@@ -4196,24 +4687,47 @@ function logIntercom(msg, meta) {
   } catch {
   }
 }
-var BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
+function classifyPaneSessionState(pane) {
+  if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
+    if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
+      return "no_claude";
+    }
+  }
+  if (/Running…/.test(pane)) return "tool";
+  if (BUSY_PATTERN.test(pane)) return "thinking";
+  return "idle";
+}
 function getSessionState(sessionName) {
   const transport = getTransport();
   if (!transport.isAlive(sessionName)) return "offline";
   try {
-    const pane = transport.capturePane(sessionName, 5);
-    if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
-      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
-        return "no_claude";
-      }
-    }
-    if (/Running…/.test(pane)) return "tool";
-    if (BUSY_PATTERN.test(pane)) return "thinking";
-    return "idle";
+    return classifyPaneSessionState(transport.capturePane(sessionName, 5));
+  } catch {
+    return "offline";
+  }
+}
+async function captureSessionPaneAsync(sessionName, lines) {
+  const { stdout } = await execFileAsync3(
+    "tmux",
+    ["capture-pane", "-t", sessionName, "-p", "-S", `-${lines}`],
+    { encoding: "utf8", timeout: 3e3 }
+  );
+  return String(stdout ?? "");
+}
+async function getSessionStateAsync(sessionName) {
+  try {
+    return classifyPaneSessionState(await captureSessionPaneAsync(sessionName, 5));
   } catch {
     return "offline";
   }
 }
+async function sessionHasPendingInputAsync(sessionName) {
+  try {
+    return paneHasPendingInput(await captureSessionPaneAsync(sessionName, 12));
+  } catch {
+    return false;
+  }
+}
 function isSessionBusy(sessionName) {
   const state = getSessionState(sessionName);
   return state === "thinking" || state === "tool";
@@ -4256,7 +4770,7 @@ function sessionHasPendingInput(sessionName) {
   }
 }
 function decideQueuedNudgeDrain(intercomReason, state) {
-  if (state.hasInProgressTask) {
+  if (state.hasInProgressTask && state.isIdle === false) {
     return { action: "drop", reason: "in_progress_task_will_auto_chain" };
   }
   if (intercomReason === "message" && !state.hasUnreadMessages) {
@@ -4279,6 +4793,111 @@ async function countScopedPendingReviews(targetSession, reviewer) {
     return null;
   }
 }
+async function countScopedOpenTasks(targetSession, agentId) {
+  try {
+    const { fastDbInit } = await import("./fast-db-init-4CWHSOOR.js");
+    const client = await fastDbInit();
+    const scope = extractRootExe(targetSession);
+    if (!scope) return 0;
+    const rawAgent = agentId ?? targetSession.split("-")[0] ?? targetSession;
+    const baseAgent = baseAgentName(rawAgent);
+    const agentIds = rawAgent !== baseAgent ? [rawAgent, baseAgent] : [baseAgent];
+    const placeholders = agentIds.map(() => "?").join(", ");
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) as cnt
+            FROM tasks
+            WHERE assigned_to IN (${placeholders})
+              AND status = 'open'
+              AND session_scope = ?
+              AND (instance_id IS NULL OR instance_id = ?)
+              AND (assigned_tmux IS NULL OR assigned_tmux = 'unknown' OR assigned_tmux = ? OR assigned_tmux LIKE ?)`,
+      args: [...agentIds, scope, targetSession, targetSession, `${targetSession}:%`]
+    });
+    return Number(result.rows[0]?.cnt ?? 0);
+  } catch {
+    return null;
+  }
+}
+function shouldDispositionWedged(input) {
+  const rawAgent = input.targetSession.split("-")[0] ?? input.targetSession;
+  if (isExeSession(input.targetSession) || !input.targetSession.includes("-") || isCoordinatorName(rawAgent)) {
+    return false;
+  }
+  if (input.state === "offline" || input.state === "no_claude") return true;
+  if (input.hasPendingInput && input.state !== "thinking" && input.state !== "tool") return true;
+  return false;
+}
+function buildScopedInProgressTaskQuery(targetSession) {
+  if (isExeSession(targetSession) || !targetSession.includes("-")) return null;
+  const rawAgent = targetSession.split("-")[0] ?? targetSession;
+  if (isCoordinatorName(rawAgent)) return null;
+  const scope = extractRootExe(targetSession);
+  if (!scope) return null;
+  const baseAgent = baseAgentName(rawAgent);
+  const agentIds = rawAgent !== baseAgent ? [rawAgent, baseAgent] : [baseAgent];
+  const placeholders = agentIds.map(() => "?").join(", ");
+  return {
+    sql: `SELECT id FROM tasks
+            WHERE assigned_to IN (${placeholders})
+              AND status = 'in_progress'
+              AND session_scope = ?
+              AND (assigned_tmux = ? OR assigned_tmux LIKE ?)
+            ORDER BY updated_at ASC
+            LIMIT 1`,
+    args: [...agentIds, scope, targetSession, `${targetSession}:%`]
+  };
+}
+async function findScopedInProgressTaskId(targetSession) {
+  const q = buildScopedInProgressTaskQuery(targetSession);
+  if (!q) return null;
+  const { fastDbInit } = await import("./fast-db-init-4CWHSOOR.js");
+  const client = await fastDbInit();
+  const result = await client.execute(q);
+  const id = result.rows[0]?.id;
+  return id == null ? null : String(id);
+}
+function offlineIfEmpty(pane, classified) {
+  return !pane || pane.trim() === "" ? "offline" : classified;
+}
+async function dispositionWedgedSessionTask(targetSession, reason, wedge, deps) {
+  if (!shouldDispositionWedged({ targetSession, state: wedge.state, hasPendingInput: wedge.hasPendingInput })) {
+    return "not_wedged";
+  }
+  try {
+    const findTaskId = deps?.findTaskId ?? findScopedInProgressTaskId;
+    const blockTask = deps?.blockTask ?? (async (taskId2, r) => {
+      const { updateTask } = await import("./lib/tasks.js");
+      await updateTask({ taskId: taskId2, status: "blocked", result: r, preserveResultIfPresent: true });
+    });
+    const taskId = await findTaskId(targetSession);
+    if (taskId == null) return "no_task";
+    await blockTask(taskId, reason);
+    logIntercom(`DISPOSITIONED \u2192 ${targetSession} (task ${taskId.slice(0, 8)} \u2192 blocked: ${reason})`);
+    return "dispositioned";
+  } catch (e) {
+    process.stderr.write(
+      `[tmux-routing] dispositionWedgedSessionTask ${targetSession}: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return "error";
+  }
+}
+async function decideDrainSend(item, ctx) {
+  const state = offlineIfEmpty(ctx.pane, ctx.paneState);
+  const decision = decideQueuedNudgeDrain(item.intercomReason, ctx.nudgeState);
+  if (decision.action === "drop") {
+    const outcome = await ctx.disposition(
+      item.targetSession,
+      `Auto-blocked: queued ${item.intercomReason ?? "nudge"} intercom was undeliverable and revalidated stale (${decision.reason}) while the pane is wedged (state=${state}, pendingInput=${ctx.hasPendingInput}; ${item.reason}). Re-dispatch after clearing the pane.`,
+      { state, hasPendingInput: ctx.hasPendingInput }
+    );
+    if (outcome === "dispositioned") return true;
+    if (outcome === "error") return false;
+    return true;
+  }
+  const result = await ctx.deliver(item.targetSession, item.intercomReason ?? "nudge");
+  return result === "delivered" || result === "debounced" || result === "skipped_exe";
+}
 function sendIntercom(targetSession, opts) {
   const transport = getTransport();
   const startedAt = Date.now();
@@ -4351,7 +4970,7 @@ function sendIntercom(targetSession, opts) {
   }
   if ((process.env.EXE_NOTIFICATION_LEDGER ?? "").trim().toLowerCase() === "shadow") {
     const shadowScope = opts && "callerSessionScope" in opts ? opts.callerSessionScope : void 0;
-    void import("./notification-ledger-B6AVEGMV.js").then((m) => m.recordShadowNudge(targetSession, reason, shadowScope)).catch(() => {
+    void import("./notification-ledger-SZEPGJQ7.js").then((m) => m.recordShadowNudge(targetSession, reason, shadowScope)).catch(() => {
     });
   }
   if (!opts?.force && isDebounced(targetSession)) {
@@ -4472,7 +5091,7 @@ function scheduleDeferredSpawnNudge(input) {
           return;
         }
         queueIntercom(input.sessionName, `spawn nudge failed after ${attempt} attempts: ${msg}`, "signal");
-        void import("./notifications-DWXV7SVL.js").then(({ writeNotification: writeNotification2 }) => writeNotification2({
+        void import("./notifications-4UT53CDG.js").then(({ writeNotification: writeNotification2 }) => writeNotification2({
           agentId: getCoordinatorName(),
           agentRole: "COO",
           event: "error_spike",
@@ -4492,7 +5111,7 @@ async function sendKeysLiteralAsync(targetSession, text, runtime) {
   const isCodex = runtime === "codex";
   const submit = async () => {
     await new Promise((r) => setTimeout(r, isCodex ? CODEX_SUBMIT_DELAY_MS : SUBMIT_DELAY_MS));
-    await execFileAsync("tmux", ["send-keys", "-t", targetSession, isCodex ? "C-m" : "Enter"], { timeout: 1e3 });
+    await execFileAsync3("tmux", ["send-keys", "-t", targetSession, isCodex ? "C-m" : "Enter"], { timeout: 1e3 });
   };
   if (text.length >= 500) {
     const tmpDir = path8.join(os6.tmpdir(), "exe-os-intercom");
@@ -4500,8 +5119,8 @@ async function sendKeysLiteralAsync(targetSession, text, runtime) {
     const tmpFile = path8.join(tmpDir, `msg-${process.pid}-${Date.now()}.txt`);
     try {
       writeFileSync5(tmpFile, text, "utf-8");
-      await execFileAsync("tmux", ["load-buffer", tmpFile], { timeout: 3e3 });
-      await execFileAsync("tmux", ["paste-buffer", "-p", "-t", targetSession], { timeout: 3e3 });
+      await execFileAsync3("tmux", ["load-buffer", tmpFile], { timeout: 3e3 });
+      await execFileAsync3("tmux", ["paste-buffer", "-p", "-t", targetSession], { timeout: 3e3 });
       await submit();
     } finally {
       try {
@@ -4511,7 +5130,7 @@ async function sendKeysLiteralAsync(targetSession, text, runtime) {
     }
     return;
   }
-  await execFileAsync("tmux", ["send-keys", "-t", targetSession, "-l", text], { timeout: 3e3 });
+  await execFileAsync3("tmux", ["send-keys", "-t", targetSession, "-l", text], { timeout: 3e3 });
   await submit();
 }
 async function sendIntercomAsync(targetSession, opts) {
@@ -4568,7 +5187,7 @@ async function sendIntercomAsync(targetSession, opts) {
     return "debounced";
   }
   try {
-    const { stdout } = await execFileAsync("tmux", ["list-sessions", "-F", "#{session_name}"], { encoding: "utf8", timeout: 3e3 });
+    const { stdout } = await execFileAsync3("tmux", ["list-sessions", "-F", "#{session_name}"], { encoding: "utf8", timeout: 3e3 });
     const sessions = stdout.trim().split("\n").filter(Boolean);
     if (!sessions.includes(targetSession)) {
       logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
@@ -4582,7 +5201,7 @@ async function sendIntercomAsync(targetSession, opts) {
       recordResult("queued", "coordinator_no_inject");
       return "queued";
     }
-    const sessionState = getSessionState(targetSession);
+    const sessionState = await getSessionStateAsync(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session", reason);
       const batched2 = recordDebounce(targetSession);
@@ -4598,14 +5217,14 @@ async function sendIntercomAsync(targetSession, opts) {
       return "queued";
     }
     try {
-      const mode = await execFileAsync("tmux", ["display-message", "-p", "-t", targetSession, "#{pane_in_mode}"], { encoding: "utf8", timeout: 1e3 });
+      const mode = await execFileAsync3("tmux", ["display-message", "-p", "-t", targetSession, "#{pane_in_mode}"], { encoding: "utf8", timeout: 1e3 });
       if (mode.stdout.trim() === "1") {
         logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
-        await execFileAsync("tmux", ["send-keys", "-t", targetSession, "q"], { timeout: 1e3 });
+        await execFileAsync3("tmux", ["send-keys", "-t", targetSession, "q"], { timeout: 1e3 });
       }
     } catch {
     }
-    if (sessionHasPendingInput(targetSession)) {
+    if (await sessionHasPendingInputAsync(targetSession)) {
       queueIntercom(targetSession, "non-empty input buffer at send time", reason);
       const batched2 = recordDebounce(targetSession);
       logIntercom(`QUEUED \u2192 ${targetSession} (non-empty input buffer)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
@@ -4673,8 +5292,21 @@ function notifyCoordinatorTaskCompletion(coordinatorSession, agentName, taskTitl
     return false;
   }
 }
-async function ensureWorktreeAsync(projectDir, employeeName, instance) {
-  return ensureWorktree(projectDir, employeeName, instance);
+function emitOptOutBypassWarning(employeeName, projectDir) {
+  process.stderr.write(
+    `[tmux-routing] WORKTREE ISOLATION BYPASSED by explicit spawn_worktree=false for code-role ${employeeName} in real repo ${projectDir} \u2014 commits can land on main. This is a deliberate operator opt-out.
+`
+  );
+}
+function worktreeIsolationGate(employeeName, projectDir, opts) {
+  const nonGit = !isInsideGitRepo(projectDir);
+  if (opts?.spawnWorktree === false) {
+    if (!nonGit) emitOptOutBypassWarning(employeeName, projectDir);
+    return { allow: true, nonGit };
+  }
+  if (nonGit) return { allow: true, nonGit: true };
+  const message = `Worktree isolation required for code-role ${employeeName}; refusing to spawn in ${projectDir}. ${projectDir} is a git repo but the worktree could not be created (git error/timeout) \u2014 spawning here would let commits land on main. To dispatch a code-role agent here anyway, pass spawn_worktree=false (create_task) or opts.spawnWorktree=false.`;
+  return { allow: false, message };
 }
 function ensureEmployee(employeeName, exeSession, projectDir, opts) {
   employeeName = employeeName.toLowerCase();
@@ -4764,6 +5396,7 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
       return { status: "failed", sessionName: failSession, error: compat.error };
     }
   }
+  let acquiredHere = false;
   let effectiveInstance = opts?.instance;
   if (effectiveInstance === void 0 && opts?.autoInstance) {
     const free = findFreeInstance(
@@ -4778,6 +5411,7 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
         error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
       };
     }
+    acquiredHere = true;
     effectiveInstance = free === 0 ? void 0 : free;
     if (free !== null) {
       recordOrchestrationEventBestEffort({
@@ -4791,8 +5425,13 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
+  const releaseIfOwned = () => {
+    if (acquiredHere) releaseSpawnLock(sessionName);
+  };
   if (!opts?.autoInstance && !opts?.spawnLockHeld) {
-    if (!acquireSpawnLock(sessionName)) {
+    if (acquireSpawnLock(sessionName)) {
+      acquiredHere = true;
+    } else {
       const reconcile = reconcileStaleSpawnLock(sessionName);
       if (reconcile.skip) {
         process.stderr.write(
@@ -4801,7 +5440,9 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
         );
         return { status: "intercom_sent", sessionName };
       }
-      if (!acquireSpawnLock(sessionName)) {
+      if (acquireSpawnLock(sessionName)) {
+        acquiredHere = true;
+      } else {
         process.stderr.write(
           `[ensureEmployee] spawn lock re-acquired by another process for ${sessionName} after stale-lock break \u2014 skipping duplicate spawn
 `
@@ -4811,8 +5452,8 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   if (isEmployeeAlive(sessionName)) {
-    if (!opts?.autoInstance) releaseSpawnLock(sessionName);
-    const result2 = sendIntercom(sessionName, { force: true, reason: "signal" });
+    releaseIfOwned();
+    const result2 = sendIntercom(sessionName, { force: true, reason: "signal", callerSessionScope: exeSession });
     if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
       return { status: "intercom_sent", sessionName };
     }
@@ -4854,10 +5495,36 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
           process.stderr.write(`[tmux-routing] worktree isolation: ${employeeName} \u2192 ${wtPath}
 `);
         } else {
-          const msg = `Worktree isolation failed for code-role ${employeeName}; refusing to spawn in main checkout ${projectDir}`;
-          process.stderr.write(`[tmux-routing] ${msg}
+          const gate = worktreeIsolationGate(employeeName, projectDir, opts);
+          if (gate.allow) {
+            spawnOpts.cwd = projectDir;
+            spawnOpts.spawnWorktree = false;
+            const reason = gate.nonGit ? "non_git_project" : "opt_out_override";
+            process.stderr.write(
+              `[tmux-routing] WORKTREE BYPASSED: code-role ${employeeName} spawning in ${projectDir} (reason=${reason}) \u2014 no git worktree isolation
+`
+            );
+            recordOrchestrationEventBestEffort({
+              eventType: "worktree.bypassed",
+              source: "tmux-routing.ensureEmployee",
+              severity: "warn",
+              agentId: employeeName,
+              sessionScope: exeSession,
+              instanceId: effectiveInstance != null ? String(effectiveInstance) : null,
+              tmuxSession: sessionName,
+              payload: {
+                agent: employeeName,
+                cwd: projectDir,
+                reason,
+                risk: "code-role agent runs in project root without git worktree isolation"
+              }
+            });
+          } else {
+            releaseIfOwned();
+            process.stderr.write(`[tmux-routing] ${gate.message}
 `);
-          return { status: "failed", sessionName, error: msg };
+            return { status: "failed", sessionName, error: gate.message };
+          }
         }
       }
     } catch (e) {
@@ -4918,7 +5585,7 @@ async function ensureEmployeeAsync(employeeName, exeSession, projectDir, opts) {
       const emp = roster.find((e) => baseAgentName(e.name) === baseAgentName(employeeName));
       if (emp && !COORDINATOR_ROLES.has(emp.role)) {
         try {
-          const collisions = checkWorktreeCollisions(projectDir);
+          const collisions = await checkWorktreeCollisionsAsync(projectDir);
           if (collisions.length > 0) {
             for (const c of collisions) {
               process.stderr.write(
@@ -4942,11 +5609,36 @@ async function ensureEmployeeAsync(employeeName, exeSession, projectDir, opts) {
           asyncOpts.cwd = wtPath;
         } else {
           const sessionName = employeeSessionName(employeeName, exeSession, asyncOpts.instance);
-          const msg = `Worktree isolation failed for code-role ${employeeName}; refusing to spawn in main checkout ${projectDir}`;
-          process.stderr.write(`[ensureEmployeeAsync] ${msg}
+          const gate = worktreeIsolationGate(employeeName, projectDir, asyncOpts);
+          if (gate.allow) {
+            asyncOpts.cwd = projectDir;
+            asyncOpts.spawnWorktree = false;
+            const reason = gate.nonGit ? "non_git_project" : "opt_out_override";
+            process.stderr.write(
+              `[ensureEmployeeAsync] WORKTREE BYPASSED: code-role ${employeeName} spawning in ${projectDir} (reason=${reason}) \u2014 no git worktree isolation
+`
+            );
+            recordOrchestrationEventBestEffort({
+              eventType: "worktree.bypassed",
+              source: "tmux-routing.ensureEmployeeAsync",
+              severity: "warn",
+              agentId: employeeName,
+              sessionScope: exeSession,
+              instanceId: asyncOpts.instance != null ? String(asyncOpts.instance) : null,
+              tmuxSession: sessionName,
+              payload: {
+                agent: employeeName,
+                cwd: projectDir,
+                reason,
+                risk: "code-role agent runs in project root without git worktree isolation"
+              }
+            });
+          } else {
+            process.stderr.write(`[ensureEmployeeAsync] ${gate.message}
 `);
-          if (asyncOpts.spawnLockHeld) releaseSpawnLock(sessionName);
-          return { status: "failed", sessionName, error: msg };
+            if (asyncOpts.spawnLockHeld) releaseSpawnLock(sessionName);
+            return { status: "failed", sessionName, error: gate.message };
+          }
         }
       }
     } catch (err) {
@@ -4966,11 +5658,21 @@ async function ensureEmployeeAsync(employeeName, exeSession, projectDir, opts) {
     );
   }
   const result = ensureEmployee(employeeName, exeSession, projectDir, asyncOpts);
-  if (asyncOpts.spawnLockHeld && result.status === "failed" && result.sessionName) {
+  if (asyncOpts.spawnLockHeld && result.sessionName) {
     releaseSpawnLock(result.sessionName);
   }
   return result;
 }
+function decideSpawnWorktreeDiscipline(input) {
+  if (input.inWorktree) return "ok";
+  if (input.roleKnown) {
+    if (!input.isCodeRole) return "ok";
+    if (input.optOut) return "bypass";
+    return input.spawnCwdIsGitRepo ? "refuse" : "bypass";
+  }
+  if (input.optOut) return "bypass";
+  return input.spawnCwdIsGitRepo ? "refuse" : "bypass";
+}
 function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
@@ -5082,32 +5784,50 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   const spawnCwd = opts?.cwd ?? projectDir;
+  let disciplineRefusal = null;
   try {
     const inWorktree = spawnCwd.includes("/.worktrees/") || spawnCwd.includes("/.claude/worktrees/");
-    if (!inWorktree) {
-      const COORDINATOR_ROLES = /* @__PURE__ */ new Set(["COO", "CTO", "CMO"]);
-      const roster = loadEmployeesSync();
-      const emp = roster.find(
-        (e) => baseAgentName(e.name) === baseAgentName(employeeName)
-      );
-      const isCodeRole = emp != null && !COORDINATOR_ROLES.has(emp.role);
-      if (isCodeRole) {
-        const reason = opts?.cwd != null ? "preset_cwd" : "git_timeout";
-        process.stderr.write(
-          `[tmux-routing] WORKTREE BYPASSED: code-role ${employeeName} (role=${emp.role}) spawning in MAIN checkout ${spawnCwd} (reason=${reason}) \u2014 commits will land on main
-`
-        );
+    const COORDINATOR_ROLES = /* @__PURE__ */ new Set(["COO", "CTO", "CMO"]);
+    const rosterResult = loadEmployeesState();
+    const emp = rosterResult.employees.find(
+      (e) => baseAgentName(e.name) === baseAgentName(employeeName)
+    );
+    const roleKnown = emp != null;
+    const isCodeRole = emp != null && !COORDINATOR_ROLES.has(emp.role);
+    const optOut = opts?.spawnWorktree === false;
+    const spawnCwdIsGitRepo = isInsideGitRepo(spawnCwd);
+    const decision = decideSpawnWorktreeDiscipline({
+      inWorktree,
+      roleKnown,
+      isCodeRole,
+      spawnCwdIsGitRepo,
+      optOut
+    });
+    if (decision !== "ok") {
+      const reason = rosterResult.status === "error" && !roleKnown ? "roster_load_error" : opts?.cwd != null ? "preset_cwd" : !roleKnown ? "roster_miss" : "git_timeout";
+      const role = emp?.role ?? "unknown";
+      if (decision === "refuse") {
+        const rosterNote = reason === "roster_load_error" ? ` The roster failed to load (unreadable/corrupt/truncated), so ${employeeName}'s role could not be verified and is treated as code-role.` : reason === "roster_miss" ? ` ${employeeName} is not in the roster, so its role could not be verified and is treated as code-role.` : "";
+        disciplineRefusal = `Worktree isolation required for ${roleKnown ? `code-role ${employeeName} (role=${role})` : employeeName}; refusing to spawn in MAIN checkout ${spawnCwd} (reason=${reason}) \u2014 commits would land on main.${rosterNote} Pass spawn_worktree=false (create_task) or opts.spawnWorktree=false to dispatch here anyway (e.g. a non-git automation project).`;
+        process.stderr.write(`[tmux-routing] ${disciplineRefusal}
+`);
         recordOrchestrationEventBestEffort({
-          eventType: "worktree.bypassed",
+          eventType: "worktree.refused",
           source: "tmux-routing.spawnEmployee",
           severity: "warn",
           agentId: employeeName,
           sessionScope: exeSession,
           instanceId: opts?.instance != null ? String(opts.instance) : null,
           tmuxSession: sessionName,
-          payload: { agent: employeeName, role: emp.role, cwd: spawnCwd, reason }
+          payload: { agent: employeeName, role, cwd: spawnCwd, reason, rosterStatus: rosterResult.status }
         });
-      } else if (emp == null) {
+      } else {
+        const viaOptOut = optOut;
+        process.stderr.write(
+          `[tmux-routing] WORKTREE BYPASSED: ${role} ${employeeName} spawning in MAIN checkout ${spawnCwd} (reason=${reason}${viaOptOut ? ", opt-out" : ""}) \u2014 commits will land on main
+`
+        );
+        if (viaOptOut && spawnCwdIsGitRepo) emitOptOutBypassWarning(employeeName, spawnCwd);
         recordOrchestrationEventBestEffort({
           eventType: "worktree.bypassed",
           source: "tmux-routing.spawnEmployee",
@@ -5116,12 +5836,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
           sessionScope: exeSession,
           instanceId: opts?.instance != null ? String(opts.instance) : null,
           tmuxSession: sessionName,
-          payload: { agent: employeeName, role: "unknown", cwd: spawnCwd, reason: "roster_miss" }
+          payload: { agent: employeeName, role, cwd: spawnCwd, reason, optOut: viaOptOut, rosterStatus: rosterResult.status }
         });
       }
     }
   } catch {
   }
+  if (disciplineRefusal) {
+    releaseSpawnLock(sessionName);
+    return { sessionName, error: disciplineRefusal };
+  }
   const useExeAgent = !!(opts?.model && opts?.provider);
   const agentRtConfig = resolveSpawnRuntimeConfig(
     employeeName,
@@ -5493,13 +6217,6 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
 }
 
 // src/lib/task-scope.ts
-var VALID_SESSION_SCOPE_RE = /^[a-zA-Z0-9_]+$/;
-function isValidSessionScope(scope) {
-  return typeof scope === "string" && scope.length > 0 && scope.length <= 64 && VALID_SESSION_SCOPE_RE.test(scope);
-}
-function sanitizeSessionScope(scope) {
-  return isValidSessionScope(scope) ? scope : null;
-}
 function isAmbiguousMultiCoordinatorContext() {
   if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") return false;
   try {
@@ -5655,7 +6372,7 @@ function sessionScopeFilter(sessionScope, tableAlias, opts) {
 function strictSessionScopeFilter(sessionScope, tableAlias) {
   const autoDetect = sessionScope === void 0;
   const scope = autoDetect ? getCurrentSessionScope() : sessionScope;
-  if (!scope) {
+  if (scope == null) {
     if (autoDetect && isAmbiguousMultiCoordinatorContext()) {
       return { sql: " AND 1=0", args: [] };
     }
@@ -5675,6 +6392,7 @@ export {
   claudeSupportsAgentFlag,
   PROVIDER_TABLE,
   DEFAULT_PROVIDER,
+  VALID_SESSION_SCOPE_RE,
   isValidSessionScope,
   sanitizeSessionScope,
   isAmbiguousMultiCoordinatorContext,
@@ -5710,10 +6428,15 @@ export {
   checkLaneAffinity,
   resolveTask,
   createTaskCore,
+  buildTaskRowsStatement,
   queryTaskRows,
   listTasks,
+  __getLiveSessionsTmuxCalls,
+  __resetLiveSessionsCache,
   isTmuxSessionAlive,
   TASK_ALREADY_CLAIMED_PREFIX,
+  TASK_SIDECHAIN_WRITE_BLOCKED_PREFIX,
+  instanceToken,
   VALID_TASK_STATUSES,
   checkStaleCompletion,
   updateTaskStatus,
@@ -5733,6 +6456,7 @@ export {
   STALE_REVIEW_AGE_MS,
   SIGNAL_FILE_TTL_MS,
   isStale,
+  buildPendingReviewsCountStatement,
   countPendingReviews,
   countNewPendingReviewsSince,
   listPendingReviews,
@@ -5758,7 +6482,10 @@ export {
   findFreeInstance,
   verifyPaneAtCapacity,
   resolveSessionRuntime,
+  classifyPaneSessionState,
   getSessionState,
+  getSessionStateAsync,
+  sessionHasPendingInputAsync,
   isSessionBusy,
   isExeSession,
   paneHasPendingInput,
@@ -5766,11 +6493,21 @@ export {
   sessionHasPendingInput,
   decideQueuedNudgeDrain,
   countScopedPendingReviews,
+  countScopedOpenTasks,
+  shouldDispositionWedged,
+  buildScopedInProgressTaskQuery,
+  findScopedInProgressTaskId,
+  offlineIfEmpty,
+  dispositionWedgedSessionTask,
+  decideDrainSend,
   sendIntercom,
   sendIntercomAsync,
   notifyParentExe,
   notifyCoordinatorTaskCompletion,
+  emitOptOutBypassWarning,
+  worktreeIsolationGate,
   ensureEmployee,
   ensureEmployeeAsync,
+  decideSpawnWorktreeDiscipline,
   spawnEmployee
 };