@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-5AS622MM.js

@@ -0,0 +1,3958 @@
+import {
+  ensureWorktree
+} from "./chunk-KZNSOHCB.js";
+import {
+  queueIntercom
+} from "./chunk-5CHYEKMH.js";
+import {
+  buildTaskResult,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  registerSession
+} from "./chunk-OBUV3W7L.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  listTmuxSessions
+} from "./chunk-CX6GL3ZJ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-2NQQP3FF.js";
+import {
+  getAgentRuntime,
+  normalizeCcModelName
+} from "./chunk-EZ7KAZMC.js";
+import {
+  RUNTIME_TABLE
+} from "./chunk-NGP6LSV2.js";
+import {
+  PlanLimitError,
+  assertEmployeeLimitSync
+} from "./chunk-WQEUY7DC.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  getProjectName
+} from "./chunk-OPU3NYOO.js";
+import {
+  getAgentContext
+} from "./chunk-GJV3WDWM.js";
+import {
+  orgBus
+} from "./chunk-MP2AFCGL.js";
+import {
+  ensureAgentSymlink
+} from "./chunk-G33BHQCO.js";
+import {
+  expandDualPrefixTools
+} from "./chunk-HYZV25LY.js";
+import {
+  baseAgentName,
+  getClient,
+  getCoordinatorName,
+  getEmployee,
+  isCoordinatorName,
+  loadEmployees,
+  loadEmployeesSync
+} from "./chunk-CHBHR5W6.js";
+import {
+  loadDeviceId
+} from "./chunk-MOZ2YQ54.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+import {
+  atomicWriteJsonSync,
+  atomicWriteSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/tmux-routing.ts
+import { execFileSync, execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync5, appendFileSync as appendFileSync2, openSync, closeSync, writeSync, renameSync as renameSync2, constants } from "fs";
+import path5 from "path";
+import os4 from "os";
+import { fileURLToPath } from "url";
+
+// src/lib/cc-agent-support.ts
+import { execSync } from "child_process";
+var _cachedSupport = null;
+function _resetCcAgentSupportCache() {
+  _cachedSupport = null;
+}
+function claudeSupportsAgentFlag() {
+  if (_cachedSupport !== null) return _cachedSupport;
+  try {
+    const helpOutput = execSync("claude --help 2>&1", {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    _cachedSupport = /(^|\s)--agent(\b|=)/.test(helpOutput);
+  } catch {
+    _cachedSupport = false;
+  }
+  return _cachedSupport;
+}
+
+// src/lib/provider-table.ts
+var PROVIDER_TABLE = {
+  opencode: {
+    baseUrl: "https://opencode.ai/zen/go",
+    apiKeyEnv: "OPENCODE_API_KEY",
+    defaultModel: "minimax-m2.7"
+  }
+};
+var DEFAULT_PROVIDER = "default";
+function detectActiveProvider(env = process.env) {
+  const baseUrl = env.ANTHROPIC_BASE_URL;
+  if (!baseUrl) return DEFAULT_PROVIDER;
+  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
+    if (cfg.baseUrl === baseUrl) return name;
+  }
+  return DEFAULT_PROVIDER;
+}
+
+// src/lib/tmux-routing.ts
+import { unlinkSync as unlinkSync3 } from "fs";
+
+// src/lib/routing-log.ts
+import { appendFileSync, mkdirSync, existsSync, statSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+var LOG_DIR = path.join(os.homedir(), ".exe-os", "logs");
+var LOG_FILE = path.join(LOG_DIR, "routing.log");
+var dirChecked = false;
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+function ensureDir() {
+  if (dirChecked) return;
+  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+  dirChecked = true;
+}
+function rotateIfNeeded() {
+  try {
+    const stat = statSync(LOG_FILE);
+    if (stat.size > MAX_LOG_BYTES) {
+      renameSync(LOG_FILE, LOG_FILE + ".1");
+    }
+  } catch {
+  }
+}
+function logRouting(event) {
+  try {
+    ensureDir();
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const flag = event.mismatch ? " \u26A0\uFE0F MISMATCH" : "";
+    const taskRef = event.taskId ? ` task=${event.taskId.slice(0, 8)}` : "";
+    const assignee = event.assignedTo ? ` \u2192 ${event.assignedTo}` : "";
+    const details = JSON.stringify({
+      ...event.inputs && { inputs: event.inputs },
+      ...event.path && { path: event.path },
+      ...event.result !== void 0 && { result: event.result },
+      ...event.note && { note: event.note },
+      ...event.taskTitle && { title: event.taskTitle }
+    });
+    const line = `[${ts}] ${event.event} | ${event.caller}${taskRef}${assignee} | result=${event.result ?? "null"}${flag} | ${details}
+`;
+    rotateIfNeeded();
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+}
+function logSessionResolve(opts) {
+  logRouting({
+    event: "session_resolve",
+    caller: opts.caller,
+    inputs: {
+      mySession: opts.mySession,
+      alsHint: opts.alsHint || void 0,
+      envHint: opts.envHint || void 0,
+      cacheHit: opts.cacheHit,
+      liveRoots: opts.liveRoots?.join(",") || void 0
+    },
+    path: opts.path,
+    result: opts.resolved,
+    mismatch: opts.mismatch
+  });
+}
+function logTaskCreated(opts) {
+  logRouting({
+    event: "task_created",
+    caller: "createTaskCore",
+    taskId: opts.taskId,
+    taskTitle: opts.title,
+    assignedTo: opts.assignedTo,
+    inputs: {
+      callerSession: opts.callerSession,
+      resolvedSession: opts.resolvedSession
+    },
+    result: opts.sessionScope,
+    path: `scope=${opts.sessionScope ?? "null"} file=${opts.taskFile}`,
+    mismatch: opts.mismatch
+  });
+}
+function logTaskDispatch(opts) {
+  logRouting({
+    event: "task_dispatch",
+    caller: "create-task.mcp",
+    taskId: opts.taskId,
+    assignedTo: opts.assignedTo,
+    inputs: {
+      callerRoot: opts.callerRoot,
+      callerSource: opts.callerSource
+    },
+    result: opts.exeSession,
+    path: `dispatch=${opts.dispatchResult} session=${opts.sessionName ?? "none"}`,
+    note: opts.error,
+    mismatch: opts.callerRoot !== opts.exeSession && !!opts.callerRoot && !!opts.exeSession
+  });
+}
+
+// src/lib/tasks-review.ts
+import path4 from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, unlinkSync as unlinkSync2 } from "fs";
+
+// src/lib/tasks-crud.ts
+import crypto from "crypto";
+import path2 from "path";
+import os2 from "os";
+import { execSync as execSync2 } from "child_process";
+import { mkdir, writeFile, appendFile } from "fs/promises";
+import { existsSync as existsSync2, readFileSync } from "fs";
+var TASK_COMPLETION_REPORT_HEADING = "# Task Completion Report";
+var REPORTABLE_COMPLETION_STATUSES = /* @__PURE__ */ new Set(["needs_review"]);
+var FILE_PATH_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+function isStructuredTaskCompletionReport(text) {
+  return (text ?? "").trimStart().startsWith(TASK_COMPLETION_REPORT_HEADING);
+}
+function cleanReportLine(line) {
+  return line.replace(/^[-*]\s+/, "").replace(/^#+\s+/, "").trim();
+}
+function formatReportList(lines, fallback) {
+  const cleaned = lines.map(cleanReportLine).filter((line) => line.length > 0).slice(0, 12);
+  if (cleaned.length === 0) return [`- ${fallback}`];
+  return cleaned.map((line) => `- ${line}`);
+}
+function linesMatching(lines, pattern) {
+  return lines.filter((line) => pattern.test(line));
+}
+function extractMentionedArtifacts(text) {
+  const artifacts = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(FILE_PATH_RE)) {
+    if (match[1]) artifacts.add(match[1]);
+    if (artifacts.size >= 12) break;
+  }
+  return [...artifacts];
+}
+function agentRoleForReport(agentId) {
+  try {
+    const employee = loadEmployeesSync().find((e) => e.name === agentId);
+    return employee?.role ?? "employee";
+  } catch {
+    return "employee";
+  }
+}
+function buildTaskCompletionReport(input) {
+  const rawResult = (input.result ?? "").trim();
+  if (isStructuredTaskCompletionReport(rawResult)) return rawResult;
+  const sourceLines = rawResult.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const artifacts = extractMentionedArtifacts(rawResult);
+  const verificationLines = linesMatching(
+    sourceLines,
+    /\b(test|tests|tested|verify|verified|verification|typecheck|build|vitest|npm run|curl|passed|failed)\b/i
+  );
+  const findingLines = linesMatching(
+    sourceLines,
+    /\b(finding|findings|root cause|decision|discovered|discovery|constraint|gotcha|learned)\b/i
+  );
+  const followupLines = linesMatching(
+    sourceLines,
+    /\b(follow[- ]?up|risk|risks|blocker|blocked|todo|next action|remaining|caveat)\b/i
+  );
+  const statusNote = input.requestedStatus === input.status ? input.status : `${input.status} (requested ${input.requestedStatus})`;
+  const parts = [
+    TASK_COMPLETION_REPORT_HEADING,
+    "",
+    `Task: ${input.title}`,
+    `Task ID: ${input.taskId}`,
+    `Agent: ${input.agentId} (${agentRoleForReport(input.agentId)})`,
+    `Project: ${input.projectName}`,
+    `Status: ${statusNote}`,
+    `Date: ${input.completedAt}`,
+    `Reviewer: ${input.reviewer || "not specified"}`,
+    `Task file: ${input.taskFile}`,
+    "",
+    "## Outcome",
+    ...formatReportList(sourceLines, "No result summary provided."),
+    "",
+    "## What Changed",
+    ...artifacts.length > 0 ? formatReportList(artifacts, "No changed files or artifacts specified.") : ["- See outcome above; no changed files or artifacts were explicitly listed."],
+    "",
+    "## Verification",
+    ...formatReportList(verificationLines, "Not specified in completion result."),
+    "",
+    "## Key Findings",
+    ...formatReportList(findingLines, "Not specified."),
+    "",
+    "## Follow-ups / Risks",
+    ...formatReportList(followupLines, "None specified."),
+    "",
+    "## Handoff Notes",
+    "- Reviewer should verify this report against the original task requirements before closing.",
+    `- Use the task ID (${input.taskId}) and task file (${input.taskFile}) for full context.`
+  ];
+  return parts.join("\n");
+}
+function shouldNormalizeTaskResult(requestedStatus, finalStatus) {
+  return requestedStatus === "done" || REPORTABLE_COMPLETION_STATUSES.has(finalStatus);
+}
+async function writeCheckpoint(input) {
+  const client = getClient();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blockedByIds = [];
+  if (row.blocked_by) {
+    blockedByIds.push(String(row.blocked_by));
+  }
+  const checkpoint = {
+    step: input.step,
+    context_summary: input.contextSummary,
+    files_touched: input.filesTouched ?? [],
+    blocked_by_ids: blockedByIds,
+    last_checkpoint_at: now
+  };
+  const result = await client.execute({
+    sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ?,
+              last_heartbeat_at = ?, lease_expires_at = datetime(?, '+30 minutes')
+          WHERE id = ?`,
+    args: [JSON.stringify(checkpoint), now, now, now, taskId]
+  });
+  if (result.rowsAffected === 0) {
+    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
+  }
+  const countResult = await client.execute({
+    sql: "SELECT checkpoint_count FROM tasks WHERE id = ?",
+    args: [taskId]
+  });
+  const checkpointCount = Number(countResult.rows[0]?.checkpoint_count ?? 1);
+  recordOrchestrationEventBestEffort({
+    eventType: "task.checkpoint",
+    source: "tasks-crud.writeCheckpoint",
+    taskId,
+    agentId: String(row.assigned_to ?? "unknown"),
+    sessionScope: row.session_scope ? String(row.session_scope) : null,
+    projectName: row.project_name ? String(row.project_name) : null,
+    payload: { step: input.step, checkpointCount }
+  });
+  return { checkpointCount };
+}
+function extractParentFromContext(contextBody) {
+  if (!contextBody) return null;
+  const match = contextBody.match(
+    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
+  );
+  return match ? match[1].toLowerCase() : null;
+}
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+var LANE_KEYWORDS = {
+  CMO: ["sales", "script", "pitch", "offer", "copy", "objection", "brand", "content", "seo", "marketing", "newsletter", "carousel", "social", "campaign"],
+  CTO: ["spec", "architecture", "migration", "schema", "database", "design doc", "adr", "security audit", "tech stack"],
+  "Principal Engineer": ["implement", "build", "fix", "commit", "refactor", "bug", "feature", "wire", "integration"],
+  "Staff Code Reviewer": ["critique", "verdict", "review", "audit", "code quality"],
+  "Content Production Specialist": ["render", "video", "image", "b-roll", "remotion", "animation", "thumbnail"],
+  "AI Product Lead": ["competitive", "analysis", "benchmark", "compare", "scout", "evaluate", "poc"]
+};
+function buildKeywordIndex() {
+  const idx = /* @__PURE__ */ new Map();
+  for (const [role, keywords] of Object.entries(LANE_KEYWORDS)) {
+    for (const kw of keywords) {
+      const existing = idx.get(kw) ?? [];
+      existing.push(role);
+      idx.set(kw, existing);
+    }
+  }
+  return idx;
+}
+var KEYWORD_INDEX = buildKeywordIndex();
+function checkLaneAffinity(title, context, assigneeName) {
+  const employees = loadEmployeesSync();
+  const employee = employees.find((e) => e.name === assigneeName);
+  if (!employee) return void 0;
+  const assigneeRole = employee.role;
+  const text = `${title} ${context}`.toLowerCase();
+  const matchedRoles = /* @__PURE__ */ new Set();
+  for (const [keyword, roles] of KEYWORD_INDEX) {
+    if (text.includes(keyword)) {
+      for (const role of roles) matchedRoles.add(role);
+    }
+  }
+  if (matchedRoles.size === 0) return void 0;
+  if (matchedRoles.has(assigneeRole)) return void 0;
+  if (assigneeRole === "COO") return void 0;
+  const expectedRoles = Array.from(matchedRoles).join(" or ");
+  return `\u26A0\uFE0F Lane mismatch: task content suggests ${expectedRoles}, but assigned to ${assigneeName} (${assigneeRole}).`;
+}
+async function resolveTask(client, identifier, scopeSession) {
+  const scope = sessionScopeFilter(scopeSession);
+  const currentScope = typeof scope.args[0] === "string" ? String(scope.args[0]) : null;
+  const crossSessionError = (rows) => {
+    if (!currentScope || rows.length === 0) return null;
+    const unique = /* @__PURE__ */ new Map();
+    for (const row of rows) unique.set(String(row.id), row);
+    const crossSessionRows = [...unique.values()].filter((row) => {
+      const rowScope = row.session_scope === null || row.session_scope === void 0 ? null : String(row.session_scope);
+      return rowScope !== null && rowScope !== currentScope;
+    });
+    if (crossSessionRows.length === 0) return null;
+    const matches = crossSessionRows.slice(0, 5).map((row) => `${String(row.id).slice(0, 8)} "${String(row.title)}" [session:${String(row.session_scope)}]`).join(", ");
+    return new Error(
+      `Cross-session task mutation blocked: "${identifier}" belongs to another coordinator session. Current session: ${currentScope}. Matching task(s): ${matches}. Use task(action="list", cross_session=true) for read-only diagnostics, or switch to the owning session to update/close.`
+    );
+  };
+  const findUnscopedMatches = async () => {
+    const matches = [];
+    const pushRows = (rows) => {
+      for (const row of rows) {
+        if (!matches.some((m) => String(m.id) === String(row.id))) matches.push(row);
+      }
+    };
+    let result2 = await client.execute({
+      sql: "SELECT * FROM tasks WHERE id = ? LIMIT 10",
+      args: [identifier]
+    });
+    pushRows(result2.rows);
+    if (/^[a-f0-9]{7,12}$/i.test(identifier)) {
+      result2 = await client.execute({
+        sql: "SELECT * FROM tasks WHERE id LIKE ? LIMIT 10",
+        args: [`${identifier}%`]
+      });
+      pushRows(result2.rows);
+    }
+    result2 = await client.execute({
+      sql: "SELECT * FROM tasks WHERE task_file LIKE ? LIMIT 10",
+      args: [`%${identifier}%`]
+    });
+    pushRows(result2.rows);
+    result2 = await client.execute({
+      sql: "SELECT * FROM tasks WHERE title LIKE ? LIMIT 10",
+      args: [`%${identifier}%`]
+    });
+    pushRows(result2.rows);
+    return matches;
+  };
+  let result = await client.execute({
+    sql: `SELECT * FROM tasks WHERE id = ?${scope.sql}`,
+    args: [identifier, ...scope.args]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (/^[a-f0-9]{7,12}$/i.test(identifier)) {
+    result = await client.execute({
+      sql: `SELECT * FROM tasks WHERE id LIKE ?${scope.sql}`,
+      args: [`${identifier}%`, ...scope.args]
+    });
+    if (result.rows.length === 0) {
+      if (currentScope) {
+        const unscoped = await client.execute({
+          sql: `SELECT * FROM tasks WHERE id LIKE ?`,
+          args: [`${identifier}%`]
+        });
+        const err2 = crossSessionError(unscoped.rows);
+        if (err2) throw err2;
+      } else {
+        result = await client.execute({
+          sql: `SELECT * FROM tasks WHERE id LIKE ?`,
+          args: [`${identifier}%`]
+        });
+      }
+    }
+    if (result.rows.length === 1) return result.rows[0];
+    if (result.rows.length > 1) {
+      const matches = result.rows.map((r) => `${String(r.id)} "${String(r.title)}" (${String(r.status)})`).join(", ");
+      throw new Error(
+        `Multiple tasks match short-ID "${identifier}": ${matches}. Use a longer prefix to disambiguate.`
+      );
+    }
+  }
+  result = await client.execute({
+    sql: `SELECT * FROM tasks WHERE task_file LIKE ?${scope.sql}`,
+    args: [`%${identifier}%`, ...scope.args]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (result.rows.length > 1) {
+    const exact = result.rows.filter(
+      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
+    );
+    if (exact.length === 1) return exact[0];
+    const candidates = exact.length > 1 ? exact : result.rows;
+    const active = candidates.filter(
+      (r) => !["done", "cancelled"].includes(String(r.status))
+    );
+    if (active.length === 1) return active[0];
+    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
+    throw new Error(
+      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+    );
+  }
+  result = await client.execute({
+    sql: `SELECT * FROM tasks WHERE title LIKE ?${scope.sql}`,
+    args: [`%${identifier}%`, ...scope.args]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (result.rows.length > 1) {
+    const active = result.rows.filter(
+      (r) => !["done", "cancelled"].includes(String(r.status))
+    );
+    if (active.length === 1) return active[0];
+    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
+    throw new Error(
+      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+    );
+  }
+  const unscopedMatches = await findUnscopedMatches();
+  const err = crossSessionError(unscopedMatches);
+  if (err) throw err;
+  throw new Error(`Task not found in current session: ${identifier}`);
+}
+function renderTaskMarkdown(f) {
+  return `# ${f.title}
+
+## MANDATORY: When done
+
+You MUST call update_task with status "done" and a result summary when finished.
+If you skip this, your reviewer will not know you're done and your work won't be reviewed.
+Do NOT let a failed commit or any error prevent you from calling update_task(done).
+
+**ID:** ${f.id}
+**Status:** ${f.status}
+**Priority:** ${f.priority}
+**Assigned by:** ${f.assignedBy}
+**Assigned to:** ${f.assignedTo}
+**Project:** ${f.projectName}
+**Created:** ${f.created}${f.parentTaskId ? `
+**Parent task:** ${f.parentTaskId}` : ""}
+**Reviewer:** ${f.reviewer}
+
+## Context
+
+${f.context}
+`;
+}
+async function createTaskCore(input) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const slug = slugify(input.title);
+  let earlySessionScope = null;
+  let scopeMismatchWarning;
+  let callerSession = input.callerSession ?? "";
+  try {
+    const { resolveExeSession: resolveExeSession2 } = await import("./lib/tmux-routing.js");
+    let hasHttpAgentContext = false;
+    if (!callerSession) {
+      try {
+        const { getAgentContext: getAgentContext2 } = await import("./agent-context-AZTTMUHP.js");
+        const agentContext = getAgentContext2();
+        hasHttpAgentContext = Boolean(agentContext);
+        callerSession = agentContext?.sessionHint ?? "";
+      } catch {
+      }
+      if (!callerSession) {
+        callerSession = process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || "";
+      }
+    }
+    const callerRoot = callerSession.includes("-") ? callerSession.split("-").pop() ?? "" : callerSession;
+    if (callerRoot) {
+      earlySessionScope = callerRoot;
+    } else if (hasHttpAgentContext) {
+      scopeMismatchWarning = "missing X-Exe-Session header in shared MCP daemon context; task created without session scope instead of guessing from daemon tmux focus.";
+      process.stderr.write(`[create_task] ${scopeMismatchWarning}
+`);
+      earlySessionScope = null;
+    } else {
+      const resolved = resolveExeSession2();
+      if (resolved) {
+        process.stderr.write(
+          `[create_task] WARN: no caller session provided. Falling back to resolveExeSession()="${resolved}" (may be wrong). Fix: ensure MCP tool layer passes callerSession.
+`
+        );
+      }
+      if (resolved && input.projectName) {
+        const isCoordinatorSession = !resolved.includes("-");
+        if (isCoordinatorSession) {
+          earlySessionScope = resolved;
+        } else {
+          const { getSessionProject } = await import("./session-scope-HHUMJYF6.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.`;
+            process.stderr.write(`[create_task] ${scopeMismatchWarning}
+`);
+            earlySessionScope = null;
+          } else {
+            earlySessionScope = resolved;
+          }
+        }
+      } else {
+        earlySessionScope = resolved;
+      }
+    }
+  } catch {
+  }
+  const scope = earlySessionScope ?? "default";
+  const taskFile = input.taskFile ?? `tasks/${scope}/${input.assignedTo}/${slug}.md`;
+  let blockedById = null;
+  const initialStatus = input.blockedBy ? "blocked" : "open";
+  if (input.blockedBy) {
+    const blocker = await resolveTask(client, input.blockedBy, earlySessionScope);
+    blockedById = String(blocker.id);
+  }
+  let parentTaskId = null;
+  let parentRef = input.parentTaskId;
+  if (!parentRef) {
+    const extracted = extractParentFromContext(input.context);
+    if (extracted) {
+      parentRef = extracted;
+      process.stderr.write(
+        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
+      );
+    }
+  }
+  if (parentRef) {
+    try {
+      const parent = await resolveTask(client, parentRef, earlySessionScope);
+      parentTaskId = String(parent.id);
+    } catch (err) {
+      if (!input.parentTaskId) {
+        throw new Error(
+          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
+        );
+      }
+      throw err;
+    }
+  }
+  let warning;
+  const dupScope = sessionScopeFilter(earlySessionScope);
+  const dupCheck = await client.execute({
+    sql: `SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')${dupScope.sql}`,
+    args: [input.title, input.assignedTo, ...dupScope.args]
+  });
+  if (dupCheck.rows.length > 0) {
+    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
+  }
+  if (!process.env.DISABLE_LANE_AFFINITY) {
+    const laneWarning = checkLaneAffinity(input.title, input.context, input.assignedTo);
+    if (laneWarning) {
+      warning = warning ? `${warning}
+${laneWarning}` : laneWarning;
+    }
+  }
+  if (scopeMismatchWarning) {
+    warning = warning ? `${warning}
+${scopeMismatchWarning}` : scopeMismatchWarning;
+  }
+  if (input.baseDir) {
+    try {
+      await mkdir(path2.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir(path2.join(input.baseDir, "exe", "research"), { recursive: true });
+      await ensureArchitectureDoc(input.baseDir, input.projectName);
+      await ensureGitignoreExe(input.baseDir);
+    } catch {
+    }
+  }
+  const complexity = input.complexity ?? "standard";
+  const sessionScope = earlySessionScope;
+  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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        input.title,
+        input.assignedTo,
+        input.assignedBy,
+        input.projectName,
+        input.priority,
+        initialStatus,
+        taskFile,
+        blockedById,
+        parentTaskId,
+        input.reviewer ?? null,
+        input.context,
+        complexity,
+        input.budgetTokens ?? null,
+        input.budgetFallbackModel ?? null,
+        0,
+        null,
+        sessionScope,
+        input.spawnRuntime ?? null,
+        input.spawnModel ?? null,
+        loadDeviceId(),
+        input.founderId ?? null,
+        now,
+        now
+      ]
+    });
+  } catch (dbErr) {
+    process.stderr.write(
+      `[create-task] DB insert failed for "${input.title}": ${dbErr instanceof Error ? dbErr.message : String(dbErr)}
+`
+    );
+    throw dbErr;
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "task.created",
+    source: "tasks-crud.createTaskCore",
+    taskId: id,
+    agentId: input.assignedTo,
+    reviewer: input.reviewer ?? null,
+    sessionScope,
+    projectName: input.projectName,
+    instanceId: null,
+    result: initialStatus,
+    payload: {
+      priority: input.priority,
+      complexity,
+      hasBlockedBy: Boolean(blockedById),
+      hasParentTask: Boolean(parentTaskId),
+      titleLength: input.title.length
+    }
+  });
+  logTaskCreated({
+    taskId: id,
+    title: input.title,
+    assignedTo: input.assignedTo,
+    sessionScope,
+    taskFile,
+    callerSession: callerSession || "(unknown)",
+    resolvedSession: earlySessionScope,
+    mismatch: !!(callerSession && earlySessionScope && (() => {
+      const cr = callerSession.includes("-") ? callerSession.split("-").pop() ?? "" : callerSession;
+      return cr && cr !== earlySessionScope;
+    })())
+  });
+  if (input.baseDir) {
+    try {
+      const EXE_OS_DIR = path2.join(os2.homedir(), ".exe-os");
+      const mdPath = path2.join(EXE_OS_DIR, taskFile);
+      const mdDir = path2.dirname(mdPath);
+      if (!existsSync2(mdDir)) await mkdir(mdDir, { recursive: true });
+      const reviewer = input.reviewer ?? input.assignedBy;
+      const mdContent = renderTaskMarkdown({
+        id,
+        title: input.title,
+        status: initialStatus,
+        priority: input.priority,
+        assignedBy: input.assignedBy,
+        assignedTo: input.assignedTo,
+        projectName: input.projectName,
+        created: now.split("T")[0],
+        reviewer,
+        context: input.context,
+        parentTaskId
+      });
+      await writeFile(mdPath, mdContent, "utf-8");
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] WARNING: .md file write failed for ${taskFile}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return {
+    id,
+    title: input.title,
+    assignedTo: input.assignedTo,
+    assignedBy: input.assignedBy,
+    reviewer: input.reviewer ?? null,
+    projectName: input.projectName,
+    priority: input.priority,
+    status: initialStatus,
+    taskFile,
+    createdAt: now,
+    updatedAt: now,
+    warning,
+    budgetTokens: input.budgetTokens ?? null,
+    budgetFallbackModel: input.budgetFallbackModel ?? null,
+    tokensUsed: 0,
+    tokensWarnedAt: null,
+    spawnRuntime: input.spawnRuntime ?? null,
+    spawnModel: input.spawnModel ?? null,
+    sessionScope
+  };
+}
+async function queryTaskRows(opts) {
+  const client = getClient();
+  const conditions = [];
+  const args = [];
+  if (opts.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args.push(opts.assignedTo);
+  }
+  if (opts.status !== void 0) {
+    if (Array.isArray(opts.status)) {
+      conditions.push(`status IN (${opts.status.map(() => "?").join(",")})`);
+      args.push(...opts.status);
+    } else {
+      conditions.push("status = ?");
+      args.push(opts.status);
+    }
+  }
+  if (opts.reviewer) {
+    conditions.push("reviewer = ?");
+    args.push(opts.reviewer);
+  }
+  if (opts.projectName !== null) {
+    const pn = opts.projectName !== void 0 ? opts.projectName : getProjectNameSafe();
+    if (pn) {
+      conditions.push("project_name = ?");
+      args.push(pn);
+    }
+  }
+  if (opts.deviceId) {
+    conditions.push("(device_id = ? OR device_id IS NULL)");
+    args.push(opts.deviceId);
+  }
+  if (opts.sessionScope !== null && !opts.deviceId) {
+    if (opts.strictSession) {
+      const scope = strictSessionScopeFilter(opts.sessionScope);
+      if (scope.sql) {
+        const cleaned = scope.sql.replace(/^\s*AND\s+/, "");
+        conditions.push(cleaned);
+        args.push(...scope.args);
+      }
+    } else {
+      const scope = sessionScopeFilter(opts.sessionScope);
+      if (scope.sql) {
+        const cleaned = scope.sql.replace(/^\s*AND\s+/, "");
+        conditions.push(cleaned);
+        args.push(...scope.args);
+      }
+    }
+  }
+  if (opts.founderId !== null) {
+    try {
+      const { founderScopeFilter } = await import("./founder-context-Q2HUCZX4.js");
+      const founderFilter = founderScopeFilter(opts.founderId);
+      const cleaned = founderFilter.sql.replace(/^\s*AND\s+/, "");
+      conditions.push(cleaned);
+      args.push(...founderFilter.args.filter((a) => a !== null));
+    } catch {
+    }
+  }
+  if (opts.extraConditions) {
+    conditions.push(...opts.extraConditions);
+  }
+  if (opts.extraArgs) {
+    args.push(...opts.extraArgs);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const cols = opts.columns ?? "*";
+  const order = opts.orderBy ?? "priority ASC, created_at DESC";
+  const limit = opts.limit ?? 100;
+  const result = await client.execute({
+    sql: `SELECT ${cols} FROM tasks ${where} ORDER BY ${order} LIMIT ?`,
+    args: [...args, limit]
+  });
+  return result.rows;
+}
+function getProjectNameSafe() {
+  try {
+    return getProjectName() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function listTasks(input) {
+  const extraConditions = [];
+  const extraArgs = [];
+  if (input.priority) {
+    extraConditions.push("priority = ?");
+    extraArgs.push(input.priority);
+  }
+  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 queryOpts = {
+    assignedTo: input.assignedTo,
+    reviewer: input.reviewer,
+    status: input.status || void 0,
+    // Public listTasks() must not silently scope to process.cwd().
+    // MCP/tool callers resolve project scope explicitly before calling here.
+    // Auto-detecting from this library made isolated test DB rows invisible
+    // (fixtures use arbitrary project names) and, in the daemon, could hide
+    // real cross-project tasks because the shared daemon cwd is exe-os.
+    //
+    // Lower-level queryTaskRows() keeps its historical auto-detect behavior for
+    // daemon/hook callers that deliberately omit projectName. listTasks()
+    // defaults to project-unscoped unless the caller provides a project.
+    projectName: input.projectName === void 0 ? null : input.projectName || null,
+    // Skip session scope when querying your own tasks — agents must ALWAYS see
+    // their own work regardless of which coordinator session created the task.
+    // Bug: bob-exe1 couldn't see tasks created by exe1 because session_scope='exe1'
+    // didn't match bob-exe1's resolved scope.
+    sessionScope: input.crossSession || input.isOwnQuery ? null : 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"] },
+    ...extraConditions.length > 0 ? { extraConditions, extraArgs } : {}
+  };
+  let rows = await queryTaskRows(queryOpts);
+  if (rows.length === 0 && !input.crossSession && input.assignedTo) {
+    const unscopedRows = await queryTaskRows({
+      ...queryOpts,
+      sessionScope: null
+    });
+    if (unscopedRows.length > 0) {
+      process.stderr.write(
+        `[list-tasks] WARN: Session-scoped query returned 0 for ${input.assignedTo} but unscoped found ${unscopedRows.length}. Possible session_scope mismatch after daemon restart. Returning unscoped results.
+`
+      );
+      rows = unscopedRows;
+    }
+  }
+  return rows.map((r) => ({
+    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),
+    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
+  }));
+}
+var TMUX_ALIVE_CACHE_TTL_MS = Number(process.env.EXE_TMUX_ALIVE_CACHE_TTL_MS || 2e3);
+var _tmuxAliveCacheTs = 0;
+var _tmuxAliveSessions = /* @__PURE__ */ new Set();
+var _tmuxAlivePanes = /* @__PURE__ */ new Set();
+var _tmuxAliveCacheVerified = false;
+function tmuxCmd(args) {
+  const sock = process.env.EXE_TMUX_SOCKET;
+  return sock ? `tmux -L ${sock} ${args}` : `tmux ${args}`;
+}
+function refreshTmuxAliveCacheSync() {
+  const now = Date.now();
+  if (now - _tmuxAliveCacheTs < TMUX_ALIVE_CACHE_TTL_MS) return;
+  _tmuxAliveCacheTs = now;
+  _tmuxAliveCacheVerified = false;
+  _tmuxAliveSessions = /* @__PURE__ */ new Set();
+  _tmuxAlivePanes = /* @__PURE__ */ new Set();
+  try {
+    const output = execSync2(tmuxCmd("list-panes -a -F '#{session_name}	#{pane_id}	#{pane_dead}'"), {
+      timeout: 2e3,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    for (const line of output.split("\n")) {
+      const [session, paneId, paneDead] = line.split("	");
+      if (!session) continue;
+      _tmuxAliveCacheVerified = true;
+      if (paneDead !== "1") {
+        _tmuxAliveSessions.add(session);
+        if (paneId) _tmuxAlivePanes.add(paneId);
+      }
+    }
+  } catch {
+  }
+}
+function isTmuxSessionAlive(identifier) {
+  if (!identifier || identifier === "unknown") return true;
+  refreshTmuxAliveCacheSync();
+  if (!_tmuxAliveCacheVerified) return true;
+  if (identifier.startsWith("%")) return _tmuxAlivePanes.has(identifier);
+  return _tmuxAliveSessions.has(identifier);
+}
+var DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
+var TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
+  try {
+    const since = new Date(taskCreatedAt).toISOString();
+    const branch = execSync2(
+      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
+      { encoding: "utf8", timeout: 3e3 }
+    ).trim();
+    const branchArg = branch && branch !== "HEAD" ? branch : "";
+    const commitCount = execSync2(
+      `git log --oneline --since="${since}" ${branchArg} 2>/dev/null | wc -l`,
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    const count = parseInt(commitCount, 10);
+    if (count === 0) {
+      return "WARNING: task closed with no new commits since creation. Verify work was actually produced.";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function updateTaskStatus(input) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = await resolveTask(client, input.taskId);
+  const taskId = String(row.id);
+  const taskFile = String(row.task_file);
+  const requestedStatus = input.status;
+  const eventSessionScope = row.session_scope ? String(row.session_scope) : null;
+  const eventProjectName = row.project_name ? String(row.project_name) : null;
+  const eventAgentId = row.assigned_to ? String(row.assigned_to) : null;
+  const previousStatus = String(row.status);
+  if (input.status === "done") {
+    input.status = "needs_review";
+  }
+  const isReviewTransition = input.status === "needs_review" && previousStatus !== "needs_review" && previousStatus !== "closed";
+  if (isReviewTransition && row.reviewer) {
+    const reviewer = String(row.reviewer);
+    try {
+      const { sendIntercom: sendIntercom2, employeeSessionName: employeeSessionName2, resolveExeSession: resolveExeSession2, isExeSession: isExeSession2 } = await import("./lib/tmux-routing.js");
+      const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession2();
+      if (exeSession) {
+        if (isCoordinatorName(reviewer)) {
+          if (isExeSession2(exeSession)) {
+            sendIntercom2(exeSession, { force: true, reason: "completion" });
+            process.stderr.write(
+              `[tasks-crud] Review intercom sent to ${exeSession}: "${String(row.title)}" by ${String(row.assigned_to)}
+`
+            );
+          }
+        } else {
+          const reviewerSession = employeeSessionName2(reviewer, exeSession);
+          sendIntercom2(reviewerSession, { force: true, reason: "completion" });
+          process.stderr.write(
+            `[tasks-crud] Review intercom sent to ${reviewerSession}: "${String(row.title)}" by ${String(row.assigned_to)}
+`
+          );
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] Review intercom failed for ${reviewer}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    try {
+      const { reviewSignalPath, taskSignalDir } = await import("./signal-paths-4GOIRLGH.js");
+      const scope = row.session_scope ? String(row.session_scope) : "default";
+      const dir = taskSignalDir(scope);
+      const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync2 } = await import("fs");
+      mkdirSync3(dir, { recursive: true });
+      writeFileSync2(
+        reviewSignalPath(scope, reviewer, String(row.id)),
+        JSON.stringify({
+          task_id: String(row.id),
+          title: String(row.title),
+          assigned_to: String(row.assigned_to),
+          reviewer,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }),
+        "utf-8"
+      );
+    } catch {
+    }
+    try {
+      const { writeNotification: writeNotification2 } = await import("./notifications-VWPO6NJF.js");
+      await writeNotification2({
+        agentId: reviewer,
+        agentRole: isCoordinatorName(reviewer) ? "COO" : "manager",
+        event: "task_complete",
+        project: String(row.project_name ?? ""),
+        summary: `${String(row.assigned_to)} completed "${String(row.title)}" \u2014 needs your review.`,
+        taskFile,
+        sessionScope: row.session_scope ? String(row.session_scope) : void 0
+      });
+    } catch {
+    }
+  }
+  const isBlockedTransition = input.status === "blocked" && previousStatus !== "blocked";
+  if (isBlockedTransition && row.assigned_by) {
+    const dispatcher = String(row.assigned_by);
+    try {
+      const { sendIntercom: sendIntercom2, employeeSessionName: employeeSessionName2, resolveExeSession: resolveExeSession2, isExeSession: isExeSession2 } = await import("./lib/tmux-routing.js");
+      const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession2();
+      if (exeSession) {
+        if (isCoordinatorName(dispatcher)) {
+          if (isExeSession2(exeSession)) {
+            sendIntercom2(exeSession, { force: true, reason: "completion" });
+            process.stderr.write(
+              `[tasks-crud] Blocked intercom sent to ${exeSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
+`
+            );
+          }
+        } else {
+          const dispatcherSession = employeeSessionName2(dispatcher, exeSession);
+          sendIntercom2(dispatcherSession, { force: true, reason: "completion" });
+          process.stderr.write(
+            `[tasks-crud] Blocked intercom sent to ${dispatcherSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
+`
+          );
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] Blocked intercom failed for ${dispatcher}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  const VALID_TRANSITIONS = {
+    open: ["in_progress", "needs_review", "cancelled", "blocked"],
+    in_progress: ["in_progress", "open", "needs_review", "blocked", "cancelled"],
+    blocked: ["open", "in_progress", "cancelled"],
+    needs_review: ["closed", "in_progress", "open"],
+    closed: [],
+    // terminal — no transitions out
+    cancelled: ["open"]
+    // allow re-opening cancelled tasks
+  };
+  const currentStatus = String(row.status);
+  const validNext = VALID_TRANSITIONS[currentStatus];
+  if (validNext && !validNext.includes(input.status)) {
+    throw new Error(
+      `Invalid task transition: ${currentStatus} \u2192 ${input.status}. Valid transitions from "${currentStatus}": [${validNext.join(", ")}]`
+    );
+  }
+  if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
+    process.stderr.write(
+      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
+`
+    );
+  }
+  if (requestedStatus === "done") {
+    const existingRow = await client.execute({
+      sql: "SELECT context, created_at FROM tasks WHERE id = ?",
+      args: [taskId]
+    });
+    if (existingRow.rows.length > 0) {
+      const ctx = existingRow.rows[0];
+      const warning = checkStaleCompletion(ctx.context, ctx.created_at);
+      if (warning) {
+        input.result = input.result ? `\u26A0\uFE0F ${warning}
+
+${input.result}` : `\u26A0\uFE0F ${warning}`;
+        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
+`);
+      }
+    }
+  }
+  const hasStructuredFields = input.filesChanged || input.decisions || input.commits || input.testsStatus || input.buildStatus || input.prNumber || input.openQuestions;
+  if (hasStructuredFields && (requestedStatus === "done" || input.status === "needs_review")) {
+    const agentId = String(row.assigned_to ?? "unknown");
+    const typedResult = buildTaskResult({
+      from: agentId,
+      task_id: taskId,
+      summary: input.result ?? "",
+      files_changed: input.filesChanged,
+      decisions: input.decisions,
+      commits: input.commits,
+      tests: input.testsStatus,
+      build: input.buildStatus,
+      pr_number: input.prNumber,
+      open_questions: input.openQuestions
+    });
+    const serialized = serializeMessage(typedResult);
+    try {
+      await client.execute({
+        sql: "UPDATE tasks SET structured_result = ?, updated_at = ? WHERE id = ?",
+        args: [serialized, now, taskId]
+      });
+    } catch {
+      process.stderr.write(
+        `[tasks-crud] structured_result column unavailable \u2014 embedding in result text
+`
+      );
+      input.result = `<!-- STRUCTURED_RESULT:${serialized} -->
+${input.result ?? ""}`;
+    }
+  }
+  const shouldWriteCompletionMemory = shouldNormalizeTaskResult(requestedStatus, input.status) && previousStatus !== input.status && (requestedStatus === "done" || input.status === "needs_review");
+  if (shouldNormalizeTaskResult(requestedStatus, input.status)) {
+    input.result = buildTaskCompletionReport({
+      taskId,
+      title: String(row.title),
+      agentId: String(row.assigned_to),
+      projectName: String(row.project_name ?? ""),
+      status: input.status,
+      requestedStatus,
+      taskFile,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      completedAt: now,
+      result: input.result
+    });
+  }
+  if (input.status === "in_progress") {
+    const tmuxSession = input.callerSession?.trim() || process.env.TMUX_PANE || process.env.MY_TMUX_SESSION || "unknown";
+    const hasConcreteSessionName = tmuxSession !== "unknown" && !tmuxSession.startsWith("%");
+    const claimGuardSql = hasConcreteSessionName ? ` AND (instance_id IS NULL OR instance_id = ?)
+          AND (assigned_tmux IS NULL OR assigned_tmux = 'unknown' OR assigned_tmux = ? OR assigned_tmux LIKE ?)` : "";
+    const claimGuardArgs = hasConcreteSessionName ? [tmuxSession, tmuxSession, `${tmuxSession}:%`] : [];
+    const claimAgent = input.callerAgentId ?? process.env.AGENT_ID ?? String(row.assigned_to ?? "unknown");
+    const leaseMinutes = 30;
+    const estMin = input.estimatedMinutes != null ? Math.max(1, Math.round(input.estimatedMinutes)) : null;
+    const estConf = input.estimateConfidence != null ? Math.max(0, Math.min(1, input.estimateConfidence)) : null;
+    const claim = await client.execute({
+      sql: `UPDATE tasks
+            SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
+                claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
+                lease_expires_at = datetime(?, '+${leaseMinutes} minutes'),
+                claim_count = COALESCE(claim_count, 0) + 1,
+                started_at = COALESCE(started_at, ?),
+                estimated_minutes = COALESCE(?, estimated_minutes),
+                estimate_confidence = COALESCE(?, estimate_confidence)
+            WHERE id = ? AND status = 'open'${claimGuardSql}`,
+      args: [tmuxSession, now, claimAgent, now, now, now, now, estMin, estConf, taskId, ...claimGuardArgs]
+    });
+    if (claim.rowsAffected === 0) {
+      const current = await client.execute({
+        sql: "SELECT status, assigned_tmux, assigned_by 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 === "in_progress" && claimedBySession && !isTmuxSessionAlive(claimedBySession)) {
+        process.stderr.write(
+          `[tasks] Auto-releasing dead claim on ${taskId} (was ${claimedBySession})
+`
+        );
+        await client.execute({
+          sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, claimed_by = NULL, claimed_at = NULL, last_heartbeat_at = NULL, lease_expires_at = NULL, updated_at = ? WHERE id = ?",
+          args: [now, taskId]
+        });
+        const retried = await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
+                    claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
+                    lease_expires_at = datetime(?, '+${leaseMinutes} minutes'),
+                    claim_count = COALESCE(claim_count, 0) + 1
+                WHERE id = ? AND status = 'open'${claimGuardSql}`,
+          args: [tmuxSession, now, claimAgent, now, now, now, taskId, ...claimGuardArgs]
+        });
+        if (retried.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "reclaimed_dead_session",
+              contextSummary: `Task reclaimed after dead session ${claimedBySession} released.`
+            });
+          } catch {
+          }
+          recordOrchestrationEventBestEffort({
+            eventType: "task.claimed",
+            source: "tasks-crud.updateTaskStatus",
+            taskId,
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "reclaimed_dead_session"
+          });
+          recordOrchestrationEventBestEffort({
+            eventType: "task.in_progress",
+            source: "tasks-crud.updateTaskStatus",
+            taskId,
+            agentId: eventAgentId,
+            sessionScope: eventSessionScope,
+            projectName: eventProjectName,
+            tmuxSession,
+            result: "reclaimed_dead_session"
+          });
+          return { row, taskFile, now, taskId };
+        }
+      }
+      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({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
+                    claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
+                    lease_expires_at = datetime(?, '+${leaseMinutes} minutes'),
+                    claim_count = COALESCE(claim_count, 0) + 1
+                WHERE id = ?`,
+          args: [tmuxSession, now, claimAgent, now, now, now, taskId]
+        });
+        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,
+          agentId: eventAgentId,
+          sessionScope: eventSessionScope,
+          projectName: eventProjectName,
+          tmuxSession,
+          result: "assigner_override"
+        });
+        return { row, taskFile, now, taskId };
+      }
+      const claimedBy = claimedBySession ? ` (claimed by ${claimedBySession})` : "";
+      recordOrchestrationEventBestEffort({
+        eventType: "claim.collision",
+        source: "tasks-crud.updateTaskStatus",
+        severity: "warn",
+        taskId,
+        agentId: eventAgentId,
+        sessionScope: eventSessionScope,
+        projectName: eventProjectName,
+        tmuxSession,
+        result: curStatus,
+        payload: { hasClaimedBy: Boolean(claimedBySession) }
+      });
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${curStatus}${claimedBy}`);
+    }
+    try {
+      await writeCheckpoint({
+        taskId,
+        step: "claimed",
+        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+      });
+    } catch {
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "task.claimed",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      tmuxSession,
+      result: "open_to_in_progress"
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "task.in_progress",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      tmuxSession,
+      result: "open_to_in_progress"
+    });
+    if (input.assertions) {
+      try {
+        const parsed = typeof input.assertions === "string" ? JSON.parse(input.assertions) : input.assertions;
+        const assertionsArr = Array.isArray(parsed) ? parsed : [];
+        const VALID_ASSERTION_TYPES = ["diagnosis", "scope", "estimate", "approach", "build", "judgment"];
+        for (const a of assertionsArr) {
+          if (!a.type || !VALID_ASSERTION_TYPES.includes(a.type)) {
+            throw new Error(`Invalid assertion type: ${a.type}. Valid: ${VALID_ASSERTION_TYPES.join(", ")}`);
+          }
+        }
+        const payload = JSON.stringify({ assertions: assertionsArr });
+        await client.execute({
+          sql: "UPDATE tasks SET assertions = ?, updated_at = ? WHERE id = ?",
+          args: [payload, now, taskId]
+        });
+      } catch (e) {
+        process.stderr.write(
+          `[tasks-crud] assertions parse/store failed: ${e instanceof Error ? e.message : String(e)}
+`
+        );
+      }
+    }
+    return { row, taskFile, now, taskId };
+  }
+  if (input.assertionsResolved && (input.status === "needs_review" || input.status === "closed")) {
+    try {
+      const resolvedArr = typeof input.assertionsResolved === "string" ? JSON.parse(input.assertionsResolved) : input.assertionsResolved;
+      if (!Array.isArray(resolvedArr)) throw new Error("assertions_resolved must be an array");
+      const VALID_WHY_WRONG = [
+        "missing_information",
+        "wrong_diagnosis",
+        "wrong_approach",
+        "scope_underestimate",
+        "scope_overestimate",
+        "external_dependency",
+        "changed_requirements"
+      ];
+      for (const r of resolvedArr) {
+        if (r.why_wrong && !VALID_WHY_WRONG.includes(r.why_wrong)) {
+          throw new Error(`Invalid why_wrong: ${r.why_wrong}. Valid: ${VALID_WHY_WRONG.join(", ")}`);
+        }
+      }
+      const existing = await client.execute({
+        sql: "SELECT assertions FROM tasks WHERE id = ?",
+        args: [taskId]
+      });
+      const merged = { assertions: [], resolved: [] };
+      if (existing.rows.length > 0 && existing.rows[0]?.assertions) {
+        try {
+          const prev = JSON.parse(String(existing.rows[0].assertions));
+          merged.assertions = prev.assertions ?? [];
+        } catch {
+        }
+      }
+      merged.resolved = resolvedArr;
+      await client.execute({
+        sql: "UPDATE tasks SET assertions = ?, updated_at = ? WHERE id = ?",
+        args: [JSON.stringify(merged), now, taskId]
+      });
+    } catch (e) {
+      process.stderr.write(
+        `[tasks-crud] assertions_resolved parse/store failed: ${e instanceof Error ? e.message : String(e)}
+`
+      );
+    }
+  }
+  let actualMinutesClause = "";
+  let actualMinutesArgs = [];
+  if (input.status === "needs_review" || requestedStatus === "done") {
+    const startedAt = row.started_at ? String(row.started_at) : null;
+    if (startedAt) {
+      const startMs = new Date(startedAt).getTime();
+      const nowMs = new Date(now).getTime();
+      if (!Number.isNaN(startMs) && nowMs > startMs) {
+        const actualMin = Math.round((nowMs - startMs) / 6e4);
+        actualMinutesClause = ", actual_minutes = ?";
+        actualMinutesArgs = [actualMin];
+        const estMin = row.estimated_minutes ? Number(row.estimated_minutes) : null;
+        if (estMin && estMin > 0) {
+          const ratio = actualMin / estMin;
+          const accuracy = ratio <= 1 ? `${Math.round(ratio * 100)}% of estimate` : `${ratio.toFixed(1)}x over estimate`;
+          process.stderr.write(
+            `[tasks] Time estimation: estimated=${estMin}min actual=${actualMin}min (${accuracy}) \u2014 ${String(row.assigned_to)}
+`
+          );
+        }
+      }
+    }
+  }
+  if (input.result) {
+    await client.execute({
+      sql: `UPDATE tasks SET status = ?, result = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+      args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
+    });
+  } else {
+    await client.execute({
+      sql: `UPDATE tasks SET status = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+      args: [input.status, now, ...actualMinutesArgs, taskId]
+    });
+  }
+  if (input.status === "cancelled" || input.status === "closed") {
+    try {
+      await client.execute({
+        sql: `UPDATE notifications SET read = 1 WHERE task_file = ? AND read = 0`,
+        args: [taskFile]
+      });
+    } catch {
+    }
+  }
+  if (requestedStatus === "done") {
+    recordOrchestrationEventBestEffort({
+      eventType: "task.done",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: input.status
+    });
+  }
+  if (shouldWriteCompletionMemory && input.result) {
+    try {
+      const { writeMemoryViaDaemon } = await import("./memory-queue-client-O57KWE6B.js");
+      await writeMemoryViaDaemon({
+        raw_text: input.result,
+        agent_id: String(row.assigned_to),
+        agent_role: agentRoleForReport(String(row.assigned_to)),
+        session_id: eventSessionScope ?? "task-completion",
+        tool_name: "task-completion-report",
+        project_name: eventProjectName ?? "",
+        timestamp: now,
+        importance: 8,
+        task_id: taskId,
+        memory_type: "checkpoint",
+        trajectory: "completed",
+        session_scope: eventSessionScope ?? void 0
+      });
+    } catch {
+    }
+  }
+  if (input.status === "needs_review" && previousStatus !== "needs_review" && previousStatus !== "closed") {
+    recordOrchestrationEventBestEffort({
+      eventType: "review.ready",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: "needs_review"
+    });
+  }
+  if (input.status === "closed") {
+    recordOrchestrationEventBestEffort({
+      eventType: "task.closed",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: "closed"
+    });
+  }
+  if (input.status === "blocked" && previousStatus !== "blocked") {
+    recordOrchestrationEventBestEffort({
+      eventType: "task.blocked",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      payload: { blockedBy: row.blocked_by ? String(row.blocked_by) : null }
+    });
+  }
+  if (previousStatus === "blocked" && input.status !== "blocked") {
+    recordOrchestrationEventBestEffort({
+      eventType: "task.unblocked",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: input.status
+    });
+  }
+  if (input.status === "cancelled") {
+    recordOrchestrationEventBestEffort({
+      eventType: "task.cancelled",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName
+    });
+  }
+  if (input.status === "closed" && previousStatus === "needs_review") {
+    recordOrchestrationEventBestEffort({
+      eventType: "review.approved",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName
+    });
+  }
+  if (previousStatus === "needs_review" && (input.status === "open" || input.status === "in_progress")) {
+    recordOrchestrationEventBestEffort({
+      eventType: "review.rejected",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: input.status
+    });
+  }
+  try {
+    await client.execute("PRAGMA wal_checkpoint(PASSIVE)");
+  } catch {
+  }
+  if (input.status === "done" || input.status === "needs_review") {
+    try {
+      const { incrementSkillSuccess } = await import("./skill-refinement-MJPOHYD5.js");
+      await incrementSkillSuccess(
+        String(row.assigned_to),
+        row.project_name ? String(row.project_name) : null
+      );
+    } catch {
+    }
+  }
+  if (input.status === "done" || input.status === "needs_review" || input.status === "cancelled" || input.status === "closed") {
+    try {
+      const { clearQueueForAgent } = await import("./intercom-queue-A6UJEFIF.js");
+      clearQueueForAgent(String(row.assigned_to));
+    } catch {
+    }
+  }
+  try {
+    await writeCheckpoint({
+      taskId,
+      step: `status_transition:${input.status}`,
+      contextSummary: input.result ? `Transitioned to ${input.status}. Result: ${input.result.slice(0, 500)}` : `Transitioned to ${input.status}.`
+    });
+  } catch {
+  }
+  return { row, taskFile, now, taskId };
+}
+async function deleteTaskCore(taskId, _baseDir) {
+  const client = getClient();
+  const row = await resolveTask(client, taskId);
+  const id = String(row.id);
+  const taskFile = String(row.task_file);
+  const assignedTo = String(row.assigned_to);
+  const assignedBy = String(row.assigned_by);
+  await client.execute({ sql: "DELETE FROM tasks WHERE id = ?", args: [id] });
+  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "";
+  return { taskFile, assignedTo, assignedBy, taskSlug };
+}
+async function ensureArchitectureDoc(baseDir, projectName) {
+  const archPath = path2.join(baseDir, "exe", "ARCHITECTURE.md");
+  try {
+    if (existsSync2(archPath)) return;
+    const template = [
+      `# ${projectName} \u2014 System Architecture`,
+      "",
+      "> Employees: read this before every task. Update it when you change system structure.",
+      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+      "",
+      "## Overview",
+      "",
+      "<!-- Describe what this system does, its main components, and how they connect. -->",
+      "",
+      "## Key Components",
+      "",
+      "<!-- List the major modules, services, or subsystems. -->",
+      "",
+      "## Data Flow",
+      "",
+      "<!-- How does data move through the system? What writes where? -->",
+      "",
+      "## Invariants",
+      "",
+      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
+      "",
+      "## Dependencies",
+      "",
+      "<!-- What depends on what? If I change X, what else is affected? -->",
+      ""
+    ].join("\n");
+    await writeFile(archPath, template, "utf-8");
+  } catch {
+  }
+}
+async function ensureGitignoreExe(baseDir) {
+  const gitignorePath = path2.join(baseDir, ".gitignore");
+  try {
+    if (existsSync2(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (/^\/?exe\/?$/m.test(content)) return;
+      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
+    } else {
+      await writeFile(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
+    }
+  } catch {
+  }
+}
+async function cleanOrphanedTaskFiles() {
+  const { readdir, unlink, stat } = await import("fs/promises");
+  const EXE_TASKS_DIR = path2.join(os2.homedir(), ".exe-os", "tasks");
+  if (!existsSync2(EXE_TASKS_DIR)) return 0;
+  const client = getClient();
+  let cleaned = 0;
+  async function walkDir(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walkDir(fullPath);
+      } else if (entry.name.endsWith(".md")) {
+        const relativePath = path2.relative(path2.join(os2.homedir(), ".exe-os"), fullPath);
+        try {
+          const result = await client.execute({
+            sql: "SELECT id FROM tasks WHERE task_file = ? LIMIT 1",
+            args: [relativePath]
+          });
+          if (result.rows.length === 0) {
+            const filenameBase = entry.name.replace(/\.md$/, "");
+            const idCheck = await client.execute({
+              sql: "SELECT id FROM tasks WHERE id LIKE ? LIMIT 1",
+              args: [`${filenameBase}%`]
+            });
+            if (idCheck.rows.length === 0) {
+              const fileStat = await stat(fullPath);
+              const ageMs = Date.now() - fileStat.mtimeMs;
+              if (ageMs > 24 * 60 * 60 * 1e3) {
+                await unlink(fullPath);
+                cleaned++;
+                recordOrchestrationEventBestEffort({
+                  eventType: "task_file.orphan_cleaned",
+                  source: "tasks-crud.cleanOrphanedTaskFiles",
+                  severity: "warn",
+                  payload: {
+                    ageHours: Math.round(ageMs / 36e5),
+                    type: "task_file_missing_db"
+                  }
+                });
+                process.stderr.write(`[task-cleanup] Removed orphan task file: ${relativePath}
+`);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await walkDir(EXE_TASKS_DIR);
+  return cleaned;
+}
+async function readLatestCheckpoint(agentId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT checkpoint, checkpoint_count FROM tasks
+          WHERE assigned_to = ?
+            AND status IN ('in_progress', 'open')
+            AND checkpoint IS NOT NULL
+          ORDER BY updated_at DESC
+          LIMIT 1`,
+    args: [agentId]
+  });
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  const checkpointJson = row.checkpoint;
+  if (!checkpointJson) return null;
+  try {
+    return JSON.parse(String(checkpointJson));
+  } catch {
+    return null;
+  }
+}
+async function createTaskGroup(input) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `INSERT INTO task_groups (id, title, coordinator, session_scope, project_name, timeout_minutes, on_partial_failure, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      input.title,
+      input.coordinator,
+      input.sessionScope ?? null,
+      input.projectName ?? null,
+      input.timeoutMinutes ?? 120,
+      input.onPartialFailure ?? "notify",
+      now,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "task_group.created",
+    source: "tasks-crud.createTaskGroup",
+    agentId: input.coordinator,
+    sessionScope: input.sessionScope ?? null,
+    projectName: input.projectName ?? null,
+    payload: { groupId: id, title: input.title, timeoutMinutes: input.timeoutMinutes ?? 120 }
+  });
+  return {
+    id,
+    title: input.title,
+    coordinator: input.coordinator,
+    sessionScope: input.sessionScope ?? null,
+    projectName: input.projectName ?? null,
+    timeoutMinutes: input.timeoutMinutes ?? 120,
+    onPartialFailure: input.onPartialFailure ?? "notify",
+    barrierFired: false,
+    barrierFiredAt: null,
+    aggregatedResult: null,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function getGroupStatus(groupId) {
+  const client = getClient();
+  const groupResult = await client.execute({
+    sql: "SELECT id, title, barrier_fired, timeout_minutes, created_at FROM task_groups WHERE id = ?",
+    args: [groupId]
+  });
+  if (groupResult.rows.length === 0) throw new Error(`Task group not found: ${groupId}`);
+  const group = groupResult.rows[0];
+  const tasksResult = await client.execute({
+    sql: `SELECT status FROM tasks WHERE group_id = ?`,
+    args: [groupId]
+  });
+  const total = tasksResult.rows.length;
+  let completed = 0;
+  let failed = 0;
+  let pending = 0;
+  for (const row of tasksResult.rows) {
+    const status = String(row.status);
+    if (status === "done" || status === "needs_review" || status === "closed") {
+      completed++;
+    } else if (status === "cancelled") {
+      failed++;
+    } else {
+      pending++;
+    }
+  }
+  const createdAt = new Date(String(group.created_at)).getTime();
+  const timeoutMs = Number(group.timeout_minutes) * 6e4;
+  const timedOut = Date.now() - createdAt > timeoutMs;
+  return {
+    groupId,
+    title: String(group.title),
+    total,
+    completed,
+    failed,
+    pending,
+    barrierFired: Number(group.barrier_fired) === 1,
+    timedOut
+  };
+}
+async function getGroupResults(groupId) {
+  const client = getClient();
+  const groupCheck = await client.execute({
+    sql: "SELECT id FROM task_groups WHERE id = ?",
+    args: [groupId]
+  });
+  if (groupCheck.rows.length === 0) throw new Error(`Task group not found: ${groupId}`);
+  const result = await client.execute({
+    sql: `SELECT id, title, status, result, structured_result FROM tasks WHERE group_id = ?`,
+    args: [groupId]
+  });
+  return result.rows.map((r) => ({
+    taskId: String(r.id),
+    title: String(r.title),
+    status: String(r.status),
+    result: r.result != null ? String(r.result) : null
+  }));
+}
+async function getAggregatedGroupResults(groupId) {
+  const { parseMessage, isTypedMessage } = await import("./typed-messages-TKDGVPHS.js");
+  const client = getClient();
+  const groupCheck = await client.execute({
+    sql: "SELECT id FROM task_groups WHERE id = ?",
+    args: [groupId]
+  });
+  if (groupCheck.rows.length === 0) throw new Error(`Task group not found: ${groupId}`);
+  const result = await client.execute({
+    sql: `SELECT id, title, status, result, structured_result FROM tasks WHERE group_id = ?`,
+    args: [groupId]
+  });
+  const filesChanged = /* @__PURE__ */ new Set();
+  const allCommits = [];
+  const allDecisions = [];
+  const prNumbers = [];
+  const openQuestions = [];
+  let overallTests = "none";
+  let overallBuild = "skip";
+  const tasks = [];
+  for (const r of result.rows) {
+    tasks.push({
+      taskId: String(r.id),
+      title: String(r.title),
+      status: String(r.status),
+      result: r.result != null ? String(r.result) : null
+    });
+    let structuredJson = r.structured_result ? String(r.structured_result) : null;
+    if (!structuredJson && r.result) {
+      const resultStr = String(r.result);
+      const match = resultStr.match(/<!-- STRUCTURED_RESULT:(.*?) -->/);
+      if (match) structuredJson = match[1];
+    }
+    if (structuredJson) {
+      const parsed = parseMessage(structuredJson);
+      if (isTypedMessage(parsed) && parsed.type === "task_result") {
+        const p = parsed.payload;
+        for (const f of p.files_changed) filesChanged.add(f);
+        allCommits.push(...p.commits);
+        allDecisions.push(...p.decisions);
+        openQuestions.push(...p.open_questions);
+        if (p.pr_number) prNumbers.push(p.pr_number);
+        if (p.tests === "fail") overallTests = "fail";
+        else if (p.tests === "pass" && overallTests !== "fail") overallTests = "pass";
+        else if (p.tests === "skip" && overallTests === "none") overallTests = "skip";
+        if (p.build === "fail") overallBuild = "fail";
+        else if (p.build === "pass" && overallBuild !== "fail") overallBuild = "pass";
+      }
+    }
+  }
+  return {
+    groupId,
+    totalTasks: result.rows.length,
+    filesChanged: [...filesChanged],
+    allCommits,
+    allDecisions,
+    overallTests,
+    overallBuild,
+    prNumbers,
+    openQuestions,
+    tasks
+  };
+}
+async function checkAndFireBarriers() {
+  const client = getClient();
+  const firedGroups = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const activeGroups = await client.execute({
+    sql: `SELECT g.id, g.title, g.coordinator, g.timeout_minutes,
+                 g.on_partial_failure, g.session_scope, g.project_name, g.created_at
+          FROM task_groups g
+          WHERE g.barrier_fired = 0`,
+    args: []
+  });
+  for (const group of activeGroups.rows) {
+    const groupId = String(group.id);
+    const coordinator = String(group.coordinator);
+    const onPartialFailure = String(group.on_partial_failure);
+    const sessionScope = group.session_scope != null ? String(group.session_scope) : null;
+    const projectName = group.project_name != null ? String(group.project_name) : null;
+    const taskResult = await client.execute({
+      sql: `SELECT status, id, title, result FROM tasks WHERE group_id = ?`,
+      args: [groupId]
+    });
+    const total = taskResult.rows.length;
+    if (total === 0) continue;
+    const terminal = taskResult.rows.filter((r) => {
+      const s = String(r.status);
+      return s === "done" || s === "needs_review" || s === "closed" || s === "cancelled";
+    });
+    const createdAt = new Date(String(group.created_at)).getTime();
+    const timeoutMs = Number(group.timeout_minutes) * 6e4;
+    const timedOut = Date.now() - createdAt > timeoutMs;
+    const allTerminal = terminal.length === total;
+    if (!allTerminal && !timedOut) continue;
+    const succeeded = terminal.filter((r) => {
+      const s = String(r.status);
+      return s === "done" || s === "needs_review" || s === "closed";
+    }).length;
+    const cancelled = terminal.filter((r) => String(r.status) === "cancelled").length;
+    const pending = total - terminal.length;
+    const taskResults = taskResult.rows.map((r) => ({
+      task_id: String(r.id),
+      title: String(r.title),
+      status: String(r.status),
+      result: r.result != null ? String(r.result) : null
+    }));
+    const aggregatedResult = JSON.stringify({
+      total,
+      succeeded,
+      cancelled,
+      pending,
+      timed_out: timedOut,
+      tasks: taskResults
+    });
+    await client.execute({
+      sql: `UPDATE task_groups SET barrier_fired = 1, barrier_fired_at = ?, aggregated_result = ?, updated_at = ? WHERE id = ?`,
+      args: [now, aggregatedResult, now, groupId]
+    });
+    if (onPartialFailure === "cancel_remaining" && pending > 0) {
+      const nonTerminal = taskResult.rows.filter((r) => {
+        const s = String(r.status);
+        return s !== "done" && s !== "needs_review" && s !== "closed" && s !== "cancelled";
+      });
+      for (const task of nonTerminal) {
+        try {
+          await client.execute({
+            sql: "UPDATE tasks SET status = 'cancelled', result = ?, updated_at = ? WHERE id = ?",
+            args: [`Cancelled by task group barrier (group: ${groupId})`, now, String(task.id)]
+          });
+          recordOrchestrationEventBestEffort({
+            eventType: "task.cancelled",
+            source: "tasks-crud.checkAndFireBarriers",
+            taskId: String(task.id),
+            agentId: null,
+            sessionScope,
+            projectName,
+            payload: { reason: "barrier_cancel_remaining", groupId }
+          });
+        } catch {
+        }
+      }
+    }
+    const eventType = timedOut ? "task_group.timeout" : "task_group.barrier_fired";
+    recordOrchestrationEventBestEffort({
+      eventType,
+      source: "tasks-crud.checkAndFireBarriers",
+      agentId: coordinator,
+      sessionScope,
+      projectName,
+      payload: {
+        groupId,
+        title: String(group.title),
+        total,
+        succeeded,
+        cancelled,
+        pending,
+        timedOut,
+        onPartialFailure
+      }
+    });
+    if (cancelled > 0 || pending > 0) {
+      recordOrchestrationEventBestEffort({
+        eventType: "task_group.partial_failure",
+        source: "tasks-crud.checkAndFireBarriers",
+        agentId: coordinator,
+        sessionScope,
+        projectName,
+        payload: {
+          groupId,
+          total,
+          succeeded,
+          cancelled,
+          pending,
+          onPartialFailure
+        }
+      });
+    }
+    firedGroups.push(groupId);
+  }
+  return firedGroups;
+}
+async function checkTaskFileConsistency() {
+  const client = getClient();
+  let mismatches = 0;
+  try {
+    const result = await client.execute({
+      sql: `SELECT id, title, task_file, status, priority, assigned_to, assigned_by,
+                   reviewer, context, parent_task_id, created_at, session_scope, project_name
+            FROM tasks
+            WHERE status IN ('open', 'in_progress', 'needs_review', 'blocked')
+              AND task_file IS NOT NULL AND task_file != ''`,
+      args: []
+    });
+    for (const row of result.rows) {
+      const taskFile = String(row.task_file ?? "");
+      if (!taskFile) continue;
+      const fullPath = taskFile.startsWith("/") ? taskFile : path2.join(os2.homedir(), ".exe-os", taskFile);
+      if (existsSync2(fullPath)) continue;
+      let repaired = false;
+      try {
+        const dir = path2.dirname(fullPath);
+        if (!existsSync2(dir)) await mkdir(dir, { recursive: true });
+        const mdContent = renderTaskMarkdown({
+          id: String(row.id),
+          title: String(row.title ?? ""),
+          status: String(row.status ?? ""),
+          priority: String(row.priority ?? ""),
+          assignedBy: String(row.assigned_by ?? ""),
+          assignedTo: String(row.assigned_to ?? ""),
+          projectName: String(row.project_name ?? ""),
+          created: String(row.created_at ?? "").split("T")[0] || "",
+          reviewer: row.reviewer ? String(row.reviewer) : row.assigned_by ? String(row.assigned_by) : "",
+          context: String(row.context ?? ""),
+          parentTaskId: row.parent_task_id ? String(row.parent_task_id) : null
+        });
+        await writeFile(fullPath, mdContent, "utf-8");
+        repaired = true;
+      } catch {
+      }
+      if (repaired) {
+        recordOrchestrationEventBestEffort({
+          eventType: "consistency.repaired",
+          source: "tasks-crud.checkTaskFileConsistency",
+          severity: "info",
+          taskId: String(row.id),
+          agentId: row.assigned_to ? String(row.assigned_to) : null,
+          sessionScope: row.session_scope ? String(row.session_scope) : null,
+          projectName: row.project_name ? String(row.project_name) : null,
+          payload: { taskFile, status: String(row.status), type: "db_row_missing_file_regenerated" }
+        });
+      } else {
+        mismatches++;
+        recordOrchestrationEventBestEffort({
+          eventType: "consistency.mismatch",
+          source: "tasks-crud.checkTaskFileConsistency",
+          severity: "warn",
+          taskId: String(row.id),
+          agentId: row.assigned_to ? String(row.assigned_to) : null,
+          sessionScope: row.session_scope ? String(row.session_scope) : null,
+          projectName: row.project_name ? String(row.project_name) : null,
+          payload: { taskFile, status: String(row.status), type: "db_row_missing_file" }
+        });
+      }
+    }
+  } catch {
+  }
+  return mismatches;
+}
+
+// src/lib/notifications.ts
+import crypto2 from "crypto";
+import path3 from "path";
+import os3 from "os";
+import {
+  readFileSync as readFileSync2,
+  readdirSync,
+  unlinkSync,
+  existsSync as existsSync3,
+  rmdirSync
+} from "fs";
+var CLEANUP_DAYS = 7;
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto2.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        sessionScope,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function readUnreadNotifications(agentFilter, sessionScope) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    const scope = strictSessionScopeFilter(sessionScope ?? null);
+    if (agentFilter) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter);
+    }
+    const result = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, session_scope, created_at
+            FROM notifications
+            WHERE ${conditions.join(" AND ")}${scope.sql}
+            ORDER BY created_at ASC`,
+      args: [...args, ...scope.args]
+    });
+    return result.rows.map((r) => ({
+      id: String(r.id),
+      agentId: String(r.agent_id),
+      agentRole: String(r.agent_role),
+      event: String(r.event),
+      project: String(r.project),
+      summary: String(r.summary),
+      taskFile: r.task_file ? String(r.task_file) : void 0,
+      sessionScope: r.session_scope == null ? null : String(r.session_scope),
+      timestamp: String(r.created_at),
+      read: false
+    }));
+  } catch {
+    return [];
+  }
+}
+async function markAsRead(ids, sessionScope) {
+  if (ids.length === 0) return;
+  try {
+    const client = getClient();
+    const placeholders = ids.map(() => "?").join(", ");
+    const scope = strictSessionScopeFilter(sessionScope ?? null);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})${scope.sql}`,
+      args: [...ids, ...scope.args]
+    });
+  } catch {
+  }
+}
+async function markAsReadByTaskFile(taskFile, sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope ?? null);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE task_file = ? AND read = 0${scope.sql}`,
+      args: [taskFile, ...scope.args]
+    });
+  } catch {
+  }
+}
+async function cleanupOldNotifications(daysOld = CLEANUP_DAYS, sessionScope) {
+  try {
+    const client = getClient();
+    const cutoff = new Date(
+      Date.now() - daysOld * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const scope = strictSessionScopeFilter(sessionScope ?? null);
+    const result = await client.execute({
+      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
+      args: [cutoff, ...scope.args]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead(sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope ?? null);
+    const result = await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE read = 0
+              AND task_file IS NOT NULL
+              ${scope.sql}
+              AND task_file IN (
+                SELECT task_file FROM tasks WHERE status IN ('done', 'closed', 'cancelled')
+              )`,
+      args: [...scope.args]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+function formatNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const n of notifications) {
+    const key = `${n.agentId}|${n.agentRole}`;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(n);
+  }
+  const lines = [];
+  lines.push(`## Notifications (${notifications.length} unread)
+`);
+  for (const [key, items] of grouped) {
+    const [agentId, agentRole] = key.split("|");
+    lines.push(`**${agentId}** (${agentRole}):`);
+    for (const item of items) {
+      const ago = formatTimeAgo(item.timestamp);
+      const icon = eventIcon(item.event);
+      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function migrateJsonNotifications() {
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path3.join(os3.homedir(), ".exe-os");
+  const notifDir = path3.join(base, "notifications");
+  if (!existsSync3(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path3.join(notifDir, file);
+        const data = JSON.parse(readFileSync2(filePath, "utf8"));
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            crypto2.randomUUID(),
+            data.agentId ?? "unknown",
+            data.agentRole ?? "unknown",
+            data.event ?? "session_summary",
+            data.project ?? "unknown",
+            data.summary ?? "",
+            data.taskFile ?? null,
+            null,
+            data.read ? 1 : 0,
+            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          ]
+        });
+        unlinkSync(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync(notifDir);
+      if (remaining.length === 0) {
+        rmdirSync(notifDir);
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return migrated;
+}
+function eventIcon(event) {
+  switch (event) {
+    case "task_complete":
+      return "Completed:";
+    case "task_needs_fix":
+      return "Needs fix:";
+    case "session_summary":
+      return "Session:";
+    case "error_spike":
+      return "Errors:";
+    case "orphan_task":
+      return "Orphan:";
+    case "subtasks_complete":
+      return "Subtasks done:";
+    case "task_group_barrier":
+      return "Task group:";
+    case "capacity_relaunch":
+      return "Relaunched:";
+  }
+}
+function formatTimeAgo(timestamp) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/lib/tasks-review.ts
+function formatAge(isoTimestamp) {
+  if (!isoTimestamp) return "";
+  const ms = Date.now() - new Date(isoTimestamp).getTime();
+  if (ms < 0) return "just now";
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function isStale(isoTimestamp) {
+  if (!isoTimestamp) return false;
+  return Date.now() - new Date(isoTimestamp).getTime() > 24 * 60 * 60 * 1e3;
+}
+async function countPendingReviews(sessionScope, reviewer) {
+  const extraConditions = reviewer ? ["reviewer = ?"] : void 0;
+  const extraArgs = reviewer ? [reviewer] : void 0;
+  const rows = await queryTaskRows({
+    status: "needs_review",
+    columns: "COUNT(*) as cnt",
+    sessionScope: sessionScope ?? null,
+    strictSession: sessionScope !== void 0,
+    projectName: null,
+    // no project filter for review counts
+    extraConditions,
+    extraArgs,
+    limit: 1,
+    orderBy: "1"
+  });
+  return Number(rows[0]?.cnt) || 0;
+}
+async function countNewPendingReviewsSince(sinceIso, sessionScope, reviewer) {
+  const extraConditions = ["updated_at > ?"];
+  const extraArgs = [sinceIso];
+  if (reviewer) {
+    extraConditions.push("reviewer = ?");
+    extraArgs.push(reviewer);
+  }
+  const rows = await queryTaskRows({
+    status: "needs_review",
+    columns: "COUNT(*) as cnt",
+    sessionScope: sessionScope ?? null,
+    strictSession: sessionScope !== void 0,
+    projectName: null,
+    limit: 1,
+    orderBy: "1",
+    extraConditions,
+    extraArgs
+  });
+  return Number(rows[0]?.cnt) || 0;
+}
+async function listPendingReviews(limit, sessionScope, projectName, reviewer) {
+  const extraConditions = reviewer ? ["reviewer = ?"] : void 0;
+  const extraArgs = reviewer ? [reviewer] : void 0;
+  const rows = await queryTaskRows({
+    status: "needs_review",
+    columns: "title, assigned_to, reviewer, project_name, updated_at",
+    sessionScope: sessionScope ?? null,
+    strictSession: sessionScope !== void 0,
+    projectName: projectName ?? null,
+    extraConditions,
+    extraArgs,
+    limit,
+    orderBy: "updated_at ASC"
+  });
+  return rows;
+}
+async function cleanupOrphanedReviews(sessionScope) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const scope = sessionScopeFilter(sessionScope);
+  const r1 = await client.execute({
+    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+          WHERE status IN ('open', 'needs_review', 'in_progress')
+          AND assigned_by = 'system'
+          AND title LIKE 'Review:%'
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled', 'closed'))
+          ${scope.sql}`,
+    args: [now, ...scope.args]
+  });
+  const r1b = await client.execute({
+    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+          WHERE status IN ('open', 'needs_review')
+          AND title LIKE 'Review:%completed%'
+          AND (parent_task_id IS NULL OR parent_task_id NOT IN (SELECT id FROM tasks WHERE status IN ('open', 'in_progress', 'needs_review', 'blocked')))
+          ${scope.sql}`,
+    args: [now, ...scope.args]
+  });
+  const staleThreshold = new Date(Date.now() - 60 * 60 * 1e3).toISOString();
+  const r2 = await client.execute({
+    sql: `UPDATE tasks SET status = 'closed', updated_at = ?
+          WHERE status = 'needs_review'
+          AND result IS NOT NULL
+          AND updated_at < ?
+          ${scope.sql}`,
+    args: [now, staleThreshold, ...scope.args]
+  });
+  const total = r1.rowsAffected + (r1b?.rowsAffected ?? 0) + r2.rowsAffected;
+  if (total > 0) {
+    process.stderr.write(
+      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r1b?.rowsAffected ?? 0} orphan + ${r2.rowsAffected} stale
+`
+    );
+  }
+  return total;
+}
+function getReviewChecklist(role, agent, taskSlug) {
+  const roleLower = role.toLowerCase();
+  if (roleLower.includes("engineer") || roleLower === "principal engineer") {
+    return {
+      lens: "Code Quality (Engineer)",
+      checklist: [
+        "1. Do all tests pass? Any new tests needed?",
+        "2. Is the code clean \u2014 no dead code or unclassified deferred-work markers left?",
+        "3. Does it follow existing patterns and conventions in the codebase?",
+        "4. Any regressions in the test suite?"
+      ]
+    };
+  }
+  if (roleLower === "cto" || roleLower.includes("architect")) {
+    return {
+      lens: "Architecture (CTO)",
+      checklist: [
+        "1. Does this fit the existing architecture? Consistent with ARCHITECTURE.md?",
+        "2. Is it backward compatible? Any breaking changes?",
+        "3. Does it introduce technical debt? Is that debt justified?",
+        "4. Security implications? Any new attack surface?",
+        "5. Does it scale? Performance considerations?",
+        "6. Coordination: does this affect other employees' work or other projects?"
+      ]
+    };
+  }
+  if (roleLower === "coo" || roleLower.includes("operations")) {
+    return {
+      lens: "Strategic (COO)",
+      checklist: [
+        "1. Does this serve the project mission?",
+        "2. Is this the right work at the right time?",
+        "3. Does the architectural assessment make sense for the business?",
+        "4. Any cross-project implications?"
+      ]
+    };
+  }
+  return {
+    lens: "General",
+    checklist: [
+      "1. Read the original task's acceptance criteria",
+      `2. Check git log for related commits: \`git log --oneline --author-date-order -10\``,
+      "3. Verify code changes match requirements",
+      "4. Check if tests were added/updated",
+      `5. Look for output files in exe/output/${agent}-${taskSlug}*`
+    ]
+  };
+}
+async function createReviewForCompletedTask(row, result, _baseDir, now) {
+  const taskFile = String(row.task_file);
+  const employees = await loadEmployees();
+  const coordinatorName = getCoordinatorName(employees);
+  if (isCoordinatorName(String(row.assigned_to), employees)) return;
+  if (String(row.title).startsWith("Review:")) return;
+  const fileName = taskFile.split("/").pop() ?? "";
+  if (fileName.startsWith("review-") && String(row.assigned_by) === "system") return;
+  if (fileName.startsWith("review-") && String(row.assigned_to) === "system") return;
+  const client = getClient();
+  const agent = String(row.assigned_to);
+  const rawReviewer = row.reviewer || row.assigned_by;
+  const reviewer = rawReviewer ? String(rawReviewer) : coordinatorName;
+  const currentStatus = String(row.status ?? "");
+  if (currentStatus === "closed") return;
+  const existingResult = String(row.result ?? "");
+  if (existingResult.includes("## Review notes")) return;
+  let reviewerRole = "unknown";
+  try {
+    const emp = getEmployee(employees, reviewer);
+    if (emp) reviewerRole = emp.role;
+  } catch {
+  }
+  const taskTitle = String(row.title);
+  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "unknown";
+  const { lens, checklist } = getReviewChecklist(reviewerRole, agent, taskSlug);
+  process.stderr.write(
+    `[review] Annotating "${taskTitle}" for review by ${reviewer} (${reviewerRole})
+`
+  );
+  const reviewNotes = [
+    `
+---
+## Review notes`,
+    `Review lens: ${lens}`,
+    `Reviewer: **${reviewer}** (${reviewerRole})`,
+    "",
+    "### Checklist",
+    ...checklist,
+    "",
+    "### Verdict",
+    "- **Approved:** mark this task as done",
+    "- **Needs work:** re-open with notes"
+  ].join("\n");
+  const originalTaskId = String(row.id);
+  const updatedResult = (result ?? "No result summary provided") + reviewNotes;
+  await client.execute({
+    sql: `UPDATE tasks SET result = ?, status = 'needs_review', updated_at = ?
+          WHERE id = ?`,
+    args: [updatedResult, now, originalTaskId]
+  });
+  orgBus.emit({
+    type: "review_created",
+    reviewId: originalTaskId,
+    employee: agent,
+    reviewer,
+    timestamp: now
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "review.created",
+    source: "tasks-review.annotateForReview",
+    taskId: originalTaskId,
+    agentId: agent,
+    reviewer,
+    sessionScope: row.session_scope ? String(row.session_scope) : null,
+    projectName: row.project_name ? String(row.project_name) : null
+  });
+  await writeNotification({
+    agentId: agent,
+    agentRole: String(row.assigned_to),
+    event: "task_complete",
+    project: String(row.project_name),
+    summary: `completed "${taskTitle}" \u2014 ready for review`,
+    taskFile,
+    sessionScope: row.session_scope ? String(row.session_scope) : null
+  });
+  const autoApprove = false;
+  if (!autoApprove) {
+    try {
+      const taskScope = row.session_scope ? String(row.session_scope) : null;
+      const exeSession = taskScope || getParentExe(getSessionKey());
+      if (exeSession) {
+        sendIntercom(exeSession, { force: true, reason: "completion" });
+      }
+      if (reviewer && reviewer !== coordinatorName && reviewer !== exeSession) {
+        const { employeeSessionName: employeeSessionName2 } = await import("./lib/tmux-routing.js");
+        if (exeSession) {
+          const reviewerSession = employeeSessionName2(reviewer, exeSession);
+          sendIntercom(reviewerSession, { force: true, reason: "completion" });
+        }
+      }
+    } catch {
+    }
+  }
+  if (autoApprove) {
+    process.stderr.write(
+      `[review] Auto-approving "${taskTitle}" (P2 + tests pass)
+`
+    );
+    try {
+      await updateTaskStatus({ taskId: originalTaskId, status: "closed", skipReviewCreation: true });
+    } catch {
+      await client.execute({
+        sql: "UPDATE tasks SET status = 'closed', updated_at = ? WHERE id = ?",
+        args: [now, originalTaskId]
+      });
+    }
+  }
+}
+async function cleanupReviewFile(row, taskFile, _baseDir) {
+  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
+  try {
+    const client = getClient();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const parentId = row.parent_task_id ? String(row.parent_task_id) : null;
+    if (parentId) {
+      let cascaded = false;
+      try {
+        await updateTaskStatus({ taskId: parentId, status: "closed", skipReviewCreation: true });
+        cascaded = true;
+      } catch {
+        const result = await client.execute({
+          sql: "UPDATE tasks SET status = 'closed', updated_at = ? WHERE id = ? AND status = 'needs_review'",
+          args: [now, parentId]
+        });
+        cascaded = result.rowsAffected > 0;
+      }
+      if (cascaded) {
+        process.stderr.write(
+          `[review-cleanup] Cascaded original task to done via parent_task_id: ${parentId}
+`
+        );
+      }
+    } else {
+      const fileName = taskFile.split("/").pop() ?? "";
+      const reviewPrefix = fileName.replace(".md", "");
+      const parts = reviewPrefix.split("-");
+      if (parts.length >= 3 && parts[0] === "review") {
+        const agent = parts[1];
+        const slug = parts.slice(2).join("-");
+        const legacyTaskFile = `exe/${agent}/${slug}.md`;
+        const legacyScope = sessionScopeFilter();
+        const result = await client.execute({
+          sql: `UPDATE tasks SET status = 'closed', updated_at = ? WHERE (task_file = ? OR task_file LIKE ?) AND status = 'needs_review'${legacyScope.sql}`,
+          args: [now, legacyTaskFile, `tasks/%/${agent}/${slug}.md`, ...legacyScope.args]
+        });
+        if (result.rowsAffected > 0) {
+          process.stderr.write(
+            `[review-cleanup] Cascaded original task to done: ${agent}/${slug}.md
+`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  try {
+    const cacheDir = path4.join(EXE_AI_DIR, "session-cache");
+    if (existsSync4(cacheDir)) {
+      for (const f of readdirSync2(cacheDir)) {
+        if (f.startsWith("review-notified-")) {
+          unlinkSync2(path4.join(cacheDir, f));
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/lib/intercom-prompts.ts
+function formatIntercomPrompt(reason = "nudge") {
+  switch (reason) {
+    case "completion":
+      return "An employee completed work. Run task(action='list', status='needs_review') to review it.";
+    case "message":
+      return "You have a new message. Run message(action='acknowledge') after reading it, and check task(action='list') only if the message references work.";
+    case "notification":
+      return "You have pending notifications. Run task(action='list', status='needs_review') and task(action='list', status='open') to check actionable work.";
+    case "signal":
+    case "nudge":
+    default:
+      return "P0: You have a new task dispatched. Run task(action='list', status='open') to find it. Start immediately.";
+  }
+}
+
+// src/lib/tmux-routing.ts
+var SPAWN_LOCK_DIR = path5.join(os4.homedir(), ".exe-os", "spawn-locks");
+function spawnLockPath(sessionName) {
+  return path5.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock(sessionName) {
+  if (!existsSync5(SPAWN_LOCK_DIR)) {
+    mkdirSync2(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  const lockData = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  try {
+    const fd = openSync(lockFile, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 420);
+    writeSync(fd, lockData);
+    closeSync(fd);
+    return true;
+  } catch (err) {
+    if (err?.code !== "EEXIST") {
+      return true;
+    }
+  }
+  try {
+    const lock = JSON.parse(readFileSync3(lockFile, "utf8"));
+    const age = Date.now() - lock.timestamp;
+    if (isProcessAlive(lock.pid) && age < 6e4) {
+      return false;
+    }
+    const tmpName = `${lockFile}.stale-${process.pid}-${Date.now()}`;
+    try {
+      renameSync2(lockFile, tmpName);
+      try {
+        unlinkSync3(tmpName);
+      } catch {
+      }
+      writeFileSync(lockFile, lockData);
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    const tmpName = `${lockFile}.stale-${process.pid}-${Date.now()}`;
+    try {
+      renameSync2(lockFile, tmpName);
+      try {
+        unlinkSync3(tmpName);
+      } catch {
+      }
+      writeFileSync(lockFile, lockData);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function releaseSpawnLock(sessionName) {
+  try {
+    unlinkSync3(spawnLockPath(sessionName));
+  } catch {
+  }
+}
+var SESSION_CACHE = path5.join(os4.homedir(), ".exe-os", "session-cache");
+var BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
+function resolveBehaviorsExporterScript() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const scriptPath = path5.join(
+      path5.dirname(thisFile),
+      "..",
+      "bin",
+      "exe-export-behaviors.js"
+    );
+    return existsSync5(scriptPath) ? scriptPath : null;
+  } catch {
+    return null;
+  }
+}
+function exportBehaviorsSync(agentId, projectName, sessionKey) {
+  const script = resolveBehaviorsExporterScript();
+  if (!script) return null;
+  try {
+    const output = execFileSync(
+      process.execPath,
+      [script, agentId, projectName, sessionKey],
+      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
+    ).trim();
+    return output.length > 0 ? output : null;
+  } catch (err) {
+    process.stderr.write(
+      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function getMySession() {
+  return getTransport().getMySession();
+}
+function isRootSession(name) {
+  return name.length > 0 && !name.includes("-");
+}
+var VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
+function employeeSessionName(employee, exeSession, instance) {
+  if (!isRootSession(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[tmux-routing] WARN: exeSession="${exeSession}" is not a root session, using "${root}" instead
+`
+      );
+      exeSession = root;
+    } else {
+      throw new Error(
+        `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
+      );
+    }
+  }
+  const suffix = instance != null && instance > 0 ? String(instance) : "";
+  const name = `${employee}${suffix}-${exeSession}`;
+  if (!VALID_SESSION_NAME.test(name)) {
+    throw new Error(
+      `Invalid session name "${name}" \u2014 must match {agent}-{rootSession} or {agent}{instance}-{rootSession}`
+    );
+  }
+  return name;
+}
+function parseParentExe(sessionName, agentId) {
+  const escaped = agentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+  const match = sessionName.match(regex);
+  return match?.[1] ?? null;
+}
+function extractRootExe(name) {
+  if (!name) return null;
+  if (!name.includes("-")) return name;
+  try {
+    const roster = loadEmployeesSync();
+    if (roster.length > 0) {
+      const sortedNames = roster.map((e) => e.name).sort((a, b) => b.length - a.length);
+      for (const agentName of sortedNames) {
+        const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+        const match = name.match(regex);
+        if (match) {
+          return extractRootExe(match[1]);
+        }
+      }
+    }
+  } catch {
+  }
+  const lastDash = name.lastIndexOf("-");
+  if (lastDash < 0) return name;
+  const tail = name.slice(lastDash + 1);
+  return tail.length > 0 ? tail : null;
+}
+function registerParentExe(sessionKey, parentExe, dispatchedBy) {
+  if (!existsSync5(SESSION_CACHE)) {
+    mkdirSync2(SESSION_CACHE, { recursive: true });
+  }
+  const rootExe = extractRootExe(parentExe) ?? parentExe;
+  const filePath = path5.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  atomicWriteJsonSync(filePath, {
+    parentExe: rootExe,
+    dispatchedBy: dispatchedBy || rootExe,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+var PARENT_EXE_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync3(path5.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    if (data.registeredAt) {
+      const age = Date.now() - new Date(data.registeredAt).getTime();
+      if (age > PARENT_EXE_CACHE_TTL_MS) return null;
+    }
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function getDispatchedBy(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync3(
+      path5.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      "utf8"
+    ));
+    return data.dispatchedBy ?? data.parentExe ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  const fromSessionName = mySession ? extractRootExe(mySession) ?? null : null;
+  const alsHint = (() => {
+    try {
+      return getAgentContext()?.sessionHint ?? "";
+    } catch {
+      return "";
+    }
+  })();
+  const envHint = process.env.EXE_SESSION_NAME || "";
+  const sessionHintRaw = alsHint || envHint || "";
+  if (sessionHintRaw) {
+    const fromEnv = extractRootExe(sessionHintRaw) ?? sessionHintRaw;
+    if (fromEnv) {
+      if (!mySession) {
+        logSessionResolve({
+          caller: "resolveExeSession",
+          mySession,
+          alsHint,
+          envHint,
+          cacheHit: null,
+          resolved: fromEnv,
+          path: alsHint ? "als_hint (no tmux)" : "env_var (no tmux)"
+        });
+        return fromEnv;
+      }
+      if (fromSessionName && fromEnv !== fromSessionName) {
+        if (alsHint) {
+          process.stderr.write(
+            `[tmux-routing] INFO: ALS hint="${fromEnv}" differs from tmux="${fromSessionName}". Trusting ALS (daemon context).
+`
+          );
+          logSessionResolve({
+            caller: "resolveExeSession",
+            mySession,
+            alsHint,
+            envHint,
+            cacheHit: null,
+            resolved: fromEnv,
+            path: "als_hint (daemon, tmux ignored)"
+          });
+          return fromEnv;
+        }
+        process.stderr.write(
+          `[tmux-routing] WARN: env hint="${fromEnv}" but tmux says "${fromSessionName}". Trusting tmux.
+`
+        );
+        logSessionResolve({
+          caller: "resolveExeSession",
+          mySession,
+          alsHint,
+          envHint,
+          cacheHit: null,
+          resolved: fromSessionName,
+          path: "tmux_override (env disagrees, non-daemon)",
+          mismatch: true
+        });
+        process.env.EXE_SESSION_NAME = fromSessionName;
+      } else {
+        logSessionResolve({
+          caller: "resolveExeSession",
+          mySession,
+          alsHint,
+          envHint,
+          cacheHit: null,
+          resolved: fromEnv,
+          path: alsHint ? "als_hint" : "env_var"
+        });
+        return fromEnv;
+      }
+    }
+  }
+  if (!mySession) {
+    logSessionResolve({
+      caller: "resolveExeSession",
+      mySession,
+      alsHint,
+      envHint,
+      cacheHit: null,
+      resolved: null,
+      path: "no_tmux_no_hint"
+    });
+    return null;
+  }
+  let candidate = null;
+  let cacheHit = null;
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      const fromCache = extractRootExe(parentExe) ?? parentExe;
+      cacheHit = fromCache;
+      if (fromSessionName && fromCache !== fromSessionName) {
+        process.stderr.write(
+          `[tmux-routing] WARN: cache says "${fromCache}" but session name says "${fromSessionName}". Trusting session name.
+`
+        );
+        try {
+          registerParentExe(key, fromSessionName);
+        } catch {
+        }
+        candidate = fromSessionName;
+      } else {
+        candidate = fromCache;
+      }
+    }
+  } catch {
+  }
+  if (!candidate) {
+    candidate = fromSessionName ?? mySession;
+  }
+  if (candidate && isRootSession(candidate)) {
+    try {
+      const transport = getTransport();
+      const liveSessions = transport.listSessions();
+      if (!liveSessions.includes(candidate)) {
+        const liveRoots = liveSessions.filter((s) => isRootSession(s));
+        if (liveRoots.length === 1) {
+          process.stderr.write(
+            `[tmux-routing] WARN: resolved session "${candidate}" is dead. Using live coordinator "${liveRoots[0]}".
+`
+          );
+          logSessionResolve({
+            caller: "resolveExeSession",
+            mySession,
+            alsHint,
+            envHint,
+            cacheHit,
+            liveRoots,
+            resolved: liveRoots[0],
+            path: "liveness_fallback_single",
+            mismatch: true
+          });
+          return liveRoots[0];
+        } else if (liveRoots.length > 1) {
+          const base = candidate.replace(/\d+$/, "");
+          const match = liveRoots.find((s) => s.startsWith(base));
+          const chosen = match ?? liveRoots[0];
+          process.stderr.write(
+            `[tmux-routing] WARN: resolved session "${candidate}" is dead. ${liveRoots.length} live roots found, using "${chosen}".
+`
+          );
+          logSessionResolve({
+            caller: "resolveExeSession",
+            mySession,
+            alsHint,
+            envHint,
+            cacheHit,
+            liveRoots,
+            resolved: chosen,
+            path: `liveness_fallback_multi (base="${base}", match=${match ?? "none"})`,
+            mismatch: true
+          });
+          return chosen;
+        }
+        process.stderr.write(
+          `[tmux-routing] WARN: resolved session "${candidate}" is dead and no live coordinator found.
+`
+        );
+        logSessionResolve({
+          caller: "resolveExeSession",
+          mySession,
+          alsHint,
+          envHint,
+          cacheHit,
+          liveRoots: [],
+          resolved: candidate,
+          path: "liveness_fallback_none (stale candidate)",
+          mismatch: true
+        });
+      }
+    } catch {
+    }
+  }
+  logSessionResolve({
+    caller: "resolveExeSession",
+    mySession,
+    alsHint,
+    envHint,
+    cacheHit,
+    resolved: candidate,
+    path: cacheHit ? "cache" : fromSessionName ? "tmux_session_name" : "tmux_raw"
+  });
+  return candidate;
+}
+function isEmployeeAlive(sessionName) {
+  return getTransport().isAlive(sessionName);
+}
+function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
+  const base = employeeSessionName(employeeName, exeSession);
+  if (!isAlive(base) && acquireSpawnLock(base)) return 0;
+  for (let i = 2; i <= maxInstances; i++) {
+    const candidate = employeeSessionName(employeeName, exeSession, i);
+    if (!isAlive(candidate) && acquireSpawnLock(candidate)) return i;
+  }
+  return null;
+}
+var VERIFY_PANE_LINES = 200;
+async function verifyPaneAtCapacity(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) {
+    return { atCapacity: false, reason: `session ${sessionName} is not alive` };
+  }
+  let pane;
+  try {
+    pane = transport.capturePane(sessionName, VERIFY_PANE_LINES);
+  } catch (err) {
+    return {
+      atCapacity: false,
+      reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const { isAtCapacity } = await import("./capacity-monitor-IFVRCIM7.js");
+  if (!isAtCapacity(pane)) {
+    return {
+      atCapacity: false,
+      reason: `last ${VERIFY_PANE_LINES} lines show normal work, no capacity banner`
+    };
+  }
+  return {
+    atCapacity: true,
+    reason: "capacity banner matched in recent pane output"
+  };
+}
+var INTERCOM_DEBOUNCE_MS = 3e5;
+var CODEX_DEBOUNCE_MS = 3e5;
+var INTERCOM_LOG = path5.join(os4.homedir(), ".exe-os", "intercom.log");
+var DEBOUNCE_FILE = path5.join(SESSION_CACHE, "intercom-debounce.json");
+var DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+function readDebounceState() {
+  try {
+    if (!existsSync5(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync3(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
+  } catch {
+    return {};
+  }
+}
+function writeDebounceState(state) {
+  try {
+    if (!existsSync5(SESSION_CACHE)) mkdirSync2(SESSION_CACHE, { recursive: true });
+    atomicWriteJsonSync(DEBOUNCE_FILE, state);
+  } catch {
+  }
+}
+function isDebounced(targetSession) {
+  const state = readDebounceState();
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  const agentName = baseAgentName(targetSession.split("-")[0] ?? "");
+  let dbRuntime = "claude";
+  try {
+    const diPath = path5.join(SESSION_CACHE, `dispatch-info-${targetSession}.json`);
+    if (existsSync5(diPath)) {
+      const di = JSON.parse(readFileSync3(diPath, "utf-8"));
+      if (di.runtime) dbRuntime = di.runtime;
+    } else {
+      dbRuntime = getAgentRuntime(agentName).runtime;
+    }
+  } catch {
+    dbRuntime = getAgentRuntime(agentName).runtime;
+  }
+  const debounceMs = dbRuntime === "codex" || dbRuntime === "opencode" ? CODEX_DEBOUNCE_MS : INTERCOM_DEBOUNCE_MS;
+  if (Date.now() - lastSent < debounceMs) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
+}
+function recordDebounce(targetSession) {
+  const state = readDebounceState();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
+  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
+  for (const key of Object.keys(state)) {
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
+  }
+  writeDebounceState(state);
+  return batched;
+}
+function logIntercom(msg, meta) {
+  const metaStr = meta ? ` | caller=${meta.caller ?? "?"} task=${meta.task ?? "none"} trigger=${meta.trigger ?? "?"}` : "";
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}${metaStr}
+`;
+  process.stderr.write(`[intercom] ${msg}${metaStr}
+`);
+  try {
+    appendFileSync2(INTERCOM_LOG, line);
+  } catch {
+  }
+}
+var BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
+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";
+  } catch {
+    return "offline";
+  }
+}
+function isSessionBusy(sessionName) {
+  const state = getSessionState(sessionName);
+  return state === "thinking" || state === "tool";
+}
+function isExeSession(sessionName) {
+  const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
+  const coordinatorName = getCoordinatorName();
+  return matchesBaseWithInstance(coordinatorName);
+}
+function sendIntercom(targetSession, opts) {
+  const transport = getTransport();
+  const startedAt = Date.now();
+  const reason = opts?.reason ?? "nudge";
+  const rawAgent = targetSession.split("-")[0] ?? targetSession;
+  const eventAgent = baseAgentName(rawAgent);
+  const eventSessionScope = extractRootExe(targetSession);
+  const recordResult = (result, errorCode) => {
+    recordOrchestrationEventBestEffort({
+      eventType: "tmux.nudge.completed",
+      source: "tmux-routing.sendIntercom",
+      severity: result === "failed" ? "warn" : "info",
+      agentId: eventAgent,
+      sessionScope: eventSessionScope,
+      tmuxSession: targetSession,
+      durationMs: Date.now() - startedAt,
+      result,
+      errorCode: errorCode ?? null,
+      payload: { reason, force: Boolean(opts?.force) }
+    });
+  };
+  recordOrchestrationEventBestEffort({
+    eventType: "tmux.nudge.attempted",
+    source: "tmux-routing.sendIntercom",
+    agentId: eventAgent,
+    sessionScope: eventSessionScope,
+    tmuxSession: targetSession,
+    payload: { reason, force: Boolean(opts?.force) }
+  });
+  const isVitest = process.env.VITEST === "true" || process.env.NODE_ENV === "test";
+  const transportName = transport.constructor?.name ?? "";
+  if (isVitest && transportName === "TmuxTransport" && process.env.EXE_TEST_ALLOW_REAL_INTERCOM !== "1") {
+    logIntercom(`SUPPRESSED_TEST \u2192 ${targetSession} (real tmux intercom disabled under Vitest)`);
+    recordResult("debounced", "test_real_tmux_suppressed");
+    return "debounced";
+  }
+  try {
+    const callerScope = resolveExeSession();
+    if (callerScope && isExeSession(callerScope) && targetSession.includes("-")) {
+      const targetScope = extractRootExe(targetSession);
+      if (targetScope && targetScope !== callerScope && isExeSession(targetScope)) {
+        logIntercom(`BLOCKED \u2192 ${targetSession} (scope violation: caller=${callerScope}, target=${targetScope})`);
+        process.stderr.write(
+          `[intercom] BLOCKED: cross-session intercom from ${callerScope} to ${targetSession}. Session isolation enforced.
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "session.scope_violation",
+          source: "tmux-routing.sendIntercom",
+          severity: "warn",
+          agentId: eventAgent,
+          sessionScope: targetScope,
+          tmuxSession: targetSession,
+          result: "blocked",
+          payload: { callerScope }
+        });
+        recordResult("failed", "scope_violation");
+        return "failed";
+      }
+    }
+  } catch {
+  }
+  if (!opts?.force && isDebounced(targetSession)) {
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (nudge batched, task safe in DB)`);
+    recordResult("debounced");
+    return "debounced";
+  }
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(targetSession)) {
+      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
+      recordResult("failed", "session_not_found");
+      return "failed";
+    }
+    const sessionState = getSessionState(targetSession);
+    if (sessionState === "no_claude") {
+      queueIntercom(targetSession, "claude not running in session", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "no_claude");
+      return "queued";
+    }
+    if (!opts?.force && (sessionState === "thinking" || sessionState === "tool")) {
+      queueIntercom(targetSession, "session busy at send time", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "session_busy");
+      return "queued";
+    }
+    if (sessionState !== "idle") {
+      try {
+        const rawAgent2 = targetSession.split("-")[0] ?? targetSession;
+        const agent = baseAgentName(rawAgent2);
+        const markerPath = path5.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync5(markerPath)) {
+          logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
+          recordResult("debounced", "in_progress_marker");
+          return "debounced";
+        }
+      } catch {
+      }
+    }
+    if (transport.isPaneInCopyMode(targetSession)) {
+      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
+      transport.sendKeys(targetSession, "q");
+    }
+    const msg = formatIntercomPrompt(reason);
+    transport.sendKeysLiteral(targetSession, msg);
+    const batched = recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (fire-and-forget)`);
+    recordResult("delivered");
+    return "delivered";
+  } catch (e) {
+    process.stderr.write("[tmux-routing] sendIntercom to " + targetSession + ": " + (e instanceof Error ? e.message : String(e)) + "\n");
+    logIntercom(`FAIL \u2192 ${targetSession}`);
+    recordResult("failed", e instanceof Error ? e.name : "send_error");
+    return "failed";
+  }
+}
+function notifyParentExe(sessionKey) {
+  const target = getDispatchedBy(sessionKey);
+  if (!target) {
+    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
+`);
+    return false;
+  }
+  process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
+`);
+  const result = sendIntercom(target, { reason: "completion" });
+  if (result === "failed") {
+    const rootExe = resolveExeSession();
+    if (rootExe && rootExe !== target) {
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root coordinator session ${rootExe}
+`);
+      const fallback = sendIntercom(rootExe, { reason: "completion" });
+      return fallback !== "failed";
+    }
+    return false;
+  }
+  return true;
+}
+function notifyCoordinatorTaskCompletion(coordinatorSession, agentName, taskTitle) {
+  const transport = getTransport();
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(coordinatorSession)) return false;
+    try {
+      const pending = countPendingReviews(coordinatorSession, getCoordinatorName());
+      if (pending instanceof Promise) {
+        pending.then((count) => {
+          if (count > 0) {
+            logIntercom(`COMPLETION \u2192 ${coordinatorSession} (${agentName} completed "${taskTitle.slice(0, 50)}", ${count} reviews pending \u2014 sending intercom)`);
+            sendIntercom(coordinatorSession, { force: true, reason: "completion" });
+          }
+        }).catch(() => {
+        });
+        return true;
+      }
+    } catch {
+    }
+    logIntercom(`COMPLETION \u2192 ${coordinatorSession} (${agentName} completed "${taskTitle.slice(0, 50)}") \u2014 review count unavailable, sending intercom as fallback`);
+    sendIntercom(coordinatorSession, { force: true, reason: "completion" });
+    return true;
+  } catch (e) {
+    process.stderr.write("[tmux-routing] notifyCoordinatorTaskCompletion for " + coordinatorSession + ": " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return false;
+  }
+}
+function ensureEmployee(employeeName, exeSession, projectDir, opts) {
+  if (isCoordinatorName(employeeName)) {
+    return { status: "failed", sessionName: "", error: "The coordinator is not a dispatchable employee" };
+  }
+  try {
+    assertEmployeeLimitSync();
+  } catch (err) {
+    if (err instanceof PlanLimitError) {
+      return { status: "failed", sessionName: "", error: err.message };
+    }
+  }
+  try {
+    const MAX_CONCURRENT = Number(process.env.EXE_MAX_SESSIONS) || 50;
+    const liveSessions = listTmuxSessions().filter((s) => !isExeSession(s));
+    if (liveSessions.length >= MAX_CONCURRENT) {
+      return {
+        status: "failed",
+        sessionName: "",
+        error: `Global session cap reached (${liveSessions.length}/${MAX_CONCURRENT}). Set EXE_MAX_SESSIONS to increase.`
+      };
+    }
+  } catch {
+  }
+  if (employeeName.includes("-")) {
+    const bare = employeeName.split("-")[0].replace(/\d+$/, "");
+    return {
+      status: "failed",
+      sessionName: "",
+      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
+    };
+  }
+  if (!isRootSession(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[ensureEmployee] WARN: caller passed exeSession="${exeSession}" (not a root session). Auto-correcting to "${root}".
+`
+      );
+      exeSession = root;
+    } else {
+      return {
+        status: "failed",
+        sessionName: "",
+        error: `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
+      };
+    }
+  }
+  let effectiveInstance = opts?.instance;
+  if (effectiveInstance === void 0 && opts?.autoInstance) {
+    const free = findFreeInstance(
+      employeeName,
+      exeSession,
+      opts.maxAutoInstances ?? 10
+    );
+    if (free === null) {
+      return {
+        status: "failed",
+        sessionName: employeeSessionName(employeeName, exeSession),
+        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
+      };
+    }
+    effectiveInstance = free === 0 ? void 0 : free;
+    if (free !== null) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worker.instance.selected",
+        source: "tmux-routing.ensureEmployee",
+        agentId: employeeName,
+        sessionScope: exeSession,
+        instanceId: String(free),
+        payload: { maxInstances: opts.maxAutoInstances ?? 10 }
+      });
+    }
+  }
+  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
+  if (!opts?.autoInstance) {
+    if (!acquireSpawnLock(sessionName)) {
+      process.stderr.write(
+        `[ensureEmployee] spawn lock held for ${sessionName} \u2014 another process is already spawning, skipping duplicate spawn
+`
+      );
+      return { status: "intercom_sent", sessionName };
+    }
+  }
+  if (isEmployeeAlive(sessionName)) {
+    if (!opts?.autoInstance) releaseSpawnLock(sessionName);
+    const result2 = sendIntercom(sessionName, { force: true, reason: "signal" });
+    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
+      return { status: "intercom_sent", sessionName };
+    }
+    if (result2 === "delivered") {
+      return { status: "intercom_unprocessed", sessionName };
+    }
+    return { status: "failed", sessionName, error: "intercom delivery failed" };
+  }
+  const spawnOpts = { ...opts, instance: effectiveInstance };
+  if (!spawnOpts.cwd) {
+    const COORDINATOR_ROLES = /* @__PURE__ */ new Set(["COO", "CTO", "CMO"]);
+    try {
+      const roster = loadEmployeesSync();
+      const emp = roster.find((e) => baseAgentName(e.name) === baseAgentName(employeeName));
+      if (emp && !COORDINATOR_ROLES.has(emp.role)) {
+        const wtPath = ensureWorktree(projectDir, employeeName, effectiveInstance);
+        if (wtPath) {
+          spawnOpts.cwd = wtPath;
+          process.stderr.write(`[tmux-routing] worktree isolation: ${employeeName} \u2192 ${wtPath}
+`);
+        }
+      }
+    } catch (e) {
+      process.stderr.write(`[tmux-routing] worktree setup failed for ${employeeName}: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
+  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
+  if (result.error) {
+    return { status: "failed", sessionName, error: result.error };
+  }
+  return { status: "spawned", sessionName };
+}
+function spawnEmployee(employeeName, exeSession, projectDir, opts) {
+  const transport = getTransport();
+  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
+  const spawnStartedAt = Date.now();
+  const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
+  const logDir = path5.join(os4.homedir(), ".exe-os", "session-logs");
+  const logFile = path5.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  recordOrchestrationEventBestEffort({
+    eventType: "tmux.spawn.attempted",
+    source: "tmux-routing.spawnEmployee",
+    agentId: employeeName,
+    sessionScope: exeSession,
+    instanceId: opts?.instance != null ? String(opts.instance) : null,
+    tmuxSession: sessionName,
+    runtime: opts?.runtimeOverride ?? null,
+    payload: { hasCwdOverride: Boolean(opts?.cwd), autoInstance: Boolean(opts?.autoInstance) }
+  });
+  if (!existsSync5(logDir)) {
+    mkdirSync2(logDir, { recursive: true });
+  }
+  transport.kill(sessionName);
+  let cleanupSuffix = "";
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const cleanupScript = path5.join(path5.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync5(cleanupScript)) {
+      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
+    }
+  } catch {
+  }
+  try {
+    const claudeJsonPath = path5.join(os4.homedir(), ".claude.json");
+    let claudeJson = {};
+    try {
+      claudeJson = JSON.parse(readFileSync3(claudeJsonPath, "utf8"));
+    } catch {
+    }
+    if (!claudeJson.projects) claudeJson.projects = {};
+    const projects = claudeJson.projects;
+    const trustDir = opts?.cwd ?? projectDir;
+    if (!projects[trustDir]) projects[trustDir] = {};
+    projects[trustDir].hasTrustDialogAccepted = true;
+    atomicWriteSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    const settingsDir = path5.join(os4.homedir(), ".claude", "projects");
+    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
+    const projSettingsDir = path5.join(settingsDir, normalizedKey);
+    const settingsPath = path5.join(projSettingsDir, "settings.json");
+    let settings = {};
+    try {
+      settings = JSON.parse(readFileSync3(settingsPath, "utf8"));
+    } catch {
+    }
+    const perms = settings.permissions ?? {};
+    const allow = perms.allow ?? [];
+    const toolNames = [
+      "recall_my_memory",
+      "store_memory",
+      "create_task",
+      "update_task",
+      "list_tasks",
+      "get_task",
+      "ask_team_memory",
+      "store_behavior",
+      "get_identity",
+      "send_message"
+    ];
+    const requiredTools = expandDualPrefixTools(toolNames);
+    let changed = false;
+    for (const tool of requiredTools) {
+      if (!allow.includes(tool)) {
+        allow.push(tool);
+        changed = true;
+      }
+    }
+    if (changed) {
+      perms.allow = allow;
+      settings.permissions = perms;
+      mkdirSync2(projSettingsDir, { recursive: true });
+      atomicWriteSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch {
+  }
+  const spawnCwd = opts?.cwd ?? projectDir;
+  const useExeAgent = !!(opts?.model && opts?.provider);
+  const baseRtConfig = getAgentRuntime(employeeName);
+  const agentRtConfig = {
+    ...baseRtConfig,
+    ...opts?.runtimeOverride ? { runtime: opts.runtimeOverride } : {},
+    ...opts?.modelOverride ? { model: opts.modelOverride } : {}
+  };
+  const useCodex = !useExeAgent && agentRtConfig.runtime === "codex";
+  const useOpencode = !useExeAgent && !useCodex && agentRtConfig.runtime === "opencode";
+  const ccProvider = useExeAgent || useCodex || useOpencode ? DEFAULT_PROVIDER : detectActiveProvider();
+  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
+  let legacyFallbackWarned = false;
+  if (!useExeAgent && !useBinSymlink) {
+    const identityPath = path5.join(
+      os4.homedir(),
+      ".exe-os",
+      "identity",
+      `${employeeName}.md`
+    );
+    _resetCcAgentSupportCache();
+    const hasAgentFlag = claudeSupportsAgentFlag();
+    if (hasAgentFlag) {
+      const symlink = ensureAgentSymlink(employeeName);
+      if (symlink.action === "conflict") {
+        process.stderr.write(
+          `[tmux-routing] WARN: respecting customer-owned ~/.claude/agents/${employeeName}.md (${symlink.conflict}); not overwriting or bypassing it.
+`
+        );
+      }
+    } else if (existsSync5(identityPath)) {
+      legacyFallbackWarned = true;
+    }
+    const behaviorsFile = exportBehaviorsSync(
+      employeeName,
+      path5.basename(spawnCwd),
+      sessionName
+    );
+    void behaviorsFile;
+  }
+  if (legacyFallbackWarned) {
+    process.stderr.write(
+      `[tmux-routing] claude --agent not supported by installed CC. Falling back to --append-system-prompt-file for ${employeeName}. Upgrade Claude Code to enable native --agent launch.
+`
+    );
+  }
+  try {
+    const ctxDir = path5.join(os4.homedir(), ".exe-os", "session-cache");
+    mkdirSync2(ctxDir, { recursive: true });
+    const ctxFile = path5.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxContent = [
+      `## Session Context`,
+      `You are running in tmux session: ${sessionName}.`,
+      `Your parent coordinator session is ${exeSession}.`,
+      `Your employees (if any) use the -${exeSession} suffix.`
+    ].join("\n");
+    atomicWriteSync(ctxFile, ctxContent);
+    void ctxFile;
+  } catch {
+  }
+  let envPrefix = `AGENT_ID=${employeeName} EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName} EXE_SESSION_START_ISO=${(/* @__PURE__ */ new Date()).toISOString()} EXE_OS_ENABLE_LEAN_MCP=1`;
+  if (ccProvider !== DEFAULT_PROVIDER) {
+    const cfg = PROVIDER_TABLE[ccProvider];
+    if (cfg?.apiKeyEnv) {
+      const keyVal = process.env[cfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${cfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+  }
+  if (useCodex) {
+    const codexCfg = RUNTIME_TABLE.codex;
+    if (codexCfg?.apiKeyEnv) {
+      const keyVal = process.env[codexCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${codexCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} EXE_AGENT_MODEL=${agentRtConfig.model}`;
+    if (agentRtConfig.reasoning_effort) {
+      envPrefix = `${envPrefix} EXE_AGENT_REASONING_EFFORT=${agentRtConfig.reasoning_effort}`;
+    }
+  }
+  if (useOpencode) {
+    const ocCfg = PROVIDER_TABLE.opencode;
+    if (ocCfg?.apiKeyEnv) {
+      const keyVal = process.env[ocCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${ocCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+  }
+  if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
+    if (agentRtConfig.runtime === "claude" && agentRtConfig.model) {
+      const ccModel = normalizeCcModelName(agentRtConfig.model);
+      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${ccModel}`;
+      if (opts?.modelOverride) {
+        envPrefix = `${envPrefix} EXE_AGENT_MODEL=${ccModel}`;
+      }
+    }
+  }
+  let spawnCommand;
+  if (useExeAgent) {
+    spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
+  } else if (useCodex) {
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
+  } else if (useOpencode) {
+    const binName = `${employeeName}-opencode`;
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 opencode (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
+  } else if (useBinSymlink) {
+    const binName = `${employeeName}-${ccProvider}`;
+    process.stderr.write(
+      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
+`
+    );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
+  } else {
+    spawnCommand = `${envPrefix} exe-launch-agent --agent ${employeeName}${cleanupSuffix}`;
+  }
+  const spawnResult = transport.spawn(sessionName, {
+    cwd: spawnCwd,
+    command: spawnCommand
+  });
+  if (spawnResult.error) {
+    releaseSpawnLock(sessionName);
+    recordOrchestrationEventBestEffort({
+      eventType: "tmux.spawn.completed",
+      source: "tmux-routing.spawnEmployee",
+      severity: "warn",
+      agentId: employeeName,
+      sessionScope: exeSession,
+      instanceId: opts?.instance != null ? String(opts.instance) : null,
+      tmuxSession: sessionName,
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      durationMs: Date.now() - spawnStartedAt,
+      result: "failed",
+      errorCode: "tmux_new_session_failed"
+    });
+    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
+  }
+  transport.pipeLog(sessionName, logFile);
+  try {
+    const mySession = getMySession();
+    const dispatchInfo = path5.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    atomicWriteJsonSync(dispatchInfo, {
+      dispatchedBy: mySession,
+      rootExe: exeSession,
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      model: useCodex ? agentRtConfig.model : useOpencode ? agentRtConfig.model : void 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch {
+  }
+  const callerIsDaemon = process.env.EXE_IS_DAEMON === "1";
+  const POLL_CAP_MS = callerIsDaemon ? 0 : 45e3;
+  const POLL_INTERVAL_MS = 500;
+  const pollIterations = Math.ceil(POLL_CAP_MS / POLL_INTERVAL_MS);
+  let booted = false;
+  for (let i = 0; i < pollIterations; i++) {
+    try {
+      execSync3("sleep 0.5");
+    } catch {
+    }
+    try {
+      const pane = transport.capturePane(sessionName);
+      if (useExeAgent) {
+        if (pane.includes("[exe-agent]") || pane.includes("online")) {
+          booted = true;
+          break;
+        }
+      } else if (useCodex) {
+        if (pane.includes("codex") || pane.includes("Codex") || pane.includes("exe-start-codex")) {
+          booted = true;
+          break;
+        }
+      } else {
+        if (pane.includes("Claude Code") || pane.includes("\u276F")) {
+          booted = true;
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  if (!booted) {
+    releaseSpawnLock(sessionName);
+    const runtimeLabel = useExeAgent ? "exe-agent" : useCodex ? "codex" : "claude";
+    process.stderr.write(
+      `[tmux-routing] ${runtimeLabel} boot poll capped at ${POLL_CAP_MS / 1e3}s for ${sessionName} \u2014 sending task nudge anyway
+`
+    );
+  }
+  if (!useExeAgent && !useCodex) {
+    if (callerIsDaemon) {
+      try {
+        const empRoster = loadEmployeesSync();
+        const bootCache = {
+          agentId: employeeName,
+          agentRole: empRoster.find((e) => baseAgentName(e.name) === baseAgentName(employeeName))?.role ?? "employee",
+          sessionName,
+          exeSession,
+          dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const cachePath = path5.join(os4.homedir(), ".exe-os", "session-cache", `boot-cache-${sessionName}.json`);
+        writeFileSync(cachePath, JSON.stringify(bootCache));
+      } catch {
+      }
+      const _transport = transport;
+      const _session = sessionName;
+      const _emp = employeeName;
+      setTimeout(() => {
+        try {
+          _transport.sendKeysLiteral(_session, `You have pending tasks. Run list_tasks and start your highest priority task immediately.`);
+        } catch (e) {
+          process.stderr.write(`[tmux-routing] deferred nudge ${_emp}: ${e.message}
+`);
+        }
+      }, 1e4);
+    } else {
+      try {
+        transport.sendKeysLiteral(sessionName, `You have pending tasks. Run list_tasks and start immediately.`);
+      } catch (e) {
+        process.stderr.write(`[tmux-routing] CLI nudge ${employeeName}: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+    }
+  }
+  registerSession({
+    windowName: sessionName,
+    agentId: employeeName,
+    projectDir: spawnCwd,
+    parentExe: exeSession,
+    pid: 0,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  releaseSpawnLock(sessionName);
+  recordOrchestrationEventBestEffort({
+    eventType: "tmux.spawn.completed",
+    source: "tmux-routing.spawnEmployee",
+    agentId: employeeName,
+    sessionScope: exeSession,
+    instanceId: opts?.instance != null ? String(opts.instance) : null,
+    tmuxSession: sessionName,
+    runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+    durationMs: Date.now() - spawnStartedAt,
+    result: booted ? "spawned_booted" : "spawned_unverified"
+  });
+  return { sessionName };
+}
+
+// src/lib/task-scope.ts
+function getCurrentSessionScope() {
+  if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
+    return null;
+  }
+  try {
+    const scope = resolveExeSession();
+    if (!scope && process.env.NODE_ENV !== "test") {
+      if (!_scopeWarningEmitted) {
+        _scopeWarningEmitted = true;
+        process.stderr.write(
+          "[task-scope] WARN: session scope resolution returned null in production. All session-scoped queries will run UNSCOPED until a session is resolved. This is expected in non-tmux environments but a bug if running in tmux.\n"
+        );
+      }
+    }
+    return scope;
+  } catch {
+    return null;
+  }
+}
+var _scopeWarningEmitted = false;
+function sessionScopeFilter(sessionScope, tableAlias) {
+  const scope = sessionScope !== void 0 ? sessionScope : getCurrentSessionScope();
+  if (!scope) return { sql: "", args: [] };
+  const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  return {
+    sql: ` AND (${col} IS NULL OR ${col} = ?)`,
+    args: [scope]
+  };
+}
+function strictSessionScopeFilter(sessionScope, tableAlias) {
+  const scope = sessionScope !== void 0 ? sessionScope : getCurrentSessionScope();
+  if (!scope) return { sql: "", args: [] };
+  const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  return {
+    sql: ` AND ${col} = ?`,
+    args: [scope]
+  };
+}
+
+export {
+  _resetCcAgentSupportCache,
+  claudeSupportsAgentFlag,
+  PROVIDER_TABLE,
+  DEFAULT_PROVIDER,
+  logTaskDispatch,
+  getCurrentSessionScope,
+  sessionScopeFilter,
+  strictSessionScopeFilter,
+  writeNotification,
+  readUnreadNotifications,
+  markAsRead,
+  markAsReadByTaskFile,
+  cleanupOldNotifications,
+  markDoneTaskNotificationsAsRead,
+  formatNotifications,
+  migrateJsonNotifications,
+  isStructuredTaskCompletionReport,
+  buildTaskCompletionReport,
+  writeCheckpoint,
+  extractParentFromContext,
+  slugify,
+  resolveTask,
+  createTaskCore,
+  queryTaskRows,
+  listTasks,
+  isTmuxSessionAlive,
+  TASK_ALREADY_CLAIMED_PREFIX,
+  checkStaleCompletion,
+  updateTaskStatus,
+  deleteTaskCore,
+  ensureArchitectureDoc,
+  ensureGitignoreExe,
+  cleanOrphanedTaskFiles,
+  readLatestCheckpoint,
+  createTaskGroup,
+  getGroupStatus,
+  getGroupResults,
+  getAggregatedGroupResults,
+  checkAndFireBarriers,
+  checkTaskFileConsistency,
+  formatAge,
+  isStale,
+  countPendingReviews,
+  countNewPendingReviewsSince,
+  listPendingReviews,
+  cleanupOrphanedReviews,
+  getReviewChecklist,
+  createReviewForCompletedTask,
+  cleanupReviewFile,
+  formatIntercomPrompt,
+  acquireSpawnLock,
+  releaseSpawnLock,
+  getMySession,
+  employeeSessionName,
+  parseParentExe,
+  extractRootExe,
+  registerParentExe,
+  getParentExe,
+  getDispatchedBy,
+  resolveExeSession,
+  isEmployeeAlive,
+  findFreeInstance,
+  verifyPaneAtCapacity,
+  getSessionState,
+  isSessionBusy,
+  isExeSession,
+  sendIntercom,
+  notifyParentExe,
+  notifyCoordinatorTaskCompletion,
+  ensureEmployee,
+  spawnEmployee
+};