@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/chunk-HV4KESRY.js

@@ -0,0 +1,395 @@
+import {
+  supportCommitSchema,
+  supportIdSchema,
+  supportProductSchema,
+  supportTaskIdSchema,
+  supportVersionSchema
+} from "./chunk-5H47VHB7.js";
+import {
+  SUPPORT_PRODUCTS,
+  sanitizeProductFilter,
+  sanitizeUpstreamId,
+  sanitizedUpstreamBody
+} from "./chunk-4QCFFW2H.js";
+import {
+  loadLicense,
+  readCachedLicenseToken
+} from "./chunk-PQIDGXSG.js";
+
+// src/mcp/tools/support-inbox.ts
+import { z } from "zod";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_ENDPOINT = "https://api.askexe.com/admin/support/bug-reports";
+var DEFAULT_OWNER_ENDPOINT = "https://api.askexe.com/v1/support/bug-reports";
+var STATUS = z.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+function adminToken() {
+  if (process.env.ASKEXE_SUPPORT_ADMIN_TOKEN) return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN;
+  if (process.env.EXE_SUPPORT_ADMIN_TOKEN) return process.env.EXE_SUPPORT_ADMIN_TOKEN;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return config.support?.adminToken || config.support?.admin_token;
+  } catch {
+    return void 0;
+  }
+}
+function endpoint() {
+  return (process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+}
+function ownerEndpoint() {
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  let configured;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    configured = config.support?.bugReportEndpoint;
+  } catch {
+  }
+  const base = configured || process.env.EXE_BUG_REPORT_ENDPOINT || (routerUrl ? `${routerUrl}/v1/support/bug-reports` : DEFAULT_OWNER_ENDPOINT);
+  return base.replace(/\/+$/, "");
+}
+function ownerAuthHeaders() {
+  let cloudApiKey;
+  try {
+    const configPath = join(process.env.EXE_OS_DIR ?? join(homedir(), ".exe-os"), "config.json");
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    cloudApiKey = config.cloud?.apiKey;
+  } catch {
+  }
+  const licenseKey = loadLicense() || process.env.EXE_LICENSE_KEY || cloudApiKey;
+  const licenseToken = readCachedLicenseToken();
+  const headers = {};
+  if (licenseKey) {
+    headers["x-exe-license-key"] = licenseKey;
+    headers.authorization = `Bearer ${licenseKey}`;
+  }
+  if (licenseToken) headers["x-exe-license-token"] = licenseToken;
+  return headers;
+}
+function assertInternal() {
+  const token = adminToken();
+  if (!token) throw new Error("AskExe support admin token not configured");
+  return token;
+}
+async function requestJson(url, init) {
+  const token = assertInternal();
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      ...init?.headers ?? {}
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await res.text();
+  let data = text;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+  return data;
+}
+async function fetchJson(url, headers, init) {
+  const res = await fetch(url, {
+    ...init,
+    headers: { "content-type": "application/json", ...headers, ...init?.headers ?? {} },
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await res.text();
+  let data = text;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+  return data;
+}
+async function commentRequestJson(bugId, init) {
+  const token = adminToken();
+  if (token) {
+    const url2 = `${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(bugId))}/comments`;
+    return fetchJson(url2, { authorization: `Bearer ${token}` }, init);
+  }
+  const ownerHeaders = ownerAuthHeaders();
+  if (!ownerHeaders.authorization && !ownerHeaders["x-exe-license-token"]) {
+    throw new Error(
+      "Not authenticated for support comments. Run `exe-os login` (GoTrue) or set a license key, or configure an AskExe admin token (ASKEXE_SUPPORT_ADMIN_TOKEN)."
+    );
+  }
+  const url = `${ownerEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(bugId))}/comments`;
+  return fetchJson(url, ownerHeaders, init);
+}
+function registerListBugReports(server) {
+  server.registerTool(
+    "list_bug_reports",
+    {
+      title: "List Bug Reports",
+      description: "AskExe-internal only: list incoming customer bug reports from the support inbox.",
+      inputSchema: {
+        status: z.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
+        severity: z.enum(["p0", "p1", "p2", "p3"]).optional(),
+        // Round 8: constrain to the known enum at the schema — a `product` filter is
+        // NOT free text, and it was sent raw as a query param.
+        product: z.enum(SUPPORT_PRODUCTS).optional().describe("Filter by product"),
+        limit: z.number().int().min(1).max(500).default(25),
+        offset: z.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
+      }
+    },
+    async ({ status, severity, product, limit, offset }) => {
+      const url = new URL(endpoint());
+      url.searchParams.set("status", status);
+      url.searchParams.set("limit", String(limit));
+      url.searchParams.set("offset", String(offset));
+      if (severity) url.searchParams.set("severity", severity);
+      const safeProduct = sanitizeProductFilter(product);
+      if (safeProduct) url.searchParams.set("product", safeProduct);
+      const data = await requestJson(url.toString());
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function parseComments(row) {
+  if (!row || typeof row !== "object") return [];
+  const raw = row.progress_log;
+  if (typeof raw !== "string" || !raw.trim()) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function registerGetBugReport(server) {
+  server.registerTool(
+    "get_bug_report",
+    {
+      title: "Get Bug Report",
+      description: "AskExe-internal only: fetch one customer bug report with full markdown payload and comments thread.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await requestJson(`${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      const comments = parseComments(data);
+      const enriched = data && typeof data === "object" ? { ...data, comments } : { id, comments };
+      return { content: [{ type: "text", text: JSON.stringify(enriched, null, 2) }] };
+    }
+  );
+}
+function registerAddBugReportComment(server) {
+  server.registerTool(
+    "add_bug_report_comment",
+    {
+      title: "Add Bug Report Comment",
+      description: "AskExe-internal only: append a comment to a bug report's thread (POST /comments). Non-destructive \u2014 does not touch triage_notes or status.",
+      inputSchema: {
+        id: supportIdSchema,
+        comment: z.string().min(1).describe("Comment text to append to the bug report thread")
+      }
+    },
+    async ({ id, comment }) => {
+      const data = await commentRequestJson(id, {
+        method: "POST",
+        body: sanitizedUpstreamBody({ comment }, "support-inbox:add_comment")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerGetBugReportComments(server) {
+  server.registerTool(
+    "get_bug_report_comments",
+    {
+      title: "Get Bug Report Comments",
+      description: "AskExe-internal only: list the comments thread on a bug report (GET /comments).",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await commentRequestJson(id);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageBugReport(server) {
+  server.registerTool(
+    "triage_bug_report",
+    {
+      title: "Triage Bug Report",
+      description: "AskExe-internal only: update bug report status and link task/commit/release metadata.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: STATUS.optional(),
+        triage_notes: z.string().optional(),
+        add_note: z.string().optional().describe("Append a timestamped progress note without changing status or replacing triage_notes"),
+        linked_task_id: supportTaskIdSchema.optional(),
+        linked_commit: supportCommitSchema.optional(),
+        fixed_version: supportVersionSchema.optional(),
+        product: supportProductSchema.optional().describe("Re-label this bug's product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp")
+      }
+    },
+    async ({ id, status, triage_notes, add_note, linked_task_id, linked_commit, fixed_version, product }) => {
+      const effectiveStatus = fixed_version && !status ? "closed" : status;
+      const data = await requestJson(`${endpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({ status: effectiveStatus, triage_notes, add_note, linked_task_id, linked_commit, fixed_version, product }, "support-inbox:triage_bug")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+var FEATURE_STATUS = z.enum(["open", "planned", "in_progress", "shipped", "closed", "wontdo"]);
+function featureEndpoint() {
+  return endpoint().replace(/\/bug-reports\/?$/, "/feature-requests");
+}
+function registerListFeatureRequests(server) {
+  server.registerTool(
+    "list_feature_requests",
+    {
+      title: "List Feature Requests",
+      description: "AskExe-internal only: list incoming customer feature requests from the support inbox.",
+      inputSchema: {
+        status: z.enum(["all", "open", "planned", "in_progress", "shipped", "closed", "wontdo"]).default("open"),
+        priority: z.enum(["p0", "p1", "p2", "p3"]).optional(),
+        product: z.string().optional().describe("Filter by product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp"),
+        limit: z.number().int().min(1).max(500).default(25),
+        offset: z.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
+      }
+    },
+    async ({ status, priority, product, limit, offset }) => {
+      const url = new URL(featureEndpoint());
+      url.searchParams.set("status", status);
+      url.searchParams.set("limit", String(limit));
+      url.searchParams.set("offset", String(offset));
+      if (priority) url.searchParams.set("priority", priority);
+      const safeProduct = sanitizeProductFilter(product);
+      if (safeProduct) url.searchParams.set("product", safeProduct);
+      const data = await requestJson(url.toString());
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerGetFeatureRequest(server) {
+  server.registerTool(
+    "get_feature_request",
+    {
+      title: "Get Feature Request",
+      description: "AskExe-internal only: fetch one customer feature request with full payload.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await requestJson(`${featureEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageFeatureRequest(server) {
+  server.registerTool(
+    "triage_feature_request",
+    {
+      title: "Triage Feature Request",
+      description: "AskExe-internal only: update feature request status, response notes, and version metadata.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: FEATURE_STATUS.optional(),
+        response_notes: z.string().optional(),
+        add_note: z.string().optional().describe("Append a timestamped progress note without changing status or replacing response_notes"),
+        target_version: supportVersionSchema.optional(),
+        shipped_version: supportVersionSchema.optional(),
+        // bug b8e990ed: allow admin re-label of a feature's product. Typed with the
+        // strict product schema (round 10 ingress validation), not a loose string.
+        product: supportProductSchema.optional().describe("Re-label this feature's product: exe-os, exe-create, exe-wiki, exe-gateway, exe-crm, exe-build, exe-chat, exe-auth, exe-monitor, exe-db, exe-erp")
+      }
+    },
+    async ({ id, status, response_notes, add_note, target_version, shipped_version, product }) => {
+      const effectiveStatus = shipped_version && !status ? "shipped" : status;
+      const data = await requestJson(`${featureEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({ status: effectiveStatus, response_notes, add_note, target_version, shipped_version, product }, "support-inbox:triage_feature")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+var REVIEW_STATUS = z.enum(["open", "in_review", "approved", "merged", "closed", "rejected"]);
+function reviewEndpoint() {
+  return endpoint().replace(/\/bug-reports\/?$/, "/reviews");
+}
+function registerListReviews(server) {
+  server.registerTool(
+    "list_reviews",
+    {
+      title: "List Reviews",
+      description: "AskExe-internal only: list incoming review requests from the support inbox.",
+      inputSchema: {
+        status: z.enum(["all", "open", "in_review", "approved", "merged", "closed", "rejected"]).default("open"),
+        priority: z.enum(["p0", "p1", "p2", "p3"]).optional(),
+        limit: z.number().int().min(1).max(500).default(25),
+        offset: z.number().int().min(0).default(0).describe("Number of results to skip for pagination. Use next_offset from a prior response.")
+      }
+    },
+    async ({ status, priority, limit, offset }) => {
+      const url = new URL(reviewEndpoint());
+      url.searchParams.set("status", status);
+      url.searchParams.set("limit", String(limit));
+      url.searchParams.set("offset", String(offset));
+      if (priority) url.searchParams.set("priority", priority);
+      const data = await requestJson(url.toString());
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerGetReview(server) {
+  server.registerTool(
+    "get_review",
+    {
+      title: "Get Review",
+      description: "AskExe-internal only: fetch one review with full payload.",
+      inputSchema: { id: supportIdSchema }
+    },
+    async ({ id }) => {
+      const data = await requestJson(`${reviewEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`);
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+function registerTriageReview(server) {
+  server.registerTool(
+    "triage_review",
+    {
+      title: "Triage Review",
+      description: "AskExe-internal only: update review status, response notes, and resolution.",
+      inputSchema: {
+        id: supportIdSchema,
+        status: REVIEW_STATUS.optional(),
+        response_notes: z.string().optional(),
+        add_note: z.string().optional().describe("Append a timestamped progress note without changing status or replacing response_notes"),
+        resolution: z.string().optional(),
+        pr_url: z.string().optional()
+      }
+    },
+    async ({ id, status, response_notes, add_note, resolution, pr_url }) => {
+      const data = await requestJson(`${reviewEndpoint()}/${encodeURIComponent(sanitizeUpstreamId(id))}`, {
+        method: "PATCH",
+        body: sanitizedUpstreamBody({ status, response_notes, add_note, resolution, pr_url }, "support-inbox:triage_review")
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+
+export {
+  registerListBugReports,
+  registerGetBugReport,
+  registerAddBugReportComment,
+  registerGetBugReportComments,
+  registerTriageBugReport,
+  registerListFeatureRequests,
+  registerGetFeatureRequest,
+  registerTriageFeatureRequest,
+  registerListReviews,
+  registerGetReview,
+  registerTriageReview
+};

package/dist/{chunk-B76TSEP3.js → chunk-I26FWCSP.js}

@@ -1,12 +1,73 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-FUIIVSW6.js";
+} from "./chunk-2WAVZ5UJ.js";
 
 // src/lib/worktree.ts
-import { execSync } from "child_process";
-import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import { execFile, execSync } from "child_process";
+import { promisify } from "util";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync, statSync } from "fs";
 import path from "path";
 var GIT_TIMEOUT_MS = 1e4;
+var execFileAsync = promisify(execFile);
+async function gitAsync(args, cwd) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS
+  });
+  return String(stdout ?? "");
+}
+function classifyGitFailure(err) {
+  if (!err || typeof err !== "object") return "unavailable";
+  const e = err;
+  if (e.killed === true) return "unavailable";
+  if (typeof e.signal === "string" && e.signal.length > 0) return "unavailable";
+  if (e.code === "ETIMEDOUT" || e.code === "ENOENT") return "unavailable";
+  if (typeof e.status === "number") return "definitive";
+  if (typeof e.code === "number") return "definitive";
+  return "unavailable";
+}
+async function resolveGitWithRetryAsync(run) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await run();
+    } catch (err) {
+      if (classifyGitFailure(err) === "definitive") return null;
+      if (attempt >= 1) return null;
+    }
+  }
+}
+function resolveGitWithRetrySync(run) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return run();
+    } catch (err) {
+      if (classifyGitFailure(err) === "definitive") return null;
+      if (attempt >= 1) return null;
+    }
+  }
+}
+function isInsideGitRepo(dir) {
+  let cur;
+  try {
+    cur = path.resolve(dir);
+  } catch {
+    return false;
+  }
+  for (let i = 0; i < 128; i++) {
+    try {
+      statSync(path.join(cur, ".git"));
+      return true;
+    } catch (err) {
+      const code = err?.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return true;
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return false;
+}
 function getGitRoot(dir) {
   try {
     const root = execSync("git rev-parse --show-toplevel", {
@@ -20,17 +81,31 @@ function getGitRoot(dir) {
     return null;
   }
 }
-function getMainRepoRoot(dir) {
+async function getGitRootAsync(dir) {
   try {
-    const commonDir = execSync(
-      "git rev-parse --path-format=absolute --git-common-dir",
-      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    return realpath(path.dirname(commonDir));
+    const root = (await gitAsync(["rev-parse", "--show-toplevel"], dir)).trim();
+    return realpath(root);
   } catch {
     return null;
   }
 }
+function getMainRepoRoot(dir) {
+  const commonDir = resolveGitWithRetrySync(
+    () => execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim()
+  );
+  if (commonDir == null) return null;
+  return realpath(path.dirname(commonDir));
+}
+async function getMainRepoRootAsync(dir) {
+  const commonDir = await resolveGitWithRetryAsync(
+    async () => (await gitAsync(["rev-parse", "--path-format=absolute", "--git-common-dir"], dir)).trim()
+  );
+  if (commonDir == null) return null;
+  return realpath(path.dirname(commonDir));
+}
 function worktreePath(repoRoot, employeeName, instance) {
   const label = instanceLabel(employeeName, instance);
   return path.join(repoRoot, ".worktrees", label);
@@ -165,6 +240,107 @@ function ensureWorktree(projectDir, employeeName, instance) {
     return null;
   }
 }
+async function ensureWorktreeAsync(projectDir, employeeName, instance) {
+  const repoRoot = await getMainRepoRootAsync(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    const currentBranch = await getWorktreeCurrentBranchAsync(wtPath);
+    if (currentBranch !== branch) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.branch_mismatch",
+        source: "worktree.ensureWorktreeAsync",
+        severity: "warn",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { expectedBranch: branch, actualBranch: currentBranch }
+      });
+      if (await isWorktreeDirtyAsync(wtPath)) {
+        process.stderr.write(
+          `[worktree] Refusing to reuse ${wtPath}: expected branch ${branch}, found ${currentBranch ?? "unknown"} with uncommitted changes
+`
+        );
+        return null;
+      }
+      try {
+        await gitAsync(["worktree", "remove", wtPath], repoRoot);
+      } catch (err) {
+        process.stderr.write(
+          `[worktree] Failed to repair branch mismatch for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+        return null;
+      }
+    } else {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.reused",
+        source: "worktree.ensureWorktreeAsync",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { branch }
+      });
+      return wtPath;
+    }
+  }
+  if (existsSync(path.join(wtPath, ".git")) && await getWorktreeCurrentBranchAsync(wtPath) === branch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktreeAsync",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  mkdirSync(path.join(repoRoot, ".worktrees"), { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    await gitAsync(["worktree", "prune"], repoRoot);
+  } catch {
+  }
+  const branchExists = await branchExistsLocallyAsync(repoRoot, branch);
+  try {
+    if (branchExists) {
+      await gitAsync(["worktree", "add", wtPath, branch], repoRoot);
+    } else {
+      await gitAsync(["worktree", "add", wtPath, "-b", branch, "HEAD"], repoRoot);
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktreeAsync",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    if (existsSync(path.join(wtPath, ".git")) && await getWorktreeCurrentBranchAsync(wtPath) === branch) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.reused",
+        source: "worktree.ensureWorktreeAsync",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { branch, raced: true }
+      });
+      return wtPath;
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktreeAsync",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
 function isWorktreeDirty(wtPath) {
   try {
     const status = execSync("git status --porcelain", {
@@ -178,6 +354,13 @@ function isWorktreeDirty(wtPath) {
     return true;
   }
 }
+async function isWorktreeDirtyAsync(wtPath) {
+  try {
+    return (await gitAsync(["status", "--porcelain"], wtPath)).trim().length > 0;
+  } catch {
+    return true;
+  }
+}
 function cleanupWorktree(projectDir, employeeName, instance) {
   const repoRoot = getMainRepoRoot(projectDir);
   if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
@@ -277,6 +460,14 @@ function branchExistsLocally(repoRoot, branch) {
     return false;
   }
 }
+async function branchExistsLocallyAsync(repoRoot, branch) {
+  try {
+    await gitAsync(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getWorktreeCurrentBranch(wtPath) {
   try {
     const branch = execSync("git branch --show-current", {
@@ -290,6 +481,14 @@ function getWorktreeCurrentBranch(wtPath) {
     return null;
   }
 }
+async function getWorktreeCurrentBranchAsync(wtPath) {
+  try {
+    const branch = (await gitAsync(["branch", "--show-current"], wtPath)).trim();
+    return branch.length > 0 ? branch : null;
+  } catch {
+    return null;
+  }
+}
 function detectMainBranch(repoRoot) {
   for (const candidate of ["main", "master"]) {
     if (branchExistsLocally(repoRoot, candidate)) return candidate;
@@ -333,12 +532,20 @@ ${entry}
 }
 
 export {
+  classifyGitFailure,
+  resolveGitWithRetryAsync,
+  resolveGitWithRetrySync,
+  isInsideGitRepo,
   getGitRoot,
+  getGitRootAsync,
   getMainRepoRoot,
+  getMainRepoRootAsync,
   worktreePath,
   worktreeBranch,
   parseInstanceLabel,
   ensureWorktree,
+  ensureWorktreeAsync,
   isWorktreeDirty,
+  isWorktreeDirtyAsync,
   cleanupWorktree
 };

package/dist/{chunk-X2FHTDIU.js → chunk-IBYL4DHM.js}

@@ -1,6 +1,6 @@
 import {
   atomicWriteJsonSync
-} from "./chunk-SHIICYJW.js";
+} from "./chunk-BYTDMAGB.js";
 
 // src/lib/mcp-port-config.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-JCBKARSK.js → chunk-IOEUAQWP.js}

@@ -1,6 +1,6 @@
 import {
   getMasterKey
-} from "./chunk-Z42MXYWW.js";
+} from "./chunk-QWVXN224.js";
 
 // src/lib/monitor-identity.ts
 import crypto from "crypto";