@askexenow/exe-os 0.8.108 → 0.9.0

package/dist/bin/cli.js

@@ -607,6 +607,7 @@ var init_preferences = __esm({
 // src/adapters/claude/installer.ts
 var installer_exports = {};
 __export(installer_exports, {
+  cleanOldShellFunctions: () => cleanOldShellFunctions,
   copySlashCommands: () => copySlashCommands,
   installStatusLine: () => installStatusLine,
   mergeHooks: () => mergeHooks,
@@ -1015,6 +1016,132 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
   await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return { added, skipped };
 }
+async function cleanOldShellFunctions(homeDir = os5.homedir()) {
+  const rosterPath = path5.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync5(rosterPath)) return 0;
+  let employees;
+  try {
+    employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
+  } catch {
+    return 0;
+  }
+  if (employees.length === 0) return 0;
+  const names = employees.map((e) => e.name);
+  const funcPatterns = names.map((n) => {
+    const funcDef = new RegExp(`^\\s*(function\\s+)?${escapeRegExp(n)}\\d+\\s*\\(\\)`, "m");
+    const forLoop = new RegExp(`${escapeRegExp(n)}\\$\\{?[a-zA-Z_][a-zA-Z0-9_]*\\}?`, "m");
+    return { name: n, funcDef, forLoop };
+  });
+  const rcFiles = [
+    path5.join(homeDir, ".zshrc"),
+    path5.join(homeDir, ".bashrc")
+  ];
+  const REMOVED_MARKER = "# Removed by exe-os \u2014 wrappers now at ~/.exe-os/bin/";
+  let totalRemoved = 0;
+  for (const rcPath of rcFiles) {
+    if (!existsSync5(rcPath)) continue;
+    let content;
+    try {
+      content = await readFile3(rcPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes(REMOVED_MARKER)) continue;
+    const lines = content.split("\n");
+    let changed = false;
+    let inForLoop = false;
+    let forLoopMatchesEmployee = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) continue;
+      if (/^\s*for\s+/.test(trimmed)) {
+        inForLoop = true;
+        forLoopMatchesEmployee = false;
+        for (const { forLoop } of funcPatterns) {
+          if (forLoop.test(trimmed)) {
+            forLoopMatchesEmployee = true;
+            break;
+          }
+        }
+        if (forLoopMatchesEmployee) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          continue;
+        }
+      }
+      if (inForLoop) {
+        if (!forLoopMatchesEmployee) {
+          for (const { forLoop } of funcPatterns) {
+            if (forLoop.test(trimmed)) {
+              forLoopMatchesEmployee = true;
+              for (let j = i - 1; j >= 0; j--) {
+                if (/^\s*for\s+/.test(lines[j].replace(/^#\s*/, ""))) {
+                  if (!lines[j].startsWith("#")) {
+                    lines[j] = `${REMOVED_MARKER}
+# ${lines[j]}`;
+                    totalRemoved++;
+                  }
+                  break;
+                }
+              }
+              break;
+            }
+          }
+        }
+        if (forLoopMatchesEmployee && !trimmed.startsWith("#")) {
+          lines[i] = `# ${line}`;
+          changed = true;
+          totalRemoved++;
+        }
+        if (trimmed === "done" || trimmed.startsWith("done;") || trimmed.startsWith("done ")) {
+          inForLoop = false;
+          forLoopMatchesEmployee = false;
+        }
+        continue;
+      }
+      for (const { funcDef } of funcPatterns) {
+        if (funcDef.test(trimmed)) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          let braceDepth = 0;
+          const hasBrace = trimmed.includes("{");
+          if (hasBrace) braceDepth = 1;
+          for (let j = i + 1; j < lines.length; j++) {
+            const bodyLine = lines[j].trim();
+            if (!hasBrace && braceDepth === 0) {
+              if (bodyLine === "{") {
+                braceDepth = 1;
+                lines[j] = `# ${lines[j]}`;
+                totalRemoved++;
+                continue;
+              }
+            }
+            if (braceDepth > 0) {
+              braceDepth += (bodyLine.match(/{/g) ?? []).length;
+              braceDepth -= (bodyLine.match(/}/g) ?? []).length;
+              lines[j] = `# ${lines[j]}`;
+              totalRemoved++;
+              if (braceDepth <= 0) break;
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (changed) {
+      await writeFile3(rcPath, lines.join("\n"));
+    }
+  }
+  return totalRemoved;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 async function injectOrchestrationRules(homeDir) {
   const claudeDir = path5.join(homeDir, ".claude");
   const claudeMdPath = path5.join(claudeDir, "CLAUDE.md");
@@ -1117,6 +1244,13 @@ async function runInstaller(homeDir) {
     `Status line: ${statusLineResult}
 `
   );
+  const shellFuncsCleaned = await cleanOldShellFunctions(resolvedHome);
+  if (shellFuncsCleaned > 0) {
+    process.stderr.write(
+      `Shell cleanup: removed ${shellFuncsCleaned} old shell function(s) that were shadowing exe-os wrappers
+`
+    );
+  }
   process.stderr.write(`
 exe-os installed successfully.
 `);
@@ -10181,7 +10315,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/bin/exe-boot.js

@@ -6268,7 +6268,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/bin/exe-dispatch.js

@@ -4434,7 +4434,7 @@ function spawnEmployee(employeeName2, exeSession2, projectDir2, opts) {
       `[tmux-routing] agent-config: ${employeeName2} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName2}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName2} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName2}-opencode`;
     process.stderr.write(

package/dist/bin/exe-gateway.js

@@ -9159,7 +9159,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/bin/exe-new-employee.js

@@ -1020,6 +1020,7 @@ var init_preferences = __esm({
 // src/adapters/claude/installer.ts
 var installer_exports = {};
 __export(installer_exports, {
+  cleanOldShellFunctions: () => cleanOldShellFunctions,
   copySlashCommands: () => copySlashCommands,
   installStatusLine: () => installStatusLine,
   mergeHooks: () => mergeHooks,
@@ -1428,6 +1429,132 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
   await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return { added, skipped };
 }
+async function cleanOldShellFunctions(homeDir = os5.homedir()) {
+  const rosterPath = path9.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync9(rosterPath)) return 0;
+  let employees;
+  try {
+    employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
+  } catch {
+    return 0;
+  }
+  if (employees.length === 0) return 0;
+  const names = employees.map((e) => e.name);
+  const funcPatterns = names.map((n) => {
+    const funcDef = new RegExp(`^\\s*(function\\s+)?${escapeRegExp(n)}\\d+\\s*\\(\\)`, "m");
+    const forLoop = new RegExp(`${escapeRegExp(n)}\\$\\{?[a-zA-Z_][a-zA-Z0-9_]*\\}?`, "m");
+    return { name: n, funcDef, forLoop };
+  });
+  const rcFiles = [
+    path9.join(homeDir, ".zshrc"),
+    path9.join(homeDir, ".bashrc")
+  ];
+  const REMOVED_MARKER = "# Removed by exe-os \u2014 wrappers now at ~/.exe-os/bin/";
+  let totalRemoved = 0;
+  for (const rcPath of rcFiles) {
+    if (!existsSync9(rcPath)) continue;
+    let content;
+    try {
+      content = await readFile3(rcPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes(REMOVED_MARKER)) continue;
+    const lines = content.split("\n");
+    let changed = false;
+    let inForLoop = false;
+    let forLoopMatchesEmployee = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) continue;
+      if (/^\s*for\s+/.test(trimmed)) {
+        inForLoop = true;
+        forLoopMatchesEmployee = false;
+        for (const { forLoop } of funcPatterns) {
+          if (forLoop.test(trimmed)) {
+            forLoopMatchesEmployee = true;
+            break;
+          }
+        }
+        if (forLoopMatchesEmployee) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          continue;
+        }
+      }
+      if (inForLoop) {
+        if (!forLoopMatchesEmployee) {
+          for (const { forLoop } of funcPatterns) {
+            if (forLoop.test(trimmed)) {
+              forLoopMatchesEmployee = true;
+              for (let j = i - 1; j >= 0; j--) {
+                if (/^\s*for\s+/.test(lines[j].replace(/^#\s*/, ""))) {
+                  if (!lines[j].startsWith("#")) {
+                    lines[j] = `${REMOVED_MARKER}
+# ${lines[j]}`;
+                    totalRemoved++;
+                  }
+                  break;
+                }
+              }
+              break;
+            }
+          }
+        }
+        if (forLoopMatchesEmployee && !trimmed.startsWith("#")) {
+          lines[i] = `# ${line}`;
+          changed = true;
+          totalRemoved++;
+        }
+        if (trimmed === "done" || trimmed.startsWith("done;") || trimmed.startsWith("done ")) {
+          inForLoop = false;
+          forLoopMatchesEmployee = false;
+        }
+        continue;
+      }
+      for (const { funcDef } of funcPatterns) {
+        if (funcDef.test(trimmed)) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          let braceDepth = 0;
+          const hasBrace = trimmed.includes("{");
+          if (hasBrace) braceDepth = 1;
+          for (let j = i + 1; j < lines.length; j++) {
+            const bodyLine = lines[j].trim();
+            if (!hasBrace && braceDepth === 0) {
+              if (bodyLine === "{") {
+                braceDepth = 1;
+                lines[j] = `# ${lines[j]}`;
+                totalRemoved++;
+                continue;
+              }
+            }
+            if (braceDepth > 0) {
+              braceDepth += (bodyLine.match(/{/g) ?? []).length;
+              braceDepth -= (bodyLine.match(/}/g) ?? []).length;
+              lines[j] = `# ${lines[j]}`;
+              totalRemoved++;
+              if (braceDepth <= 0) break;
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (changed) {
+      await writeFile3(rcPath, lines.join("\n"));
+    }
+  }
+  return totalRemoved;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 async function injectOrchestrationRules(homeDir) {
   const claudeDir = path9.join(homeDir, ".claude");
   const claudeMdPath = path9.join(claudeDir, "CLAUDE.md");
@@ -1530,6 +1657,13 @@ async function runInstaller(homeDir) {
     `Status line: ${statusLineResult}
 `
   );
+  const shellFuncsCleaned = await cleanOldShellFunctions(resolvedHome);
+  if (shellFuncsCleaned > 0) {
+    process.stderr.write(
+      `Shell cleanup: removed ${shellFuncsCleaned} old shell function(s) that were shadowing exe-os wrappers
+`
+    );
+  }
   process.stderr.write(`
 exe-os installed successfully.
 `);

package/dist/bin/exe-session-cleanup.js

@@ -6270,7 +6270,7 @@ function spawnEmployee(employeeName, exeSession2, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/bin/exe-start-codex.js

@@ -2791,8 +2791,17 @@ function resolveAgent(argv) {
     );
   }
   const agent = rest[idx + 1].toLowerCase();
-  const passthrough = [...rest.slice(0, idx), ...rest.slice(idx + 2)];
-  return { agent, passthrough };
+  const withoutAgent = [...rest.slice(0, idx), ...rest.slice(idx + 2)];
+  const sessIdx = withoutAgent.indexOf("--session");
+  let sessionName;
+  let passthrough;
+  if (sessIdx !== -1 && withoutAgent[sessIdx + 1]) {
+    sessionName = withoutAgent[sessIdx + 1];
+    passthrough = [...withoutAgent.slice(0, sessIdx), ...withoutAgent.slice(sessIdx + 2)];
+  } else {
+    passthrough = withoutAgent;
+  }
+  return { agent, passthrough, sessionName };
 }
 function loadIdentity(agent) {
   const dir = path11.join(os9.homedir(), ".exe-os", "identity");
@@ -2839,8 +2848,9 @@ function writePromptFile(agent, identity, behaviorsPath) {
 async function main() {
   let agent;
   let passthrough;
+  let sessionName;
   try {
-    ({ agent, passthrough } = resolveAgent(process.argv));
+    ({ agent, passthrough, sessionName } = resolveAgent(process.argv));
   } catch (err) {
     process.stderr.write(`${err.message}
 `);
@@ -2941,6 +2951,37 @@ async function main() {
 `
     );
   }
+  const WORKTREE_ROLES = /* @__PURE__ */ new Set(["Principal Engineer", "Staff Code Reviewer"]);
+  let worktreePath = null;
+  const worktreeName = sessionName ? sessionName.split("-")[0] : agent;
+  process.stderr.write(`[exe-start-codex] agent=${agent} session=${sessionName ?? "none"} worktree=${worktreeName} role="${empRole}" worktree-eligible=${WORKTREE_ROLES.has(empRole)}
+`);
+  if (WORKTREE_ROLES.has(empRole)) {
+    try {
+      const { execSync: es } = await import("child_process");
+      const worktreeDir = path11.join(process.cwd(), ".worktrees", worktreeName);
+      const branchName = `${worktreeName}/codex-${Date.now()}`;
+      if (existsSync10(worktreeDir)) {
+        worktreePath = worktreeDir;
+        process.stderr.write(`[exe-start-codex] Reusing worktree at ${worktreeDir}
+`);
+      } else {
+        mkdirSync7(path11.dirname(worktreeDir), { recursive: true });
+        es(`git worktree add "${worktreeDir}" -b "${branchName}" HEAD`, {
+          encoding: "utf-8",
+          timeout: 3e4
+        });
+        worktreePath = worktreeDir;
+        process.stderr.write(`[exe-start-codex] Created worktree at ${worktreeDir} (branch: ${branchName})
+`);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[exe-start-codex] Worktree creation failed for ${agent}: ${err instanceof Error ? err.message : String(err)}. Falling back to main checkout.
+`
+      );
+    }
+  }
   const effectiveModel = process.env.EXE_AGENT_MODEL ?? CODEX.defaultModel;
   const args = [
     "-m",
@@ -2949,6 +2990,9 @@ async function main() {
     CODEX.inlineFlag,
     ...passthrough
   ];
+  if (worktreePath) {
+    args.push("-C", worktreePath);
+  }
   if (promptPath) {
     args.push("-c", `model_instructions_file="${promptPath}"`);
   }

package/dist/bin/git-sweep.js

@@ -4922,7 +4922,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/bin/install.js

@@ -804,6 +804,132 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
   await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return { added, skipped };
 }
+async function cleanOldShellFunctions(homeDir = os5.homedir()) {
+  const rosterPath = path5.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync5(rosterPath)) return 0;
+  let employees;
+  try {
+    employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
+  } catch {
+    return 0;
+  }
+  if (employees.length === 0) return 0;
+  const names = employees.map((e) => e.name);
+  const funcPatterns = names.map((n) => {
+    const funcDef = new RegExp(`^\\s*(function\\s+)?${escapeRegExp(n)}\\d+\\s*\\(\\)`, "m");
+    const forLoop = new RegExp(`${escapeRegExp(n)}\\$\\{?[a-zA-Z_][a-zA-Z0-9_]*\\}?`, "m");
+    return { name: n, funcDef, forLoop };
+  });
+  const rcFiles = [
+    path5.join(homeDir, ".zshrc"),
+    path5.join(homeDir, ".bashrc")
+  ];
+  const REMOVED_MARKER = "# Removed by exe-os \u2014 wrappers now at ~/.exe-os/bin/";
+  let totalRemoved = 0;
+  for (const rcPath of rcFiles) {
+    if (!existsSync5(rcPath)) continue;
+    let content;
+    try {
+      content = await readFile3(rcPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes(REMOVED_MARKER)) continue;
+    const lines = content.split("\n");
+    let changed = false;
+    let inForLoop = false;
+    let forLoopMatchesEmployee = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) continue;
+      if (/^\s*for\s+/.test(trimmed)) {
+        inForLoop = true;
+        forLoopMatchesEmployee = false;
+        for (const { forLoop } of funcPatterns) {
+          if (forLoop.test(trimmed)) {
+            forLoopMatchesEmployee = true;
+            break;
+          }
+        }
+        if (forLoopMatchesEmployee) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          continue;
+        }
+      }
+      if (inForLoop) {
+        if (!forLoopMatchesEmployee) {
+          for (const { forLoop } of funcPatterns) {
+            if (forLoop.test(trimmed)) {
+              forLoopMatchesEmployee = true;
+              for (let j = i - 1; j >= 0; j--) {
+                if (/^\s*for\s+/.test(lines[j].replace(/^#\s*/, ""))) {
+                  if (!lines[j].startsWith("#")) {
+                    lines[j] = `${REMOVED_MARKER}
+# ${lines[j]}`;
+                    totalRemoved++;
+                  }
+                  break;
+                }
+              }
+              break;
+            }
+          }
+        }
+        if (forLoopMatchesEmployee && !trimmed.startsWith("#")) {
+          lines[i] = `# ${line}`;
+          changed = true;
+          totalRemoved++;
+        }
+        if (trimmed === "done" || trimmed.startsWith("done;") || trimmed.startsWith("done ")) {
+          inForLoop = false;
+          forLoopMatchesEmployee = false;
+        }
+        continue;
+      }
+      for (const { funcDef } of funcPatterns) {
+        if (funcDef.test(trimmed)) {
+          lines[i] = `${REMOVED_MARKER}
+# ${line}`;
+          changed = true;
+          totalRemoved++;
+          let braceDepth = 0;
+          const hasBrace = trimmed.includes("{");
+          if (hasBrace) braceDepth = 1;
+          for (let j = i + 1; j < lines.length; j++) {
+            const bodyLine = lines[j].trim();
+            if (!hasBrace && braceDepth === 0) {
+              if (bodyLine === "{") {
+                braceDepth = 1;
+                lines[j] = `# ${lines[j]}`;
+                totalRemoved++;
+                continue;
+              }
+            }
+            if (braceDepth > 0) {
+              braceDepth += (bodyLine.match(/{/g) ?? []).length;
+              braceDepth -= (bodyLine.match(/}/g) ?? []).length;
+              lines[j] = `# ${lines[j]}`;
+              totalRemoved++;
+              if (braceDepth <= 0) break;
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (changed) {
+      await writeFile3(rcPath, lines.join("\n"));
+    }
+  }
+  return totalRemoved;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var EXE_SECTION_START = "<!-- exe-os:orchestration-start -->";
 var EXE_SECTION_END = "<!-- exe-os:orchestration-end -->";
 var ORCHESTRATION_RULES = `${EXE_SECTION_START}
@@ -919,6 +1045,13 @@ async function runInstaller(homeDir) {
     `Status line: ${statusLineResult}
 `
   );
+  const shellFuncsCleaned = await cleanOldShellFunctions(resolvedHome);
+  if (shellFuncsCleaned > 0) {
+    process.stderr.write(
+      `Shell cleanup: removed ${shellFuncsCleaned} old shell function(s) that were shadowing exe-os wrappers
+`
+    );
+  }
   process.stderr.write(`
 exe-os installed successfully.
 `);

package/dist/bin/scan-tasks.js

@@ -4927,7 +4927,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/gateway/index.js

@@ -7501,7 +7501,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/bug-report-worker.js

@@ -3433,7 +3433,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/commit-complete.js

@@ -4921,7 +4921,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/ingest-worker.js

@@ -4300,7 +4300,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/pre-compact.js

@@ -4905,7 +4905,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/prompt-submit.js

@@ -7405,7 +7405,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/hooks/session-end.js

@@ -5107,7 +5107,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/index.js

@@ -5339,7 +5339,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/lib/cloudflare-dns.js

@@ -0,0 +1,117 @@
+// src/lib/cloudflare-dns.ts
+var CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
+var DNS_RECORD_TYPE_A = "A";
+var DEFAULT_PROXIED = true;
+var DEFAULT_TTL = 1;
+var REQUEST_TIMEOUT_MS = 3e4;
+var UNKNOWN_ERROR_CODE = "unknown";
+async function createARecord(cfApiToken, zoneId, domain, ip, opts) {
+  const proxied = opts?.proxied ?? DEFAULT_PROXIED;
+  const ttl = opts?.ttl ?? DEFAULT_TTL;
+  const response = await requestCloudflare(cfApiToken, zoneId, {
+    method: "POST",
+    body: {
+      type: DNS_RECORD_TYPE_A,
+      name: domain,
+      content: ip,
+      proxied,
+      ttl
+    }
+  });
+  return mapDnsRecord(response);
+}
+async function deleteARecord(cfApiToken, zoneId, recordId) {
+  await requestCloudflare(cfApiToken, zoneId, {
+    method: "DELETE",
+    path: `/dns_records/${recordId}`
+  });
+}
+async function findARecord(cfApiToken, zoneId, name) {
+  const query = new URLSearchParams({
+    type: DNS_RECORD_TYPE_A,
+    name
+  });
+  const records = await requestCloudflare(cfApiToken, zoneId, {
+    method: "GET",
+    query
+  });
+  const record = records[0];
+  return record ? mapDnsRecord(record) : null;
+}
+async function requestCloudflare(cfApiToken, zoneId, options) {
+  const response = await fetch(buildUrl(zoneId, options.path, options.query), {
+    method: options.method,
+    headers: buildHeaders(cfApiToken),
+    body: options.body ? JSON.stringify(options.body) : void 0,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  const envelope = await parseEnvelope(response);
+  if (!response.ok || !envelope.success) {
+    throw toCloudflareError(response, envelope);
+  }
+  return envelope.result;
+}
+function buildUrl(zoneId, path = "/dns_records", query) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(
+    `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
+  );
+  if (query) {
+    url.search = query.toString();
+  }
+  return url.toString();
+}
+function buildHeaders(cfApiToken) {
+  return {
+    Authorization: `Bearer ${cfApiToken}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+async function parseEnvelope(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {
+      success: false,
+      errors: [
+        {
+          code: UNKNOWN_ERROR_CODE,
+          message: `HTTP ${response.status}: ${response.statusText}`
+        }
+      ],
+      messages: [],
+      result: null
+    };
+  }
+}
+function toCloudflareError(response, envelope) {
+  const firstError = envelope.errors[0];
+  const errorCode = String(firstError?.code ?? UNKNOWN_ERROR_CODE);
+  const message = firstError?.message ?? `HTTP ${response.status}: ${response.statusText}`;
+  return new CloudflareError(response.status, errorCode, message);
+}
+function mapDnsRecord(record) {
+  return {
+    recordId: record.id,
+    name: record.name,
+    ip: record.content,
+    proxied: record.proxied
+  };
+}
+var CloudflareError = class extends Error {
+  status;
+  errorCode;
+  constructor(status, errorCode, message) {
+    super(message);
+    this.name = "CloudflareError";
+    this.status = status;
+    this.errorCode = errorCode;
+  }
+};
+export {
+  CloudflareError,
+  createARecord,
+  deleteARecord,
+  findARecord
+};

package/dist/lib/exe-daemon.js

@@ -2937,11 +2937,6 @@ var init_session_kill_telemetry = __esm({
 });
 
 // src/lib/task-scope.ts
-var task_scope_exports = {};
-__export(task_scope_exports, {
-  getCurrentSessionScope: () => getCurrentSessionScope,
-  sessionScopeFilter: () => sessionScopeFilter
-});
 function getCurrentSessionScope() {
   try {
     return resolveExeSession();
@@ -5611,7 +5606,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(
@@ -6482,6 +6477,7 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     const agent = deps.parseAgentFromSession(session);
     if (agent) liveAgents.add(agent);
   }
+  const coordinatorSessions = liveSessions.filter((s) => isExeSession(s));
   let tasksByAgent;
   try {
     tasksByAgent = await deps.queryTasksByAgent();
@@ -6490,12 +6486,17 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
   }
   const agentTasks = /* @__PURE__ */ new Map();
   for (const t of tasksByAgent) {
-    const existing = agentTasks.get(t.agentId) ?? [];
-    existing.push({ taskId: t.taskId, priority: t.priority });
-    agentTasks.set(t.agentId, existing);
+    const scope = t.sessionScope || coordinatorSessions[0] || null;
+    if (!scope) continue;
+    const key = `${t.agentId}::${scope}`;
+    const existing = agentTasks.get(key) ?? [];
+    existing.push({ taskId: t.taskId, priority: t.priority, sessionScope: scope });
+    agentTasks.set(key, existing);
   }
   const woken = [];
-  for (const [agentId, tasks] of agentTasks) {
+  for (const [key, tasks] of agentTasks) {
+    const agentId = key.split("::")[0];
+    const sessionScope = tasks[0].sessionScope;
     if (!shouldAutoWake({
       agentId,
       hasRunningSession: liveAgents.has(agentId),
@@ -6522,11 +6523,11 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
       continue;
     }
     process.stderr.write(
-      `[auto-wake] ${agentId} has ${tasks.length} pending task(s) but no session \u2014 spawning (attempt ${retries + 1} for task ${topTask.taskId})
+      `[auto-wake] ${agentId} has ${tasks.length} pending task(s) but no session \u2014 spawning in ${sessionScope} (attempt ${retries + 1} for task ${topTask.taskId})
 `
     );
     try {
-      const result = deps.ensureEmployee(agentId);
+      const result = deps.ensureEmployee(agentId, sessionScope);
       if (result.status === "failed") {
         process.stderr.write(
           `[auto-wake] Failed to spawn ${agentId}: ${result.error ?? "unknown"}
@@ -6546,7 +6547,7 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
   }
   return woken;
 }
-function createAutoWakeRealDeps(getClient2, sessionScope, projectDir) {
+function createAutoWakeRealDeps(getClient2, projectDir) {
   return {
     listTmuxSessions: () => {
       const { listTmuxSessions: listTmuxSessions2 } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
@@ -6554,24 +6555,24 @@ function createAutoWakeRealDeps(getClient2, sessionScope, projectDir) {
     },
     queryTasksByAgent: async () => {
       const client = getClient2();
-      const scope = sessionScopeFilter(sessionScope);
       const result = await client.execute({
-        sql: `SELECT assigned_to, id, priority FROM tasks
-              WHERE status IN ('open', 'in_progress')${scope.sql}
+        sql: `SELECT assigned_to, id, priority, session_scope FROM tasks
+              WHERE status IN ('open', 'in_progress')
               ORDER BY
                 CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
                 created_at ASC`,
-        args: [...scope.args]
+        args: []
       });
       return result.rows.map((r) => ({
         agentId: String(r.assigned_to),
         taskId: String(r.id),
-        priority: String(r.priority)
+        priority: String(r.priority),
+        sessionScope: r.session_scope ? String(r.session_scope) : null
       }));
     },
-    ensureEmployee: (agentName) => {
+    ensureEmployee: (agentName, scope) => {
       const { ensureEmployee: ensureEmployee2 } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
-      return ensureEmployee2(agentName, sessionScope, projectDir);
+      return ensureEmployee2(agentName, scope, projectDir);
     },
     markTaskBlocked: async (taskId, reason) => {
       const client = getClient2();
@@ -10800,9 +10801,7 @@ function startAutoWake() {
     try {
       const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
       const { pollOrphanedTasks: pollOrphanedTasks2, createAutoWakeRealDeps: createAutoWakeRealDeps2 } = await Promise.resolve().then(() => (init_daemon_orchestration(), daemon_orchestration_exports));
-      const { getCurrentSessionScope: getCurrentSessionScope2 } = await Promise.resolve().then(() => (init_task_scope(), task_scope_exports));
-      const sessionScope = getCurrentSessionScope2() ?? "";
-      const deps = createAutoWakeRealDeps2(getClient2, sessionScope, process.cwd());
+      const deps = createAutoWakeRealDeps2(getClient2, process.cwd());
       const woken = await pollOrphanedTasks2(deps);
       for (const agent of woken) {
         process.stderr.write(`[exed] Auto-wake: spawned ${agent}

package/dist/lib/tasks.js

@@ -1846,7 +1846,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/lib/tmux-routing.js

@@ -3426,7 +3426,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/mcp/server.js

@@ -7156,7 +7156,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/mcp/tools/create-task.js

@@ -2051,7 +2051,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/runtime/index.js

@@ -5038,7 +5038,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/dist/tui/App.js

@@ -5544,7 +5544,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
 `
     );
-    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName} --session ${sessionName}${cleanupSuffix}`;
   } else if (useOpencode) {
     const binName = `${employeeName}-opencode`;
     process.stderr.write(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.8.108",
+  "version": "0.9.0",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "CC-BY-NC-4.0",
   "type": "module",