@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/{chunk-HHE2HV3V.js → chunk-NBXDXKLC.js}

@@ -1,6 +1,6 @@
 import {
   listReminders
-} from "./chunk-SEP5ITFQ.js";
+} from "./chunk-636LKCKE.js";
 
 // src/mcp/tools/list-reminders.ts
 import { z } from "zod";

package/dist/{chunk-LDL3S7AC.js → chunk-NKETJCB5.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B6TI3TZT.js";
 import {
   loadEmployeesSync
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/adapters/mcp-http-config.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -39,9 +39,13 @@ function readOrCreateDaemonToken(homeDir = os.homedir()) {
     }
   }
   const token = randomBytes(32).toString("hex");
-  mkdirSync(exeDir, { recursive: true });
+  mkdirSync(exeDir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(exeDir, 448);
+  } catch {
+  }
   writeFileSync(tokenPath, `${token}
-`, "utf-8");
+`, { encoding: "utf-8", mode: 384 });
   try {
     chmodSync(tokenPath, 384);
   } catch {

package/dist/{chunk-ECHLVLA7.js → chunk-NMH5ZQPU.js}

@@ -1,6 +1,6 @@
 import {
   processCRMEvent
-} from "./chunk-ADNBOKYZ.js";
+} from "./chunk-GM7TLYOK.js";
 
 // src/gateway/adapters/crm-webhook.ts
 function parseTwentyWebhook(payload) {

package/dist/{chunk-U3XLRMJD.js → chunk-NT7W4RXD.js}

@@ -1,6 +1,6 @@
 import {
   writeMemoryViaDaemon
-} from "./chunk-QZL6E4UB.js";
+} from "./chunk-GOMQ7PVQ.js";
 
 // src/lib/auto-checkpoint.ts
 var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;

package/dist/{chunk-UQUUNGTP.js → chunk-NUK7EEN5.js}

@@ -1,20 +1,22 @@
 import {
   SUPERVISED_ENV
-} from "./chunk-IVU3WN7S.js";
+} from "./chunk-ZG62LIK3.js";
 import {
   ensureDaemonToken,
   readDaemonToken
-} from "./chunk-RIECV7SR.js";
+} from "./chunk-EKYYMIVT.js";
+import {
+  computeDaemonHeapCapMb
+} from "./chunk-NLEW62VC.js";
+import {
+  killIfSameProcess,
+  processStartedAt
+} from "./chunk-SLLLOOEI.js";
 import {
   KILL_INTENT_LOOKBACK_MS,
   findRecentKillIntent,
-  killIfSameProcess,
-  processStartedAt,
   recordKillIntent
-} from "./chunk-LNOS24GV.js";
-import {
-  computeDaemonHeapCapMb
-} from "./chunk-NLEW62VC.js";
+} from "./chunk-V3WLC5TJ.js";
 import {
   SYSTEMD_DAEMON_UNIT,
   SYSTEMD_WATCHDOG_UNIT,
@@ -26,7 +28,7 @@ import {
 import {
   EXE_AI_DIR,
   resolveDataDir
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/exe-daemon-client.ts
 import net from "net";

package/dist/{chunk-GBNB4EWD.js → chunk-ORM7ZFKC.js}

@@ -66,6 +66,21 @@ function listTmuxSessions() {
   }
 }
 var listTmuxWindows = listTmuxSessions;
+async function listTmuxSessionsAsync() {
+  try {
+    const { promisify } = await import("util");
+    const { execFile } = await import("child_process");
+    const exec = promisify(execFile);
+    const { stdout } = await exec("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      timeout: 3e3
+    });
+    return String(stdout ?? "").trim().split("\n").filter(Boolean);
+  } catch (err) {
+    warnTmuxAbsenceOnce(err);
+    return [];
+  }
+}
 function capturePaneLines(windowName, lines = 10) {
   try {
     const out = execFileSync(
@@ -311,6 +326,7 @@ export {
   resetTmuxAbsenceWarning,
   listTmuxSessions,
   listTmuxWindows,
+  listTmuxSessionsAsync,
   capturePaneLines,
   capturePaneLinesAsync,
   getPaneCwd,

package/dist/{chunk-O4ZFRK6W.js → chunk-OVEQE6YS.js}

@@ -7,22 +7,23 @@ import {
 } from "./chunk-S2YTU74T.js";
 import {
   createTask
-} from "./chunk-HECXZGGZ.js";
+} from "./chunk-ZCERWHY2.js";
 import {
   getActiveAgent
-} from "./chunk-KYFFVTGO.js";
+} from "./chunk-55BEFF4V.js";
 import {
   ensureEmployeeAsync,
+  isEmployeeAlive,
   isExeSession,
   logTaskDispatch,
   resolveExeSession
-} from "./chunk-XHYHX6F7.js";
+} from "./chunk-AKLQSC6W.js";
 import {
   isValidSessionScope
 } from "./chunk-BTSWFMEH.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-E2WEFZOR.js";
+} from "./chunk-W75GTHR3.js";
 import {
   releaseDispatchClaim,
   tryAcquireDispatchClaim,
@@ -32,21 +33,142 @@ import {
 import {
   getAgentRuntime,
   validateRuntimeModel
-} from "./chunk-XTWHNLGD.js";
+} from "./chunk-GZOG2MAX.js";
 import {
   getLicenseSync
-} from "./chunk-HIIXCAEE.js";
+} from "./chunk-6YVUR3OU.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-ZIG7VPJV.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-HSGBZSCA.js";
 
 // src/mcp/tools/create-task.ts
 import { z } from "zod";
-import { existsSync, readdirSync, realpathSync, statSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync2, readdirSync, realpathSync, statSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { basename, dirname, isAbsolute, join, sep } from "path";
+
+// src/lib/project-dir-cache.ts
+import path from "path";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+var MAX_PROJECTS_PER_SCOPE = 64;
+var MAX_SCOPES = 128;
+function cacheDir() {
+  return process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || EXE_AI_DIR;
+}
+function cachePath() {
+  return path.join(cacheDir(), "project-dir-cache.json");
+}
+function keyFor(projectName) {
+  return projectName.trim().toLowerCase();
+}
+function readCache() {
+  try {
+    const raw = readFileSync(cachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function pruneScope(bucket) {
+  const entries = Object.entries(bucket);
+  if (entries.length <= MAX_PROJECTS_PER_SCOPE) return bucket;
+  entries.sort((a, b) => Date.parse(b[1].at) - Date.parse(a[1].at));
+  return Object.fromEntries(entries.slice(0, MAX_PROJECTS_PER_SCOPE));
+}
+function pruneScopes(cache) {
+  const scopes = Object.keys(cache);
+  if (scopes.length <= MAX_SCOPES) return cache;
+  const newest = (bucket) => Math.max(0, ...Object.values(bucket).map((e) => Date.parse(e.at) || 0));
+  scopes.sort((a, b) => newest(cache[b]) - newest(cache[a]));
+  const kept = {};
+  for (const s of scopes.slice(0, MAX_SCOPES)) kept[s] = cache[s];
+  return kept;
+}
+function rememberProjectDir(scope, projectName, dir, anchor) {
+  const s = scope.trim();
+  const p = keyFor(projectName);
+  const incarnation = anchor?.incarnation?.trim() ?? "";
+  const coordDir = anchor?.coordDir ?? "";
+  if (!s || !p || !dir || !incarnation || !coordDir) return;
+  try {
+    const cache = readCache();
+    const bucket = { ...cache[s] ?? {} };
+    bucket[p] = { dir, at: (/* @__PURE__ */ new Date()).toISOString(), incarnation, coordDir };
+    cache[s] = pruneScope(bucket);
+    const dirPath = cacheDir();
+    if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+    atomicWriteJsonSync(cachePath(), pruneScopes(cache));
+  } catch {
+  }
+}
+function recallProjectDir(scope, projectName, incarnation) {
+  const s = scope.trim();
+  const p = keyFor(projectName);
+  const inc = String(incarnation ?? "").trim();
+  if (!s || !p || !inc) return null;
+  const cache = readCache();
+  const entry = cache[s]?.[p];
+  if (!entry?.dir || !entry.coordDir) return null;
+  if (entry.incarnation !== inc) {
+    forgetProjectDir(s, p);
+    return null;
+  }
+  return { dir: entry.dir, coordDir: entry.coordDir };
+}
+function forgetProjectDir(scope, projectKey) {
+  try {
+    const cache = readCache();
+    const bucket = cache[scope];
+    if (!bucket || !(projectKey in bucket)) return;
+    delete bucket[projectKey];
+    if (Object.keys(bucket).length === 0) delete cache[scope];
+    else cache[scope] = bucket;
+    atomicWriteJsonSync(cachePath(), cache);
+  } catch {
+  }
+}
+
+// src/lib/session-incarnation.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var SAFE_SESSION_NAME = /^[A-Za-z0-9._-]{1,64}$/;
+var INCARNATION_FORMAT = "#{session_name}	#{pid}	#{session_id}	#{session_created}";
+function parseIncarnationLine(expectedName, stdout) {
+  const [echoedName, serverPid, sessionId, createdRaw] = String(stdout ?? "").trim().split("	");
+  const created = Number.parseInt(String(createdRaw ?? "").trim(), 10);
+  if (echoedName !== expectedName) return null;
+  if (!serverPid || !sessionId) return null;
+  if (!Number.isFinite(created) || created <= 0) return null;
+  return `tmux:${serverPid}:${sessionId}:${created}`;
+}
+async function sessionIncarnationId(sessionName) {
+  const name = String(sessionName ?? "").trim();
+  if (!SAFE_SESSION_NAME.test(name)) return null;
+  try {
+    const { stdout } = await execFileAsync(
+      "tmux",
+      ["display-message", "-t", name, "-p", INCARNATION_FORMAT],
+      { encoding: "utf8", timeout: 2e3 }
+    );
+    return parseIncarnationLine(name, String(stdout));
+  } catch {
+  }
+  return null;
+}
+
+// src/mcp/tools/create-task.ts
 function rootFromSessionName(sessionName) {
   const raw = (sessionName ?? "").trim();
   if (!raw) return "";
@@ -58,13 +180,13 @@ function isRootSessionName(sessionName) {
 }
 function isDirectory(pathname) {
   try {
-    return existsSync(pathname) && statSync(pathname).isDirectory();
+    return existsSync2(pathname) && statSync(pathname).isDirectory();
   } catch {
     return false;
   }
 }
 function isGitRepoDir(pathname) {
-  return isDirectory(pathname) && existsSync(join(pathname, ".git"));
+  return isDirectory(pathname) && existsSync2(join(pathname, ".git"));
 }
 function realpathSafe(pathname) {
   try {
@@ -80,6 +202,16 @@ function isRealpathInside(candidate, scopedRoot) {
   const prefix = rr.endsWith(sep) ? rr : rr + sep;
   return rc.startsWith(prefix);
 }
+function rememberedDirStillInScope(dir, coordDir, projectName) {
+  if (!dir || !coordDir) return false;
+  if (!existsSync2(dir) || !existsSync2(coordDir)) return false;
+  if (!projectDirMatches(dir, projectName)) return false;
+  if (isRealpathInside(coordDir, dir)) return true;
+  if (isRealpathInside(dir, coordDir)) return true;
+  const workspaceRoot = dirname(coordDir);
+  if (workspaceRoot !== coordDir && isRealpathInside(dir, workspaceRoot)) return true;
+  return false;
+}
 function findNestedGitRepo(parentDir) {
   const preferred = ["website", "app", "repo", "src"];
   for (const child of preferred) {
@@ -141,7 +273,7 @@ function isSafeProjectName(projectName) {
 }
 function findProjectChildDir(parentDir, projectName) {
   if (!isSafeProjectName(projectName)) return null;
-  if (!existsSync(parentDir)) return null;
+  if (!existsSync2(parentDir)) return null;
   const normalizedProject = projectName.toLowerCase();
   const aliases = /* @__PURE__ */ new Set([
     normalizedProject,
@@ -240,7 +372,7 @@ async function inferCoordinatorRootForProject(projectName) {
   try {
     const liveRoots = new Set(await listCoordinatorRoots());
     const { listSessions } = await import("./lib/session-registry.js");
-    const matches = listSessions().filter((session) => isRootSessionName(session.windowName)).filter((session) => !liveRoots.size || liveRoots.has(session.windowName)).filter((session) => session.projectDir && existsSync(session.projectDir)).filter((session) => registeredProjectDirMatches(session.projectDir, projectName)).map((session) => session.windowName);
+    const matches = listSessions().filter((session) => isRootSessionName(session.windowName)).filter((session) => !liveRoots.size || liveRoots.has(session.windowName)).filter((session) => session.projectDir && existsSync2(session.projectDir)).filter((session) => registeredProjectDirMatches(session.projectDir, projectName)).map((session) => session.windowName);
     return [...new Set(matches)].length === 1 ? matches[0] : "";
   } catch {
     return "";
@@ -266,28 +398,36 @@ async function resolveProjectDir(projectName, callerSession) {
     return null;
   }
   if (callerSession) {
+    const coordName = callerSession.includes("-") ? callerSession.slice(callerSession.indexOf("-") + 1) : callerSession;
+    let coordinatorScopeWasAuthoritative = false;
+    let sessions = [];
+    const remember = async (dir, coordDir) => {
+      const incarnation = await sessionIncarnationId(coordName);
+      if (incarnation) rememberProjectDir(coordName, projectName, dir, { incarnation, coordDir });
+      return dir;
+    };
     try {
       const { listSessions } = await import("./lib/session-registry.js");
-      const sessions = listSessions();
-      const coordName = callerSession.includes("-") ? callerSession.slice(callerSession.indexOf("-") + 1) : callerSession;
+      sessions = listSessions();
       const coordSession = sessions.find((s) => s.windowName === coordName) ?? sessions.find((s) => s.windowName === callerSession);
-      if (coordSession?.projectDir && existsSync(coordSession.projectDir)) {
+      if (coordSession?.projectDir && existsSync2(coordSession.projectDir)) {
         const coordDir = coordSession.projectDir;
+        coordinatorScopeWasAuthoritative = true;
         if (projectDirMatches(coordDir, projectName)) {
-          return coordDir;
+          return await remember(coordDir, coordDir);
         }
         const ancestorRoot = findAncestorProjectDir(coordDir, projectName);
-        if (ancestorRoot) return ancestorRoot;
+        if (ancestorRoot) return await remember(ancestorRoot, coordDir);
         const sameScopeCandidates = /* @__PURE__ */ new Set();
         for (const session of sessions) {
           if (!sessionBelongsToCoordinator(session, coordName, callerSession)) continue;
-          if (!session.projectDir || !existsSync(session.projectDir)) continue;
+          if (!session.projectDir || !existsSync2(session.projectDir)) continue;
           if (registeredProjectDirMatches(session.projectDir, projectName)) {
             sameScopeCandidates.add(session.projectDir);
           }
         }
         const sortedSameScope = [...sameScopeCandidates].sort();
-        if (sortedSameScope.length === 1) return sortedSameScope[0];
+        if (sortedSameScope.length === 1) return await remember(sortedSameScope[0], coordDir);
         if (sortedSameScope.length > 1) {
           process.stderr.write(
             `[create-task] ambiguous same-session project resolution for "${projectName}" in caller scope "${callerSession}": ${sortedSameScope.join(", ")}. Returning null.
@@ -296,9 +436,9 @@ async function resolveProjectDir(projectName, callerSession) {
           return null;
         }
         const childUnderCoord = findProjectChildDir(coordDir, projectName);
-        if (childUnderCoord) return childUnderCoord;
+        if (childUnderCoord) return await remember(childUnderCoord, coordDir);
         const automationChildUnderCoord = findAutomationChildDir(coordDir, projectName);
-        if (automationChildUnderCoord) return automationChildUnderCoord;
+        if (automationChildUnderCoord) return await remember(automationChildUnderCoord, coordDir);
         const workspaceRoot = dirname(coordDir);
         if (workspaceRoot !== coordDir) {
           const sibling = findProjectChildDir(workspaceRoot, projectName);
@@ -313,13 +453,14 @@ async function resolveProjectDir(projectName, callerSession) {
               );
               return null;
             }
-            return sibling;
+            return await remember(sibling, coordDir);
           }
         }
         process.stderr.write(
-          `[create-task] project "${projectName}" not found within caller scope "${callerSession}" (coordinator dir "${coordDir}"). Not scanning other scopes.
+          `[create-task] project "${projectName}" not found within caller scope "${callerSession}" (coordinator dir "${coordDir}"). Not scanning other scopes and not consulting the resolution memo \u2014 this is a scope refusal, not registry churn.
 `
         );
+        return null;
       }
     } catch (err) {
       process.stderr.write(
@@ -327,6 +468,28 @@ async function resolveProjectDir(projectName, callerSession) {
 `
       );
     }
+    if (!coordinatorScopeWasAuthoritative) {
+      const incarnation = await sessionIncarnationId(coordName);
+      const remembered = incarnation ? recallProjectDir(coordName, projectName, incarnation) : null;
+      if (remembered) {
+        const inScope = rememberedDirStillInScope(remembered.dir, remembered.coordDir, projectName);
+        const owner = !inScope ? null : sessions.find(
+          (s) => s.windowName !== coordName && s.windowName !== callerSession && s.projectDir && isRealpathInside(remembered.dir, s.projectDir)
+        );
+        if (inScope && !owner) {
+          process.stderr.write(
+            `[create-task] recovered project "${projectName}" for caller scope "${callerSession}" from the in-scope resolution memo (${remembered.dir}, incarnation ${incarnation}) after the live session registry missed \u2014 transient registry churn, not an out-of-scope project.
+`
+          );
+          return remembered.dir;
+        }
+        const reason = owner ? `it is now owned by coordinator scope "${owner.windowName}"` : `it is no longer in scope of its anchor "${remembered.coordDir}"`;
+        process.stderr.write(
+          `[create-task] DISCARDING remembered dir ${remembered.dir} for project "${projectName}" in caller scope "${callerSession}": ${reason}. Refusing rather than misrouting.
+`
+        );
+      }
+    }
     process.stderr.write(
       `[create-task] could not resolve project "${projectName}" within caller scope "${callerSession}". Returning null \u2014 dispatch will be refused (no $HOME/cwd fallback for a scoped caller).
 `
@@ -338,7 +501,7 @@ async function resolveProjectDir(projectName, callerSession) {
     const candidates = /* @__PURE__ */ new Set();
     for (const session of listSessions()) {
       if (!isRootSessionName(session.windowName)) continue;
-      if (!session.projectDir || !existsSync(session.projectDir)) continue;
+      if (!session.projectDir || !existsSync2(session.projectDir)) continue;
       if (registeredProjectDirMatches(session.projectDir, projectName)) {
         candidates.add(session.projectDir);
       }
@@ -378,7 +541,7 @@ async function resolveCoordinatorOwnProjectDir(callerRoot) {
     const coordName = callerRoot.includes("-") ? callerRoot.slice(callerRoot.indexOf("-") + 1) : callerRoot;
     const sessions = listSessions();
     const coordSession = sessions.find((s) => s.windowName === coordName) ?? sessions.find((s) => s.windowName === callerRoot);
-    if (coordSession?.projectDir && existsSync(coordSession.projectDir)) {
+    if (coordSession?.projectDir && existsSync2(coordSession.projectDir)) {
       return coordSession.projectDir;
     }
   } catch {
@@ -541,7 +704,7 @@ function registerCreateTask(server) {
       let claimWarning = "";
       const claimRefRaw = (work_ref ?? "").trim();
       try {
-        const { findConflicts, findConflictsInText, describeConflict, normalizeTarget } = await import("./work-claims-MNK7PEPW.js");
+        const { findConflicts, findConflictsInText, describeConflict, normalizeTarget } = await import("./work-claims-B73X5NE7.js");
         const conflicts = claimRefRaw ? await findConflicts(
           [normalizeTarget({ kind: "work_ref", value: claimRefRaw })],
           callerRoot
@@ -720,7 +883,7 @@ Nothing was created or dispatched. Either pick different work, or \u2014 if that
       }
       if (claimRefRaw) {
         try {
-          const { acquireClaim } = await import("./work-claims-MNK7PEPW.js");
+          const { acquireClaim } = await import("./work-claims-B73X5NE7.js");
           const acquired = await acquireClaim({
             targets: [{ kind: "work_ref", value: claimRefRaw }],
             holderSession: callerRoot,
@@ -739,10 +902,10 @@ Claimed ${claimRefRaw} for session ${callerRoot} (claim_group ${acquired.claimGr
         }
       }
       try {
-        const { existsSync: existsSync2, mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
+        const { existsSync: existsSync3, mkdirSync: mkdirSync3, writeFileSync: writeFileSync2 } = await import("fs");
         const { identityPath } = await import("./lib/identity.js");
         const idPath = identityPath(assigned_to);
-        if (!existsSync2(idPath)) {
+        if (!existsSync3(idPath)) {
           const { loadEmployees } = await import("./lib/employees.js");
           const employees = await loadEmployees();
           const emp = employees.find((e) => e.name === assigned_to);
@@ -751,7 +914,7 @@ Claimed ${claimRefRaw} for session ${callerRoot} (claim_group ${acquired.claimGr
             const template = getTemplateForTitle(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+              if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
               writeFileSync2(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
@@ -763,7 +926,7 @@ Claimed ${claimRefRaw} for session ${callerRoot} (claim_group ${acquired.claimGr
         const { taskSignalPath: getSignalPath } = await import("./signal-paths-4G53QTII.js");
         const { taskSignalDir } = await import("./signal-paths-4G53QTII.js");
         const signalDir = taskSignalDir(sessionScope);
-        mkdirSync(signalDir, { recursive: true });
+        mkdirSync2(signalDir, { recursive: true });
         const signalPath = getSignalPath(sessionScope, assigned_to, task.id);
         writeFileSync(signalPath, JSON.stringify({
           task_id: task.id,
@@ -773,7 +936,7 @@ Claimed ${claimRefRaw} for session ${callerRoot} (claim_group ${acquired.claimGr
           session_scope: sessionScope,
           created_at: (/* @__PURE__ */ new Date()).toISOString()
         }), "utf-8");
-        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-GY5VP5LU.js");
+        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-N7LYMUGA.js");
         recordOE({
           eventType: "signal.created",
           source: "create-task.mcp",
@@ -805,7 +968,7 @@ Claimed ${claimRefRaw} for session ${callerRoot} (claim_group ${acquired.claimGr
             let projectConflictOpts = {};
             try {
               const { getClient } = await import("./lib/database.js");
-              const { sessionScopeFilter } = await import("./task-scope-KXF7Y6KA.js");
+              const { sessionScopeFilter } = await import("./task-scope-ERVEUEYU.js");
               const client = getClient();
               const scope = sessionScopeFilter(task.sessionScope || callerRoot || exeSession || null);
               const existing = await client.execute({
@@ -873,30 +1036,60 @@ Dispatched: spawned ${result.sessionName}`;
 Dispatch failed: ${result.error ?? "unknown"}`;
                   break;
               }
-              if (result.status === "failed") dispatchOutcome = "failed";
-              if (result.status === "failed") {
+              let livenessDemoted = false;
+              if (result.status === "spawned" && result.sessionName) {
+                const reprobeCapMs = Number(process.env.EXE_SPAWN_REPROBE_CAP_MS) || 4e3;
+                const reprobeIntervalMs = Number(process.env.EXE_SPAWN_REPROBE_INTERVAL_MS) || 500;
+                const reprobeIterations = Math.max(1, Math.ceil(reprobeCapMs / reprobeIntervalMs));
+                let confirmedLive = false;
+                for (let i = 0; i < reprobeIterations; i++) {
+                  try {
+                    if (isEmployeeAlive(result.sessionName)) {
+                      confirmedLive = true;
+                      break;
+                    }
+                  } catch {
+                  }
+                  if (i < reprobeIterations - 1) {
+                    await new Promise((r) => setTimeout(r, reprobeIntervalMs));
+                  }
+                }
+                if (!confirmedLive) {
+                  livenessDemoted = true;
+                  dispatchStatus = `
+Dispatch failed: spawn reported "spawned ${result.sessionName}" but the tmux session never came alive within ${reprobeCapMs / 1e3}s (post-spawn liveness re-probe). The agent was NOT started \u2014 re-dispatch required.`;
+                  process.stderr.write(
+                    `[create_task] SPAWN LIVENESS DEMOTION: ${result.sessionName} reported "spawned" but the re-probe found no live session \u2014 reporting dispatch FAILURE instead of a phantom success (bug 1c3ab704)
+`
+                  );
+                }
+              }
+              const dispatchFailed = result.status === "failed" || livenessDemoted;
+              if (dispatchFailed) dispatchOutcome = "failed";
+              const dispatchFailureError = result.error ?? (livenessDemoted ? "spawn reported success but tmux session never came alive (liveness re-probe)" : "spawn failed");
+              if (dispatchFailed) {
                 try {
-                  releaseDispatchClaim(task.id, assigned_to, result.error ?? "spawn failed");
+                  releaseDispatchClaim(task.id, assigned_to, dispatchFailureError);
                 } catch {
                 }
                 try {
-                  writeDispatchFailed(task.id, assigned_to, result.error ?? "spawn failed", result.sessionName);
+                  writeDispatchFailed(task.id, assigned_to, dispatchFailureError, result.sessionName);
                 } catch {
                 }
               }
               recordOrchestrationEventBestEffort({
-                eventType: result.status === "failed" ? "dispatch.failed" : "dispatch.completed",
+                eventType: dispatchFailed ? "dispatch.failed" : "dispatch.completed",
                 source: "create-task.mcp",
-                severity: result.status === "failed" ? "warn" : "info",
+                severity: dispatchFailed ? "warn" : "info",
                 taskId: task.id,
                 agentId: assigned_to,
                 sessionScope: task.sessionScope || callerRoot || exeSession,
                 projectName: project_name,
                 tmuxSession: result.sessionName || null,
                 runtime: dispatchRuntime,
-                result: result.status,
-                errorCode: result.status === "failed" ? "ensure_employee_failed" : null,
-                payload: { priority, error: result.error ?? null }
+                result: dispatchFailed ? "failed" : result.status,
+                errorCode: dispatchFailed ? livenessDemoted ? "spawn_liveness_reprobe_failed" : "ensure_employee_failed" : null,
+                payload: { priority, error: dispatchFailed ? dispatchFailureError : result.error ?? null }
               });
               try {
                 const { sendIntercom: si } = await import("./lib/tmux-routing.js");
@@ -912,7 +1105,7 @@ Dispatch failed: ${result.error ?? "unknown"}`;
                 }
               } catch {
               }
-              if (result.sessionName && result.status !== "failed") {
+              if (result.sessionName && !dispatchFailed) {
                 try {
                   const { getClient: gc } = await import("./lib/database.js");
                   await gc().execute({
@@ -945,9 +1138,11 @@ Dispatch failed: ${result.error ?? "unknown"}`;
                 } catch {
                 }
               }
-              try {
-                writeDispatchPending(task.id, assigned_to, result.sessionName);
-              } catch {
+              if (!dispatchFailed) {
+                try {
+                  writeDispatchPending(task.id, assigned_to, result.sessionName);
+                } catch {
+                }
               }
               logTaskDispatch({
                 taskId: task.id,
@@ -955,9 +1150,9 @@ Dispatch failed: ${result.error ?? "unknown"}`;
                 callerRoot,
                 exeSession,
                 callerSource,
-                dispatchResult: result.status,
+                dispatchResult: dispatchFailed ? "failed" : result.status,
                 sessionName: result.sessionName,
-                error: result.error
+                error: dispatchFailed ? dispatchFailureError : result.error
               });
             }
           } else {
@@ -1006,7 +1201,7 @@ ${dispatchErr instanceof Error ? dispatchErr.stack : ""}
       }
       let dupWarning = "";
       try {
-        const { findMatchingBranches } = await import("./branch-hygiene-KCGXRAWP.js");
+        const { findMatchingBranches } = await import("./branch-hygiene-U5GFRSTP.js");
         const matches = await findMatchingBranches(resolvedProjectDir, { title });
         if (matches.length > 0) {
           const top = matches.slice(0, 3).map((m) => {

package/dist/{chunk-4ZJ5BPY6.js → chunk-PB5S7YOF.js}

@@ -1,9 +1,9 @@
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 import {
   loadConfigSync
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/token-spend.ts
 import { readdir, stat } from "fs/promises";