@kibitzsh/kibitz 0.0.3 → 0.0.4

package/dist/core/session-dispatch.js

@@ -1,453 +1,441 @@
 "use strict";
-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
-});
-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;
+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]; } };
     }
-    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;
+    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 __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;
     }
-    this.emitStatus("queued", request.target, `Queued for ${describeTarget(request.target)}`);
-    if (request.target.kind === "existing") {
-      await this.dispatchExistingSession(request.target, prompt);
-      return;
+    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 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");
+    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));
         }
-        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));
     }
-  }
-  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;
+    emitStatus(state, target, message) {
+        const status = {
+            state,
+            message,
+            target,
+            timestamp: Date.now(),
+        };
+        this.emit('status', status);
     }
-    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;
+}
+exports.SessionDispatchService = SessionDispatchService;
+function buildExistingDispatchCommand(target, prompt, platform = process.platform) {
+    if (target.kind !== 'existing') {
+        throw new Error(`Expected existing target, got "${target.kind}"`);
     }
-    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));
+    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: 'codex',
+            command: (0, platform_support_1.getProviderCliCommand)('codex', platform),
+            args: ['exec', 'resume', '--json', '--skip-git-repo-check', sessionId, prompt],
+        };
     }
-  }
-  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: "codex",
-      command: getProviderCliCommand("codex", platform),
-      args: ["exec", "resume", "--json", "--skip-git-repo-check", sessionId, prompt]
+        provider: 'claude',
+        command: (0, platform_support_1.getProviderCliCommand)('claude', platform),
+        args: ['-p', prompt, '--verbose', '--output-format', 'stream-json', '--resume', sessionId],
     };
-  }
-  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: getProviderCliCommand(provider, platform),
-    args: [prompt]
-  };
+    return {
+        provider,
+        command: (0, platform_support_1.getProviderCliCommand)(provider, platform),
+        args: [prompt],
+    };
 }
 function resolveDispatchCommand(command, platform = process.platform) {
-  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
-      };
+    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,
+            };
+        }
     }
-    if (pathHint.toLowerCase().endsWith(".cmd")) {
-      return {
+    return {
         command: pathHint,
         args: command.args,
-        shell: true
-      };
-    }
-  }
-  return {
-    command: pathHint,
-    args: command.args,
-    shell: false
-  };
+        shell: false,
+    };
 }
 async function waitForDispatchAcknowledgement(filePath, prompt, before, completion) {
-  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 } : {}
+    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 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;
+    while (true) {
+        if (completionState === 2) {
+            throw completionError || new Error('Dispatch failed');
         }
-        rejectCompletion(error);
-      });
-      child.on("close", (code) => {
-        if (code === 0) {
-          resolveCompletion();
-          return;
+        if (hasSessionUpdateWithPrompt(filePath, prompt, before)) {
+            return 'prompt-observed';
         }
-        const normalized = String(stderr || "").trim();
-        if (looksLikeUnsupportedFlags(normalized)) {
-          rejectCompletion(new Error("Provider CLI does not support required resume flags. Update the CLI version."));
-          return;
+        if (completionState === 1) {
+            return 'process-complete';
         }
-        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 });
+        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 });
+        });
     });
-  });
 }
 async function runInteractiveInTerminal(provider, prompt) {
-  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
+    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}`));
+        });
     });
-    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} \u203A ${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} › ${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 = fs2.statSync(filePath);
-    return {
-      exists: true,
-      size: stat.size,
-      mtimeMs: stat.mtimeMs
-    };
-  } catch {
-    return {
-      exists: false,
-      size: 0,
-      mtimeMs: 0
-    };
-  }
+    try {
+        const stat = fs.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 buf = Buffer.alloc(length);
-      fs2.readSync(fd, buf, 0, length, desiredStart);
-      return buf.toString("utf8");
-    } finally {
-      fs2.closeSync(fd);
+        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 '';
     }
-  } 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 void 0;
-  return decodeClaudeProjectPathFromSessionFile(session.filePath);
+    if (session.agent !== 'claude')
+        return undefined;
+    return decodeClaudeProjectPathFromSessionFile(session.filePath);
 }
 function decodeClaudeProjectPathFromSessionFile(filePath) {
-  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;
+    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;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SessionDispatchService,
-  buildExistingDispatchCommand,
-  buildInteractiveDispatchCommand,
-  resolveDispatchCommand
-});
+//# sourceMappingURL=session-dispatch.js.map