@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/{chunk-DILD54TU.js → chunk-OZEBAGKR.js}

@@ -1,40 +1,42 @@
 import {
+  createTask
+} from "./chunk-QYZJHTNE.js";
+import {
+  releaseDispatchClaim,
+  tryAcquireDispatchClaim,
   writeDispatchFailed,
   writeDispatchPending
-} from "./chunk-HMP5VT6A.js";
-import {
-  createTask
-} from "./chunk-542EWGY3.js";
+} from "./chunk-O7LWR36Z.js";
 import {
   getActiveAgent
-} from "./chunk-DZ6OQM67.js";
+} from "./chunk-5ERDIOV3.js";
 import {
-  ensureEmployee,
+  ensureEmployeeAsync,
   isValidSessionScope,
   logTaskDispatch,
   resolveExeSession
-} from "./chunk-PLRIJALF.js";
+} from "./chunk-UP75Z5X7.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-FUIIVSW6.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   getAgentRuntime,
   validateRuntimeModel
-} from "./chunk-65SVQELL.js";
+} from "./chunk-HA5R6USD.js";
 import {
   getLicenseSync
-} from "./chunk-MW2GJJ53.js";
+} from "./chunk-JGIPOUIK.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-HEPR6QTL.js";
+} from "./chunk-AOHXREB7.js";
 
 // src/mcp/tools/create-task.ts
 import { z } from "zod";
-import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
-import { basename, join } from "path";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { basename, dirname, isAbsolute, join, sep } from "path";
 import { homedir } from "os";
 function rootFromSessionName(sessionName) {
   const raw = (sessionName ?? "").trim();
@@ -55,6 +57,20 @@ function isDirectory(pathname) {
 function isGitRepoDir(pathname) {
   return isDirectory(pathname) && existsSync(join(pathname, ".git"));
 }
+function realpathSafe(pathname) {
+  try {
+    return realpathSync(pathname);
+  } catch {
+    return pathname;
+  }
+}
+function isRealpathInside(candidate, scopedRoot) {
+  const rc = realpathSafe(candidate);
+  const rr = realpathSafe(scopedRoot);
+  if (rc === rr) return true;
+  const prefix = rr.endsWith(sep) ? rr : rr + sep;
+  return rc.startsWith(prefix);
+}
 function findNestedGitRepo(parentDir) {
   const preferred = ["website", "app", "repo", "src"];
   for (const child of preferred) {
@@ -74,34 +90,72 @@ function findNestedGitRepo(parentDir) {
 function projectDirMatches(projectDir, projectName) {
   const dirBasename = basename(projectDir).toLowerCase();
   const normalizedProject = projectName.toLowerCase();
-  return dirBasename === normalizedProject || dirBasename === normalizedProject.replace(/^exe-/, "") || `exe-${dirBasename}` === normalizedProject || projectDir.toLowerCase().includes(normalizedProject);
+  return dirBasename === normalizedProject || dirBasename === normalizedProject.replace(/^exe-/, "") || `exe-${dirBasename}` === normalizedProject;
+}
+function isSafeProjectName(projectName) {
+  if (typeof projectName !== "string") return false;
+  const name = projectName.trim();
+  if (name.length === 0 || name.length > 128) return false;
+  if (name === "." || name === "..") return false;
+  if (name.includes("\0")) return false;
+  if (isAbsolute(name)) return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  if (name.split(/[/\\]/).some((seg) => seg === "..")) return false;
+  return true;
 }
 function findProjectChildDir(parentDir, projectName) {
+  if (!isSafeProjectName(projectName)) return null;
   if (!existsSync(parentDir)) return null;
   const normalizedProject = projectName.toLowerCase();
   const aliases = /* @__PURE__ */ new Set([
     normalizedProject,
     normalizedProject.replace(/^exe-/, "")
   ]);
+  const accept = (candidate) => {
+    if (!candidate) return null;
+    if (!isRealpathInside(candidate, parentDir)) {
+      process.stderr.write(
+        `[create-task] rejecting "${projectName}" candidate ${candidate}: symlink resolves outside scoped root ${parentDir}.
+`
+      );
+      return null;
+    }
+    return candidate;
+  };
   const exactCandidate = join(parentDir, projectName);
-  if (isGitRepoDir(exactCandidate)) return exactCandidate;
-  if (isDirectory(exactCandidate)) {
-    const nested = findNestedGitRepo(exactCandidate);
-    if (nested) return nested;
+  if (isGitRepoDir(exactCandidate)) {
+    const ok = accept(exactCandidate);
+    if (ok) return ok;
   }
+  const matches = /* @__PURE__ */ new Set();
+  const exactNested = isDirectory(exactCandidate) ? accept(findNestedGitRepo(exactCandidate)) : null;
+  if (exactNested) matches.add(exactNested);
   try {
     for (const entry of readdirSync(parentDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       const lower = entry.name.toLowerCase();
       if (aliases.has(lower) || `exe-${lower}` === normalizedProject) {
         const candidate = join(parentDir, entry.name);
-        if (isGitRepoDir(candidate)) return candidate;
-        const nested = findNestedGitRepo(candidate);
-        if (nested) return nested;
+        if (isGitRepoDir(candidate)) {
+          const ok = accept(candidate);
+          if (ok) matches.add(ok);
+          continue;
+        }
+        const nested = accept(findNestedGitRepo(candidate));
+        if (nested) matches.add(nested);
       }
     }
   } catch {
   }
+  const sorted = [...matches].sort();
+  if (sorted.length === 1) return sorted[0];
+  if (sorted.length > 1) {
+    process.stderr.write(
+      `[create-task] ambiguous project resolution for "${projectName}" under ${parentDir}: ${sorted.length} candidates (${sorted.join(", ")}). Refusing to guess.
+`
+    );
+    return null;
+  }
   return null;
 }
 async function listCoordinatorRoots() {
@@ -212,6 +266,13 @@ function resolveDispatchRuntime(agentId, override) {
 }
 async function resolveProjectDir(projectName, callerSession) {
   const home = homedir();
+  if (!isSafeProjectName(projectName)) {
+    process.stderr.write(
+      `[create-task] refusing to resolve unsafe project name "${String(projectName).slice(0, 80)}" (absolute path, path separator, or ".." segment). Rejecting.
+`
+    );
+    return null;
+  }
   if (callerSession) {
     try {
       const { listSessions } = await import("./lib/session-registry.js");
@@ -219,15 +280,31 @@ async function resolveProjectDir(projectName, callerSession) {
       const coordName = callerSession.includes("-") ? callerSession.slice(callerSession.indexOf("-") + 1) : callerSession;
       const coordSession = sessions.find((s) => s.windowName === coordName) ?? sessions.find((s) => s.windowName === callerSession);
       if (coordSession?.projectDir && existsSync(coordSession.projectDir)) {
-        if (projectDirMatches(coordSession.projectDir, projectName)) {
-          return coordSession.projectDir;
+        const coordDir = coordSession.projectDir;
+        if (projectDirMatches(coordDir, projectName)) {
+          return coordDir;
         }
-        const childProjectDir = findProjectChildDir(coordSession.projectDir, projectName);
-        if (childProjectDir) {
-          return childProjectDir;
+        const childUnderCoord = findProjectChildDir(coordDir, projectName);
+        if (childUnderCoord) return childUnderCoord;
+        const workspaceRoot = dirname(coordDir);
+        if (workspaceRoot !== coordDir) {
+          const sibling = findProjectChildDir(workspaceRoot, projectName);
+          if (sibling) {
+            const owner = sessions.find(
+              (s) => s.windowName !== coordName && s.windowName !== callerSession && s.projectDir && isRealpathInside(sibling, s.projectDir)
+            );
+            if (owner) {
+              process.stderr.write(
+                `[create-task] REFUSING cross-scope resolution: project "${projectName}" -> ${sibling} is owned by coordinator scope "${owner.windowName}", not caller "${callerSession}". Returning null.
+`
+              );
+              return null;
+            }
+            return sibling;
+          }
         }
         process.stderr.write(
-          `[create-task] project mismatch: coordinator dir="${coordSession.projectDir}" (${basename(coordSession.projectDir).toLowerCase()}) vs task project="${projectName}". Falling through.
+          `[create-task] project "${projectName}" not found within caller scope "${callerSession}" (coordinator dir "${coordDir}"). Not scanning other scopes.
 `
         );
       }
@@ -237,36 +314,36 @@ async function resolveProjectDir(projectName, callerSession) {
 `
       );
     }
+    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).
+`
+    );
+    return null;
   }
   try {
     const ctx = getAgentContext();
-    if (ctx?.projectName) {
+    if (ctx?.projectName && isSafeProjectName(ctx.projectName)) {
       const alsCandidate = join(home, ctx.projectName);
       if (existsSync(alsCandidate)) return alsCandidate;
     }
   } catch {
   }
-  const candidates = [
-    join(home, projectName),
-    join(home, projectName.replace(/^exe-/, ""))
-  ];
-  for (const candidate of candidates) {
+  for (const candidate of [join(home, projectName), join(home, projectName.replace(/^exe-/, ""))]) {
     if (existsSync(candidate)) return candidate;
   }
   const cwd = process.cwd();
   if (cwd !== home && existsSync(join(cwd, ".git"))) {
     process.stderr.write(
-      `[create-task] WARN: could not resolve project dir for "${projectName}" \u2014 falling back to cwd (${cwd}). This may cause agents to spawn in the wrong repo.
+      `[create-task] WARN: resolving project "${projectName}" to cwd (${cwd}) \u2014 no caller scope.
 `
     );
     return cwd;
   }
-  const fallback = join(home, projectName);
   process.stderr.write(
-    `[create-task] ERROR: could not resolve project dir for "${projectName}". cwd=${cwd} is not a valid project directory. Using ${fallback} as fallback (may not exist). Ensure the project is cloned or the coordinator session registry is populated.
+    `[create-task] could not resolve an existing project dir for "${projectName}" (no caller scope). Returning null \u2014 dispatch will be refused.
 `
   );
-  return fallback;
+  return null;
 }
 function registerCreateTask(server) {
   server.registerTool(
@@ -287,10 +364,15 @@ function registerCreateTask(server) {
         budget_tokens: z.number().optional().describe("Max tokens allowed for this task (null = unlimited)"),
         budget_fallback_model: z.string().optional().describe("Model to route to when budget is exhausted"),
         spawn_runtime: z.string().optional().describe("Override runtime for spawned session (e.g., 'claude', 'codex', 'opencode')"),
-        spawn_model: z.string().optional().describe("Override model for spawned session (e.g., 'claude-sonnet-4.6', 'claude-haiku-4.5')")
+        spawn_model: z.string().optional().describe("Override model for spawned session (e.g., 'claude-sonnet-4.6', 'claude-haiku-4.5')"),
+        spawn_worktree: z.boolean().optional().describe(
+          "Worktree isolation for code-role agents. Default true (REQUIRED \u2014 a code-role agent that cannot get an isolated git worktree is refused, never spawned on main). Set false ONLY to dispatch a code-role agent into a NON-git 'automation' project (a plain folder with no repo to protect); the agent then runs in the project root and a loud worktree.bypassed event is logged. Genuine non-git projects are auto-detected, so this is rarely needed by hand."
+        ),
+        idempotency_key: z.string().optional().describe("Idempotency key (bug c06a8803): retrying create_task with the SAME key returns the ORIGINAL task instead of creating a duplicate + duplicate spawn. Must be stable across the original call and its retry \u2014 do NOT embed a timestamp. Optional; when omitted no dedup is applied."),
+        idempotency_window: z.string().optional().describe("Optional nonce used to DERIVE an idempotency key when idempotency_key is not given (stable hash of assignee+title+project+session+window). Reuse the same window on a retry to dedup. When both this and idempotency_key are omitted, no dedup is applied.")
       }
     },
-    async ({ title, assigned_to, project_name, priority, complexity, context, blocked_by, parent_task_id, reviewer, budget_tokens, budget_fallback_model, spawn_runtime, spawn_model }) => {
+    async ({ title, assigned_to, project_name, priority, complexity, context, blocked_by, parent_task_id, reviewer, budget_tokens, budget_fallback_model, spawn_runtime, spawn_model, spawn_worktree, idempotency_key, idempotency_window }) => {
       if (!isCoordinatorName(assigned_to)) {
         const license = getLicenseSync();
         if (license.plan === "free") {
@@ -399,6 +481,26 @@ function registerCreateTask(server) {
         effectiveSpawnModel = validated.model;
       }
       const projectDir = await resolveProjectDir(project_name, callerRoot);
+      if (projectDir == null && process.env.VITEST !== "true" && process.env.NODE_ENV !== "test") {
+        const message = `BLOCKED: create_task could not resolve an existing project directory for "${project_name}" within the caller's coordinator scope. Refusing to create/dispatch into a fabricated or cross-scope path. Clone the project (or ensure the coordinator session registry points at it) and retry. If "${project_name}" is a non-git automation project, dispatch it from a session whose coordinator dir contains it.`;
+        process.stderr.write(`[create_task] ${message}
+`);
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "create-task.mcp",
+          severity: "error",
+          agentId: assigned_to,
+          sessionScope: callerRoot || null,
+          projectName: project_name,
+          errorCode: "project_dir_unresolved",
+          payload: { priority, callerTmux, callerSource }
+        });
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+      const resolvedProjectDir = projectDir ?? process.cwd();
       let journalWarning = "";
       try {
         const orphans = findOrphanedDispatchIntents(callerRoot || null);
@@ -434,7 +536,7 @@ function registerCreateTask(server) {
             assignedBy,
             sessionScope: callerRoot || null,
             callerSource,
-            projectDir
+            projectDir: resolvedProjectDir
           }
         );
       } catch (journalErr) {
@@ -453,7 +555,7 @@ function registerCreateTask(server) {
           priority,
           complexity,
           context,
-          baseDir: projectDir,
+          baseDir: resolvedProjectDir,
           blockedBy: blocked_by,
           parentTaskId: parent_task_id,
           reviewer: reviewer ?? assignedBy,
@@ -461,6 +563,11 @@ function registerCreateTask(server) {
           budgetFallbackModel: budget_fallback_model,
           spawnRuntime: spawn_runtime,
           spawnModel: effectiveSpawnModel,
+          // Idempotency (bug c06a8803): thread the OPT-IN key/window through to
+          // createTaskCore so a retried tool call after a daemon transport error
+          // returns the original task instead of inserting a duplicate.
+          idempotencyKey: idempotency_key,
+          idempotencyWindow: idempotency_window,
           // Pass the pre-resolved caller session to tasks-crud so it doesn't
           // re-resolve independently (eliminates cross-session scope divergence).
           callerSession: callerTmux || callerRoot || void 0,
@@ -532,7 +639,7 @@ function registerCreateTask(server) {
           session_scope: sessionScope,
           created_at: (/* @__PURE__ */ new Date()).toISOString()
         }), "utf-8");
-        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-5SIJOE4H.js");
+        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-WV4NWKZH.js");
         recordOE({
           eventType: "signal.created",
           source: "create-task.mcp",
@@ -545,7 +652,7 @@ function registerCreateTask(server) {
       }
       let dispatchStatus = "";
       let dispatchOutcome = "ok";
-      if (task.status !== "blocked" && !process.env.VITEST) {
+      if (task.status !== "blocked" && !process.env.VITEST && !task.deduplicated) {
         try {
           const exeSession = task.sessionScope || callerRoot;
           const dispatchRuntime = resolveDispatchRuntime(assigned_to, spawn_runtime ?? null);
@@ -565,7 +672,7 @@ function registerCreateTask(server) {
             let projectConflictOpts = {};
             try {
               const { getClient } = await import("./lib/database.js");
-              const { sessionScopeFilter } = await import("./task-scope-CQEG5SSJ.js");
+              const { sessionScopeFilter } = await import("./task-scope-FOIW25HR.js");
               const client = getClient();
               const scope = sessionScopeFilter(task.sessionScope || callerRoot || exeSession || null);
               const existing = await client.execute({
@@ -584,116 +691,142 @@ function registerCreateTask(server) {
               }
             } catch {
             }
-            try {
-              writeDispatchPending(task.id, assigned_to);
-            } catch {
-            }
-            const result = ensureEmployee(assigned_to, exeSession, projectDir, {
-              ...autoOpts,
-              ...projectConflictOpts,
-              runtimeOverride: spawn_runtime ?? void 0,
-              modelOverride: effectiveSpawnModel ?? void 0
-            });
-            switch (result.status) {
-              case "intercom_sent":
-                dispatchStatus = `
+            const claimedSpawn = tryAcquireDispatchClaim(task.id, assigned_to);
+            if (!claimedSpawn) {
+              dispatchStatus = `
+Dispatched: deduped \u2014 another dispatch for task ${task.id} is already in flight`;
+              process.stderr.write(
+                `[create_task] DEDUPED spawn for ${assigned_to} task ${task.id} \u2014 a fresh dispatch is already in flight; not double-spawning
+`
+              );
+              recordOrchestrationEventBestEffort({
+                eventType: "dispatch.deduped",
+                source: "create-task.mcp",
+                severity: "info",
+                taskId: task.id,
+                agentId: assigned_to,
+                sessionScope: task.sessionScope || callerRoot || exeSession,
+                projectName: project_name,
+                runtime: dispatchRuntime,
+                result: "deduped",
+                payload: { priority, reason: "fresh_dispatch_in_flight" }
+              });
+            } else {
+              const result = await ensureEmployeeAsync(assigned_to, exeSession, resolvedProjectDir, {
+                ...autoOpts,
+                ...projectConflictOpts,
+                runtimeOverride: spawn_runtime ?? void 0,
+                modelOverride: effectiveSpawnModel ?? void 0,
+                // Explicit worktree opt-out (bug b65135ee) — only when the caller
+                // passed spawn_worktree=false; undefined keeps the refuse-in-main
+                // default. Non-git automation projects auto-bypass downstream.
+                ...spawn_worktree === false ? { spawnWorktree: false } : {}
+              });
+              switch (result.status) {
+                case "intercom_sent":
+                  dispatchStatus = `
 Dispatched: intercom sent to ${result.sessionName}`;
-                break;
-              case "intercom_unprocessed":
-                dispatchStatus = `
+                  break;
+                case "intercom_unprocessed":
+                  dispatchStatus = `
 Dispatched: intercom delivered to ${result.sessionName}`;
-                break;
-              case "spawned":
-                dispatchStatus = `
+                  break;
+                case "spawned":
+                  dispatchStatus = `
 Dispatched: spawned ${result.sessionName}`;
-                break;
-              case "failed":
-                dispatchStatus = `
+                  break;
+                case "failed":
+                  dispatchStatus = `
 Dispatch failed: ${result.error ?? "unknown"}`;
-                break;
-            }
-            if (result.status === "failed") dispatchOutcome = "failed";
-            if (result.status === "failed") {
-              try {
-                writeDispatchFailed(task.id, assigned_to, result.error ?? "spawn failed", result.sessionName);
-              } catch {
+                  break;
               }
-            }
-            recordOrchestrationEventBestEffort({
-              eventType: result.status === "failed" ? "dispatch.failed" : "dispatch.completed",
-              source: "create-task.mcp",
-              severity: result.status === "failed" ? "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 }
-            });
-            try {
-              const { sendIntercom: si } = await import("./lib/tmux-routing.js");
-              const { listTmuxSessions } = await import("./lib/tmux-status.js");
-              if (!autoOpts.autoInstance) {
-                const liveSessions = listTmuxSessions();
-                for (const s of liveSessions) {
-                  const agentPart = s.split("-")[0]?.replace(/\d+$/, "") ?? "";
-                  if (agentPart === assigned_to && s !== result.sessionName) {
-                    si(s, { force: true });
-                  }
+              if (result.status === "failed") dispatchOutcome = "failed";
+              if (result.status === "failed") {
+                try {
+                  releaseDispatchClaim(task.id, assigned_to, result.error ?? "spawn failed");
+                } catch {
+                }
+                try {
+                  writeDispatchFailed(task.id, assigned_to, result.error ?? "spawn failed", result.sessionName);
+                } catch {
                 }
               }
-            } catch {
-            }
-            if (result.sessionName && result.status !== "failed") {
+              recordOrchestrationEventBestEffort({
+                eventType: result.status === "failed" ? "dispatch.failed" : "dispatch.completed",
+                source: "create-task.mcp",
+                severity: result.status === "failed" ? "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 }
+              });
               try {
-                const { getClient: gc } = await import("./lib/database.js");
-                await gc().execute({
-                  // Audited 2026: intentionally unscoped PK update. The task was
-                  // just created in this request, and WHERE id = ? binds one row.
-                  sql: `UPDATE tasks
+                const { sendIntercom: si } = await import("./lib/tmux-routing.js");
+                const { listTmuxSessions } = await import("./lib/tmux-status.js");
+                if (!autoOpts.autoInstance) {
+                  const liveSessions = listTmuxSessions();
+                  for (const s of liveSessions) {
+                    const agentPart = s.split("-")[0]?.replace(/\d+$/, "") ?? "";
+                    if (agentPart === assigned_to && s !== result.sessionName) {
+                      si(s, { force: true });
+                    }
+                  }
+                }
+              } catch {
+              }
+              if (result.sessionName && result.status !== "failed") {
+                try {
+                  const { getClient: gc } = await import("./lib/database.js");
+                  await gc().execute({
+                    // Audited 2026: intentionally unscoped PK update. The task was
+                    // just created in this request, and WHERE id = ? binds one row.
+                    sql: `UPDATE tasks
                         SET instance_id = ?,
                             assigned_tmux = CASE
                               WHEN assigned_tmux IS NULL OR assigned_tmux = 'unknown' THEN ?
                               ELSE assigned_tmux
                             END
                         WHERE id = ?`,
-                  args: [result.sessionName, result.sessionName, task.id]
-                });
-              } catch {
+                    args: [result.sessionName, result.sessionName, task.id]
+                  });
+                } catch {
+                }
+                try {
+                  const sessionScope = task.sessionScope || callerRoot || "default";
+                  const { taskSignalPath: getSignalPath } = await import("./signal-paths-4G53QTII.js");
+                  const signalPath = getSignalPath(sessionScope, assigned_to, task.id);
+                  writeFileSync(signalPath, JSON.stringify({
+                    task_id: task.id,
+                    title,
+                    priority,
+                    assigned_by: assignedBy,
+                    session_scope: sessionScope,
+                    instance_id: result.sessionName,
+                    created_at: (/* @__PURE__ */ new Date()).toISOString()
+                  }), "utf-8");
+                } catch {
+                }
               }
               try {
-                const sessionScope = task.sessionScope || callerRoot || "default";
-                const { taskSignalPath: getSignalPath } = await import("./signal-paths-4G53QTII.js");
-                const signalPath = getSignalPath(sessionScope, assigned_to, task.id);
-                writeFileSync(signalPath, JSON.stringify({
-                  task_id: task.id,
-                  title,
-                  priority,
-                  assigned_by: assignedBy,
-                  session_scope: sessionScope,
-                  instance_id: result.sessionName,
-                  created_at: (/* @__PURE__ */ new Date()).toISOString()
-                }), "utf-8");
+                writeDispatchPending(task.id, assigned_to, result.sessionName);
               } catch {
               }
+              logTaskDispatch({
+                taskId: task.id,
+                assignedTo: assigned_to,
+                callerRoot,
+                exeSession,
+                callerSource,
+                dispatchResult: result.status,
+                sessionName: result.sessionName,
+                error: result.error
+              });
             }
-            try {
-              writeDispatchPending(task.id, assigned_to, result.sessionName);
-            } catch {
-            }
-            logTaskDispatch({
-              taskId: task.id,
-              assignedTo: assigned_to,
-              callerRoot,
-              exeSession,
-              callerSource,
-              dispatchResult: result.status,
-              sessionName: result.sessionName,
-              error: result.error
-            });
           } else {
             const noSessionMsg = `Dispatch skipped: no coordinator session resolved (callerTmux="${callerTmux}", callerSource="${callerSource}"). Task ${task.id} created but agent ${assigned_to} was NOT spawned. Auto-wake will retry.`;
             process.stderr.write(`[create_task] ${noSessionMsg}
@@ -716,6 +849,10 @@ Dispatch deferred: no coordinator session \u2014 auto-wake will spawn ${assigned
           }
         } catch (dispatchErr) {
           dispatchOutcome = "failed";
+          try {
+            releaseDispatchClaim(task.id, assigned_to, "dispatch exception");
+          } catch {
+          }
           recordOrchestrationEventBestEffort({
             eventType: "dispatch.failed",
             source: "create-task.mcp",
@@ -734,8 +871,8 @@ ${dispatchErr instanceof Error ? dispatchErr.stack : ""}
       }
       let dupWarning = "";
       try {
-        const { findMatchingBranches } = await import("./branch-hygiene-R5NVTRAY.js");
-        const matches = await findMatchingBranches(projectDir, { title });
+        const { findMatchingBranches } = await import("./branch-hygiene-TZWK6QCF.js");
+        const matches = await findMatchingBranches(resolvedProjectDir, { title });
         if (matches.length > 0) {
           const top = matches.slice(0, 3).map((m) => {
             const age = m.ageHours >= 24 ? `${(m.ageHours / 24).toFixed(1)}d` : `${m.ageHours.toFixed(0)}h`;
@@ -783,11 +920,14 @@ Warning: ${task.warning}`;
 }
 
 export {
+  isSafeProjectName,
+  findProjectChildDir,
   DISPATCH_JOURNAL_ORPHAN_AGE_MS,
   dispatchJournalDir,
   journalDispatchIntent,
   updateDispatchJournalEntry,
   clearDispatchJournalEntry,
   findOrphanedDispatchIntents,
+  resolveProjectDir,
   registerCreateTask
 };

package/dist/{chunk-DADMPMYX.js → chunk-P5HIWY2E.js}

@@ -1,7 +1,7 @@
 import {
   checkLicense,
   loadLicense
-} from "./chunk-XACL67CS.js";
+} from "./chunk-PQIDGXSG.js";
 
 // src/lib/license-gate.ts
 var _cachedLicense = null;