@kibitzsh/kibitz 0.0.4 → 0.0.6

package/dist/core/session-dispatch.js

@@ -1,441 +1,453 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/session-dispatch.ts
+var session_dispatch_exports = {};
+__export(session_dispatch_exports, {
+  SessionDispatchService: () => SessionDispatchService,
+  buildExistingDispatchCommand: () => buildExistingDispatchCommand,
+  buildInteractiveDispatchCommand: () => buildInteractiveDispatchCommand,
+  resolveDispatchCommand: () => resolveDispatchCommand
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionDispatchService = void 0;
-exports.buildExistingDispatchCommand = buildExistingDispatchCommand;
-exports.buildInteractiveDispatchCommand = buildInteractiveDispatchCommand;
-exports.resolveDispatchCommand = resolveDispatchCommand;
-const events_1 = require("events");
-const child_process_1 = require("child_process");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const platform_support_1 = require("./platform-support");
-class SessionDispatchService extends events_1.EventEmitter {
-    options;
-    constructor(options) {
-        super();
-        this.options = options;
+module.exports = __toCommonJS(session_dispatch_exports);
+var import_events = require("events");
+var import_child_process2 = require("child_process");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/core/platform-support.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function getProviderCliCommand(provider, platform = process.platform) {
+  return platform === "win32" ? `${provider}.cmd` : provider;
+}
+function resolveCmdNodeScript(cmdPath) {
+  if (!String(cmdPath || "").toLowerCase().endsWith(".cmd")) return null;
+  try {
+    const content = fs.readFileSync(cmdPath, "utf8");
+    const match = content.match(/%dp0%\\(.+?\.js)/i);
+    if (!match) return null;
+    const scriptPath = path.join(path.dirname(cmdPath), match[1]);
+    return fs.existsSync(scriptPath) ? scriptPath : null;
+  } catch {
+    return null;
+  }
+}
+function findCommandPath(command, platform = process.platform) {
+  try {
+    if (platform === "win32") {
+      const out2 = (0, import_child_process.execSync)(`where ${command}`, {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const first = out2.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+      return first || void 0;
     }
-    async dispatch(request) {
-        const prompt = String(request.prompt || '').trim();
-        if (!prompt) {
-            this.emitStatus('failed', request.target, 'Prompt cannot be empty');
-            return;
-        }
-        this.emitStatus('queued', request.target, `Queued for ${describeTarget(request.target)}`);
-        if (request.target.kind === 'existing') {
-            await this.dispatchExistingSession(request.target, prompt);
-            return;
-        }
-        const provider = request.target.kind === 'new-codex' ? 'codex' : 'claude';
-        this.emitStatus('started', request.target, `Starting new ${provider} session`);
-        try {
-            if (request.origin === 'vscode') {
-                if (!this.options.launchInteractiveSession) {
-                    throw new Error('Interactive launcher is not available in VS Code mode');
-                }
-                await this.options.launchInteractiveSession(provider, prompt);
-            }
-            else {
-                await runInteractiveInTerminal(provider, prompt);
-            }
-            this.emitStatus('sent', request.target, `Started new ${provider} session`);
-        }
-        catch (error) {
-            this.emitStatus('failed', request.target, normalizeError(error));
-        }
+    const out = (0, import_child_process.execFileSync)("which", [command], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/session-dispatch.ts
+var SessionDispatchService = class extends import_events.EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async dispatch(request) {
+    const prompt = String(request.prompt || "").trim();
+    if (!prompt) {
+      this.emitStatus("failed", request.target, "Prompt cannot be empty");
+      return;
     }
-    async dispatchExistingSession(target, prompt) {
-        const targetSessionId = String(target.sessionId || '').trim().toLowerCase();
-        const targetAgent = target.agent;
-        if (!targetSessionId || (targetAgent !== 'claude' && targetAgent !== 'codex')) {
-            this.emitStatus('failed', target, 'Missing target session or provider');
-            return;
-        }
-        const active = this.options.getActiveSessions();
-        const activeMatch = active.find((session) => {
-            return session.agent === targetAgent && session.id.toLowerCase() === targetSessionId;
-        });
-        if (!activeMatch) {
-            this.emitStatus('failed', target, `Selected ${describeProvider(targetAgent)} session is not active`);
-            return;
-        }
-        const targetLabel = describeTarget(target);
-        this.emitStatus('started', target, `Dispatching to ${targetLabel}`);
-        try {
-            const command = buildExistingDispatchCommand(target, prompt);
-            const dispatchCwd = deriveDispatchCwdForSession(activeMatch);
-            const beforeDispatch = captureSessionFileSnapshot(activeMatch.filePath);
-            const handle = await startBackgroundCommand(command, { cwd: dispatchCwd });
-            const dispatchOutcome = await runWithTimeout(waitForDispatchAcknowledgement(activeMatch.filePath, prompt, beforeDispatch, handle.completion), 20_000, 'Dispatch timed out waiting for target session update');
-            // If process exited before prompt was observed, enforce full verification.
-            if (dispatchOutcome === 'process-complete') {
-                verifyExistingDispatchDelivery(activeMatch.filePath, prompt, beforeDispatch);
-            }
-            // Keep completion promise observed to avoid unhandled rejections after early ack.
-            void handle.completion.catch(() => undefined);
-            this.emitStatus('sent', target, `Prompt sent to ${targetLabel}`);
-        }
-        catch (error) {
-            this.emitStatus('failed', target, normalizeError(error));
-        }
+    this.emitStatus("queued", request.target, `Queued for ${describeTarget(request.target)}`);
+    if (request.target.kind === "existing") {
+      await this.dispatchExistingSession(request.target, prompt);
+      return;
     }
-    emitStatus(state, target, message) {
-        const status = {
-            state,
-            message,
-            target,
-            timestamp: Date.now(),
-        };
-        this.emit('status', status);
+    const provider = request.target.kind === "new-codex" ? "codex" : "claude";
+    this.emitStatus("started", request.target, `Starting new ${provider} session`);
+    try {
+      if (request.origin === "vscode") {
+        if (!this.options.launchInteractiveSession) {
+          throw new Error("Interactive launcher is not available in VS Code mode");
+        }
+        await this.options.launchInteractiveSession(provider, prompt);
+      } else {
+        await runInteractiveInTerminal(provider, prompt);
+      }
+      this.emitStatus("sent", request.target, `Started new ${provider} session`);
+    } catch (error) {
+      this.emitStatus("failed", request.target, normalizeError(error));
     }
-}
-exports.SessionDispatchService = SessionDispatchService;
-function buildExistingDispatchCommand(target, prompt, platform = process.platform) {
-    if (target.kind !== 'existing') {
-        throw new Error(`Expected existing target, got "${target.kind}"`);
+  }
+  async dispatchExistingSession(target, prompt) {
+    const targetSessionId = String(target.sessionId || "").trim().toLowerCase();
+    const targetAgent = target.agent;
+    if (!targetSessionId || targetAgent !== "claude" && targetAgent !== "codex") {
+      this.emitStatus("failed", target, "Missing target session or provider");
+      return;
     }
-    const sessionId = String(target.sessionId || '').trim();
-    const agent = target.agent;
-    if (!sessionId || (agent !== 'claude' && agent !== 'codex')) {
-        throw new Error('Missing existing-session target details');
+    const active = this.options.getActiveSessions();
+    const activeMatch = active.find((session) => {
+      return session.agent === targetAgent && session.id.toLowerCase() === targetSessionId;
+    });
+    if (!activeMatch) {
+      this.emitStatus("failed", target, `Selected ${describeProvider(targetAgent)} session is not active`);
+      return;
     }
-    if (agent === 'codex') {
-        return {
-            provider: 'codex',
-            command: (0, platform_support_1.getProviderCliCommand)('codex', platform),
-            args: ['exec', 'resume', '--json', '--skip-git-repo-check', sessionId, prompt],
-        };
+    const targetLabel = describeTarget(target);
+    this.emitStatus("started", target, `Dispatching to ${targetLabel}`);
+    try {
+      const command = buildExistingDispatchCommand(target, prompt);
+      const dispatchCwd = deriveDispatchCwdForSession(activeMatch);
+      const beforeDispatch = captureSessionFileSnapshot(activeMatch.filePath);
+      const handle = await startBackgroundCommand(command, { cwd: dispatchCwd });
+      const dispatchOutcome = await runWithTimeout(
+        waitForDispatchAcknowledgement(
+          activeMatch.filePath,
+          prompt,
+          beforeDispatch,
+          handle.completion
+        ),
+        2e4,
+        "Dispatch timed out waiting for target session update"
+      );
+      if (dispatchOutcome === "process-complete") {
+        verifyExistingDispatchDelivery(activeMatch.filePath, prompt, beforeDispatch);
+      }
+      void handle.completion.catch(() => void 0);
+      this.emitStatus("sent", target, `Prompt sent to ${targetLabel}`);
+    } catch (error) {
+      this.emitStatus("failed", target, normalizeError(error));
     }
+  }
+  emitStatus(state, target, message) {
+    const status = {
+      state,
+      message,
+      target,
+      timestamp: Date.now()
+    };
+    this.emit("status", status);
+  }
+};
+function buildExistingDispatchCommand(target, prompt, platform = process.platform) {
+  if (target.kind !== "existing") {
+    throw new Error(`Expected existing target, got "${target.kind}"`);
+  }
+  const sessionId = String(target.sessionId || "").trim();
+  const agent = target.agent;
+  if (!sessionId || agent !== "claude" && agent !== "codex") {
+    throw new Error("Missing existing-session target details");
+  }
+  if (agent === "codex") {
     return {
-        provider: 'claude',
-        command: (0, platform_support_1.getProviderCliCommand)('claude', platform),
-        args: ['-p', prompt, '--verbose', '--output-format', 'stream-json', '--resume', sessionId],
+      provider: "codex",
+      command: getProviderCliCommand("codex", platform),
+      args: ["exec", "resume", "--json", "--skip-git-repo-check", sessionId, prompt]
     };
+  }
+  return {
+    provider: "claude",
+    command: getProviderCliCommand("claude", platform),
+    args: ["-p", prompt, "--verbose", "--output-format", "stream-json", "--resume", sessionId]
+  };
 }
 function buildInteractiveDispatchCommand(provider, prompt, platform = process.platform) {
-    return {
-        provider,
-        command: (0, platform_support_1.getProviderCliCommand)(provider, platform),
-        args: [prompt],
-    };
+  return {
+    provider,
+    command: getProviderCliCommand(provider, platform),
+    args: [prompt]
+  };
 }
 function resolveDispatchCommand(command, platform = process.platform) {
-    const pathHint = (0, platform_support_1.findCommandPath)(command.command, platform);
-    if (!pathHint) {
-        throw new Error(`CLI not found: ${command.command}`);
-    }
-    if (platform === 'win32') {
-        const nodeScript = (0, platform_support_1.resolveCmdNodeScript)(pathHint);
-        if (nodeScript) {
-            return {
-                command: process.execPath,
-                args: [nodeScript, ...command.args],
-                shell: false,
-            };
-        }
-        if (pathHint.toLowerCase().endsWith('.cmd')) {
-            return {
-                command: pathHint,
-                args: command.args,
-                shell: true,
-            };
-        }
+  const pathHint = findCommandPath(command.command, platform);
+  if (!pathHint) {
+    throw new Error(`CLI not found: ${command.command}`);
+  }
+  if (platform === "win32") {
+    const nodeScript = resolveCmdNodeScript(pathHint);
+    if (nodeScript) {
+      return {
+        command: process.execPath,
+        args: [nodeScript, ...command.args],
+        shell: false
+      };
     }
-    return {
+    if (pathHint.toLowerCase().endsWith(".cmd")) {
+      return {
         command: pathHint,
         args: command.args,
-        shell: false,
-    };
+        shell: true
+      };
+    }
+  }
+  return {
+    command: pathHint,
+    args: command.args,
+    shell: false
+  };
 }
 async function waitForDispatchAcknowledgement(filePath, prompt, before, completion) {
-    let completionState = 0; // 0: running, 1: success, 2: failed
-    let completionError = null;
-    completion.then(() => {
-        completionState = 1;
-    }).catch((error) => {
-        completionState = 2;
-        completionError = error instanceof Error ? error : new Error(String(error || 'Dispatch failed'));
+  let completionState = 0;
+  let completionError = null;
+  completion.then(() => {
+    completionState = 1;
+  }).catch((error) => {
+    completionState = 2;
+    completionError = error instanceof Error ? error : new Error(String(error || "Dispatch failed"));
+  });
+  while (true) {
+    if (completionState === 2) {
+      throw completionError || new Error("Dispatch failed");
+    }
+    if (hasSessionUpdateWithPrompt(filePath, prompt, before)) {
+      return "prompt-observed";
+    }
+    if (completionState === 1) {
+      return "process-complete";
+    }
+    await sleepMs(120);
+  }
+}
+async function startBackgroundCommand(command, options = {}) {
+  const resolved = resolveDispatchCommand(command);
+  return await new Promise((resolve, reject) => {
+    const child = (0, import_child_process2.spawn)(resolved.command, resolved.args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      shell: resolved.shell,
+      windowsHide: true,
+      ...options.cwd ? { cwd: options.cwd } : {}
     });
-    while (true) {
-        if (completionState === 2) {
-            throw completionError || new Error('Dispatch failed');
+    let stderr = "";
+    let spawned = false;
+    let launchSettled = false;
+    const failLaunch = (error) => {
+      if (launchSettled) return;
+      launchSettled = true;
+      reject(error);
+    };
+    const completion = new Promise((resolveCompletion, rejectCompletion) => {
+      child.on("error", (error) => {
+        if (!spawned) {
+          failLaunch(error);
+          return;
         }
-        if (hasSessionUpdateWithPrompt(filePath, prompt, before)) {
-            return 'prompt-observed';
+        rejectCompletion(error);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolveCompletion();
+          return;
         }
-        if (completionState === 1) {
-            return 'process-complete';
+        const normalized = String(stderr || "").trim();
+        if (looksLikeUnsupportedFlags(normalized)) {
+          rejectCompletion(new Error("Provider CLI does not support required resume flags. Update the CLI version."));
+          return;
         }
-        await sleepMs(120);
-    }
-}
-async function startBackgroundCommand(command, options = {}) {
-    const resolved = resolveDispatchCommand(command);
-    return await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(resolved.command, resolved.args, {
-            stdio: ['ignore', 'ignore', 'pipe'],
-            shell: resolved.shell,
-            windowsHide: true,
-            ...(options.cwd ? { cwd: options.cwd } : {}),
-        });
-        let stderr = '';
-        let spawned = false;
-        let launchSettled = false;
-        const failLaunch = (error) => {
-            if (launchSettled)
-                return;
-            launchSettled = true;
-            reject(error);
-        };
-        const completion = new Promise((resolveCompletion, rejectCompletion) => {
-            child.on('error', (error) => {
-                if (!spawned) {
-                    failLaunch(error);
-                    return;
-                }
-                rejectCompletion(error);
-            });
-            child.on('close', (code) => {
-                if (code === 0) {
-                    resolveCompletion();
-                    return;
-                }
-                const normalized = String(stderr || '').trim();
-                if (looksLikeUnsupportedFlags(normalized)) {
-                    rejectCompletion(new Error('Provider CLI does not support required resume flags. Update the CLI version.'));
-                    return;
-                }
-                rejectCompletion(new Error(normalized || `Dispatch exited with code ${code}`));
-            });
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('spawn', () => {
-            spawned = true;
-            if (launchSettled)
-                return;
-            launchSettled = true;
-            resolve({ completion });
-        });
+        rejectCompletion(new Error(normalized || `Dispatch exited with code ${code}`));
+      });
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("spawn", () => {
+      spawned = true;
+      if (launchSettled) return;
+      launchSettled = true;
+      resolve({ completion });
     });
+  });
 }
 async function runInteractiveInTerminal(provider, prompt) {
-    const command = buildInteractiveDispatchCommand(provider, prompt);
-    const resolved = resolveDispatchCommand(command);
-    await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(resolved.command, resolved.args, {
-            stdio: 'inherit',
-            shell: resolved.shell,
-            windowsHide: false,
-        });
-        child.on('error', (error) => reject(error));
-        child.on('close', (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Interactive session exited with code ${code}`));
-        });
+  const command = buildInteractiveDispatchCommand(provider, prompt);
+  const resolved = resolveDispatchCommand(command);
+  await new Promise((resolve, reject) => {
+    const child = (0, import_child_process2.spawn)(resolved.command, resolved.args, {
+      stdio: "inherit",
+      shell: resolved.shell,
+      windowsHide: false
     });
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Interactive session exited with code ${code}`));
+    });
+  });
 }
 function describeTarget(target) {
-    if (target.kind === 'new-codex')
-        return 'new codex session';
-    if (target.kind === 'new-claude')
-        return 'new claude session';
-    const provider = describeProvider(target.agent);
-    const project = cleanTargetLabel(target.projectName, 24);
-    const sessionTitle = cleanTargetLabel(target.sessionTitle, 44);
-    if (project && sessionTitle)
-        return `${provider} session (${project} › ${sessionTitle})`;
-    if (sessionTitle)
-        return `${provider} session (${sessionTitle})`;
-    if (project)
-        return `${provider} session (${project})`;
-    return `${provider} session`;
+  if (target.kind === "new-codex") return "new codex session";
+  if (target.kind === "new-claude") return "new claude session";
+  const provider = describeProvider(target.agent);
+  const project = cleanTargetLabel(target.projectName, 24);
+  const sessionTitle = cleanTargetLabel(target.sessionTitle, 44);
+  if (project && sessionTitle) return `${provider} session (${project} \u203A ${sessionTitle})`;
+  if (sessionTitle) return `${provider} session (${sessionTitle})`;
+  if (project) return `${provider} session (${project})`;
+  return `${provider} session`;
 }
 function describeProvider(agent) {
-    return String(agent || '').toLowerCase() === 'claude' ? 'Claude' : 'Codex';
+  return String(agent || "").toLowerCase() === "claude" ? "Claude" : "Codex";
 }
 function cleanTargetLabel(value, max) {
-    const text = String(value || '').replace(/\s+/g, ' ').trim();
-    if (!text)
-        return '';
-    if (/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(text))
-        return '';
-    if (text.length <= max)
-        return text;
-    if (max <= 3)
-        return text.slice(0, max);
-    return `${text.slice(0, max - 3).trimEnd()}...`;
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(text)) return "";
+  if (text.length <= max) return text;
+  if (max <= 3) return text.slice(0, max);
+  return `${text.slice(0, max - 3).trimEnd()}...`;
 }
 function looksLikeUnsupportedFlags(stderr) {
-    const normalized = String(stderr || '').toLowerCase();
-    if (!normalized)
-        return false;
-    return normalized.includes('unknown option')
-        || normalized.includes('unknown flag')
-        || normalized.includes('unrecognized option')
-        || normalized.includes('did you mean');
+  const normalized = String(stderr || "").toLowerCase();
+  if (!normalized) return false;
+  return normalized.includes("unknown option") || normalized.includes("unknown flag") || normalized.includes("unrecognized option") || normalized.includes("did you mean");
 }
 function normalizeError(error) {
-    if (error instanceof Error && error.message)
-        return error.message;
-    return String(error || 'Dispatch failed');
+  if (error instanceof Error && error.message) return error.message;
+  return String(error || "Dispatch failed");
 }
 function captureSessionFileSnapshot(filePath) {
-    try {
-        const stat = fs.statSync(filePath);
-        return {
-            exists: true,
-            size: stat.size,
-            mtimeMs: stat.mtimeMs,
-        };
-    }
-    catch {
-        return {
-            exists: false,
-            size: 0,
-            mtimeMs: 0,
-        };
-    }
+  try {
+    const stat = fs2.statSync(filePath);
+    return {
+      exists: true,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return {
+      exists: false,
+      size: 0,
+      mtimeMs: 0
+    };
+  }
 }
 function verifyExistingDispatchDelivery(filePath, prompt, before) {
-    if (!hasSessionFileChanged(filePath, before)) {
-        throw new Error('Target session did not update after dispatch');
-    }
-    const promptSignature = firstPromptSignature(prompt);
-    if (promptSignature.length < 4)
-        return;
-    const tail = readSessionTailSinceOffset(filePath, before.size);
-    if (!tail) {
-        throw new Error('Target session updated but prompt text was not found');
-    }
-    if (!tail.toLowerCase().includes(promptSignature.toLowerCase())) {
-        throw new Error('Prompt text was not found in target session update');
-    }
+  if (!hasSessionFileChanged(filePath, before)) {
+    throw new Error("Target session did not update after dispatch");
+  }
+  const promptSignature = firstPromptSignature(prompt);
+  if (promptSignature.length < 4) return;
+  const tail = readSessionTailSinceOffset(filePath, before.size);
+  if (!tail) {
+    throw new Error("Target session updated but prompt text was not found");
+  }
+  if (!tail.toLowerCase().includes(promptSignature.toLowerCase())) {
+    throw new Error("Prompt text was not found in target session update");
+  }
 }
 function hasSessionUpdateWithPrompt(filePath, prompt, before) {
-    if (!hasSessionFileChanged(filePath, before))
-        return false;
-    const promptSignature = firstPromptSignature(prompt);
-    if (promptSignature.length < 4)
-        return true;
-    const tail = readSessionTailSinceOffset(filePath, before.size);
-    if (!tail)
-        return false;
-    return tail.toLowerCase().includes(promptSignature.toLowerCase());
+  if (!hasSessionFileChanged(filePath, before)) return false;
+  const promptSignature = firstPromptSignature(prompt);
+  if (promptSignature.length < 4) return true;
+  const tail = readSessionTailSinceOffset(filePath, before.size);
+  if (!tail) return false;
+  return tail.toLowerCase().includes(promptSignature.toLowerCase());
 }
 function hasSessionFileChanged(filePath, before) {
-    const after = captureSessionFileSnapshot(filePath);
-    if (!after.exists) {
-        throw new Error('Target session file is not accessible after dispatch');
-    }
-    return after.size > before.size || after.mtimeMs > before.mtimeMs;
+  const after = captureSessionFileSnapshot(filePath);
+  if (!after.exists) {
+    throw new Error("Target session file is not accessible after dispatch");
+  }
+  return after.size > before.size || after.mtimeMs > before.mtimeMs;
 }
 function firstPromptSignature(prompt) {
-    const lines = String(prompt || '')
-        .split(/\r?\n/g)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const first = lines[0] || String(prompt || '').trim();
-    return first.slice(0, 160);
+  const lines = String(prompt || "").split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
+  const first = lines[0] || String(prompt || "").trim();
+  return first.slice(0, 160);
 }
 function readSessionTailSinceOffset(filePath, previousSize) {
+  try {
+    const stat = fs2.statSync(filePath);
+    const maxBytes = 1024 * 512;
+    const start = Math.max(0, previousSize - 2048);
+    const desiredStart = stat.size - start > maxBytes ? Math.max(0, stat.size - maxBytes) : start;
+    const length = Math.max(0, stat.size - desiredStart);
+    if (length === 0) return "";
+    const fd = fs2.openSync(filePath, "r");
     try {
-        const stat = fs.statSync(filePath);
-        const maxBytes = 1024 * 512;
-        const start = Math.max(0, previousSize - 2048);
-        const desiredStart = stat.size - start > maxBytes
-            ? Math.max(0, stat.size - maxBytes)
-            : start;
-        const length = Math.max(0, stat.size - desiredStart);
-        if (length === 0)
-            return '';
-        const fd = fs.openSync(filePath, 'r');
-        try {
-            const buf = Buffer.alloc(length);
-            fs.readSync(fd, buf, 0, length, desiredStart);
-            return buf.toString('utf8');
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-    }
-    catch {
-        return '';
+      const buf = Buffer.alloc(length);
+      fs2.readSync(fd, buf, 0, length, desiredStart);
+      return buf.toString("utf8");
+    } finally {
+      fs2.closeSync(fd);
     }
+  } catch {
+    return "";
+  }
 }
 async function runWithTimeout(promise, timeoutMs, message) {
-    return await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }).catch((error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
+  return await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
     });
+  });
 }
 async function sleepMs(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 function deriveDispatchCwdForSession(session) {
-    if (session.agent !== 'claude')
-        return undefined;
-    return decodeClaudeProjectPathFromSessionFile(session.filePath);
+  if (session.agent !== "claude") return void 0;
+  return decodeClaudeProjectPathFromSessionFile(session.filePath);
 }
 function decodeClaudeProjectPathFromSessionFile(filePath) {
-    if (!filePath)
-        return undefined;
-    const projectDir = path.basename(path.dirname(filePath));
-    if (!projectDir)
-        return undefined;
-    const parts = projectDir.split('-').filter(Boolean);
-    if (parts.length === 0)
-        return undefined;
-    if (parts.length >= 2 && /^[A-Za-z]$/.test(parts[0])) {
-        const windowsPath = `${parts[0]}:\\${parts.slice(1).join('\\')}`;
-        if (fs.existsSync(windowsPath))
-            return windowsPath;
-    }
-    const unixPath = `/${parts.join('/')}`;
-    if (fs.existsSync(unixPath))
-        return unixPath;
-    return undefined;
+  if (!filePath) return void 0;
+  const projectDir = path2.basename(path2.dirname(filePath));
+  if (!projectDir) return void 0;
+  const parts = projectDir.split("-").filter(Boolean);
+  if (parts.length === 0) return void 0;
+  if (parts.length >= 2 && /^[A-Za-z]$/.test(parts[0])) {
+    const windowsPath = `${parts[0]}:\\${parts.slice(1).join("\\")}`;
+    if (fs2.existsSync(windowsPath)) return windowsPath;
+  }
+  const unixPath = `/${parts.join("/")}`;
+  if (fs2.existsSync(unixPath)) return unixPath;
+  return void 0;
 }
-//# sourceMappingURL=session-dispatch.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionDispatchService,
+  buildExistingDispatchCommand,
+  buildInteractiveDispatchCommand,
+  resolveDispatchCommand
+});