@poetic-ai/poetic 1.42.0

package/dist/chunk-WZ6U3O7I.js

@@ -0,0 +1,1581 @@
+import {
+  killTmuxSessionWithPaneFallback,
+  markTmuxSessionOrphaned,
+  recordTmuxSessionPanePid,
+  registerTmuxSession,
+  unregisterTmuxSession
+} from "./chunk-4CUY7AFY.js";
+import {
+  CircuitBreakerError,
+  createCircuitBreakerOptions,
+  executeWithCircuitBreaker
+} from "./chunk-MWK5UZQ3.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  DEFAULT_TIMEOUT,
+  POETIC_PROCESS_GROUP_OWNER_ENV,
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  acquireProcessSlot,
+  assertProviderBypassHasBoundaryProof,
+  createLogger,
+  getProcessLifecycleManager,
+  globalProcessLimiter,
+  providerExecutionTransportStreamOptions,
+  resolveProviderProcessGroupOwnership
+} from "./chunk-PFTQBXS6.js";
+import {
+  evaluateCpuTimeProgressStreak,
+  readCpuTimeSeconds,
+  resolveIdleTimeoutsMs
+} from "./chunk-E3NTPHEO.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-FC23CTXV.js";
+import {
+  createRetryOptions,
+  withRetry
+} from "./chunk-CKNX3TTP.js";
+import {
+  ModelInvocationsDB,
+  ensurePendingInvocationCostEnrichment,
+  generateInvocationId,
+  resolveInvocationRegistryVersion,
+  resolveInvocationsDbPath
+} from "./chunk-GKN3HMN4.js";
+import {
+  JsonParseError,
+  safeJsonParse
+} from "./chunk-S54MKU6V.js";
+import {
+  isSandboxAuthorityEnvVar
+} from "./chunk-6TZJRKNW.js";
+import {
+  wrapWithSandbox
+} from "./chunk-PCAGC5MR.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  ProviderExecutionError,
+  providerExecutionErrorStreamOptions
+} from "./chunk-LUVKFFWR.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_ACTIVE_TASK_ID,
+  POETIC_MOCK_PROVIDERS,
+  POETIC_TIMEOUT_MS,
+  POETIC_WORKER_VARIANT,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/providers/shared/execution-transport.ts
+import { randomBytes } from "crypto";
+import * as fs from "fs/promises";
+import { open as fsOpen } from "fs/promises";
+import * as path from "path";
+import { StringDecoder } from "string_decoder";
+import { execa } from "execa";
+var transportLogger = createLogger("ExecutionTransport");
+var VALID_EXECUTION_TRANSPORT_MODES = [
+  "auto",
+  "headless",
+  "tmux-exec",
+  "interactive"
+];
+function isTmuxExecStatusAuthoritative(input) {
+  return input.statusPresent && !input.sessionAlive;
+}
+function parseExecutionTransportMode(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "interactive") {
+    return "tmux-exec";
+  }
+  if (VALID_EXECUTION_TRANSPORT_MODES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+var tmuxAvailabilityProbe;
+async function isTmuxAvailable() {
+  if (tmuxAvailabilityProbe === void 0) {
+    tmuxAvailabilityProbe = (async () => {
+      try {
+        const result = await execa("tmux", ["-V"], { reject: false });
+        return result.exitCode === 0;
+      } catch {
+        return false;
+      }
+    })();
+  }
+  return tmuxAvailabilityProbe;
+}
+function resolveRequestedTransportMode(options) {
+  const providerKey = options.provider?.trim().toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+  const envRequested = (providerKey ? parseExecutionTransportMode(options.env?.[`POETIC_${providerKey}_EXECUTION_TRANSPORT`]) : void 0) ?? parseExecutionTransportMode(options.env?.POETIC_PROVIDER_EXECUTION_TRANSPORT) ?? parseExecutionTransportMode(options.env?.POETIC_EXECUTION_TRANSPORT);
+  const requested = options.requested ?? envRequested ?? options.configured ?? "headless";
+  return requested === "interactive" ? "tmux-exec" : requested;
+}
+async function resolveExecutionTransportMode(options) {
+  const normalizedRequested = resolveRequestedTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider
+  });
+  if (normalizedRequested === "headless") return "headless";
+  const available = await (options.tmuxAvailable ?? isTmuxAvailable)();
+  if (available) return "tmux-exec";
+  if (normalizedRequested === "tmux-exec") {
+    throw new ProviderExecutionError(
+      "tmux-exec provider execution transport requires tmux, but tmux was not found on PATH.",
+      { retryable: false, reason: "tmux_exec_transport_unavailable" }
+    );
+  }
+  return "headless";
+}
+async function resolveProviderTransportDecision(options) {
+  const quirks = getProviderRuntimeQuirks(options.provider);
+  const requestedMode = resolveRequestedTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider
+  });
+  if (options.forceHeadlessReason) {
+    const requested = requestedMode === "headless" ? "headless" : "tmux-exec";
+    return {
+      resolved: "headless",
+      requested,
+      downgradeReason: requested === "tmux-exec" ? options.forceHeadlessReason : void 0
+    };
+  }
+  const support = quirks?.tmuxExecSupport ?? "none";
+  if (support === "none") {
+    if (requestedMode === "tmux-exec") {
+      return {
+        resolved: "headless",
+        requested: "tmux-exec",
+        downgradeReason: `${options.provider} is not validated for tmux-exec under a pane pty; using headless`
+      };
+    }
+    return { resolved: "headless", requested: "headless" };
+  }
+  const resolved = await resolveExecutionTransportMode({
+    requested: options.requested,
+    configured: options.configured,
+    env: options.env,
+    provider: options.provider,
+    tmuxAvailable: options.tmuxAvailable
+  });
+  if (resolved !== "tmux-exec") {
+    return { resolved, requested: resolved };
+  }
+  if (support === "read-only") {
+    const isReadOnly = options.executionIntent === "analysis" || options.readOnlyWorkingDir === true;
+    if (!isReadOnly) {
+      return {
+        resolved: "headless",
+        requested: "tmux-exec",
+        downgradeReason: `${options.provider} supports tmux-exec only for analysis/read-only runs; using headless for this write-intent run`
+      };
+    }
+  }
+  return { resolved: "tmux-exec", requested: "tmux-exec" };
+}
+function reportTransportDecision(provider, decision, debug) {
+  if (decision.downgradeReason) {
+    transportLogger.warn(
+      `[${provider}] execution transport downgraded: ${decision.downgradeReason}`,
+      {
+        provider,
+        requested: decision.requested,
+        resolved: decision.resolved
+      }
+    );
+    return;
+  }
+  debug?.(`[${provider}] execution transport resolved to ${decision.resolved}`, {
+    provider,
+    resolved: decision.resolved
+  });
+}
+async function selectProviderExecutor(options) {
+  const decision = await resolveProviderTransportDecision(options);
+  options.onDecision?.(decision);
+  const execute = decision.resolved === "tmux-exec" ? executeProviderCommandTmuxExec : options.headless;
+  return { execute, decision };
+}
+function sessionName(providerName) {
+  const safeProvider = providerName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+  return `poetic-${safeProvider || "provider"}-${randomBytes(4).toString("hex")}`;
+}
+async function writePromptFile(tmpDir, input) {
+  if (input === void 0) return void 0;
+  const file = path.join(tmpDir, "prompt.txt");
+  await fs.writeFile(file, input, { mode: 384 });
+  return file;
+}
+async function writeEnvFile(tmpDir, env) {
+  const ownership = resolveProviderProcessGroupOwnership();
+  const paneEnv = {
+    ...commandEnvironment(env),
+    [POETIC_PROCESS_GROUP_OWNER_ENV]: ownership.owner
+  };
+  const lines = Object.entries(commandEnvironment(paneEnv)).filter(
+    (entry) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(entry[0]) && typeof entry[1] === "string"
+  ).map(([key, value]) => `export ${key}=${quotePosixShellArg(value)}`);
+  const file = path.join(tmpDir, "env.sh");
+  await fs.writeFile(file, lines.length > 0 ? `${lines.join("\n")}
+` : "", { mode: 384 });
+  return file;
+}
+function resolveCommandName(command) {
+  const posix2 = path.posix.basename(command);
+  const win322 = path.win32.basename(command);
+  const basename = posix2.length <= win322.length ? posix2 : win322;
+  return basename.replace(/\.(exe|cmd|bat|ps1)$/i, "").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+}
+function commandEnvironment(env) {
+  const source = env ?? process.env;
+  const next = { ...source };
+  for (const key of Object.keys(next)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete next[key];
+    }
+  }
+  return next;
+}
+function buildTmuxShellCommand(options) {
+  const argv = [options.command, ...options.args].map(quotePosixShellArg).join(" ");
+  const input = options.promptFile ? ` < ${quotePosixShellArg(options.promptFile)}` : " < /dev/null";
+  const output = ` > ${quotePosixShellArg(options.stdoutFile)} 2> ${quotePosixShellArg(options.stderrFile)}`;
+  const innerScript = [
+    `. ${quotePosixShellArg(options.envFile)}`,
+    `rm -f ${quotePosixShellArg(options.envFile)}`,
+    `exec ${argv}${input}${output}`
+  ].join("; ");
+  const runner = `env -i sh -c ${quotePosixShellArg(innerScript)}`;
+  return [
+    runner,
+    "status=$?",
+    `printf '%s' "$status" > ${quotePosixShellArg(options.statusFile)}`,
+    'exit "$status"'
+  ].join("; ");
+}
+async function readTextIfPresent(file) {
+  try {
+    return await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+var OutputFileTail = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  offset = 0;
+  decoder = new StringDecoder("utf8");
+  /** Read any bytes appended since the last call (bytes + decoded text). */
+  async read() {
+    let handle;
+    try {
+      handle = await fsOpen(this.file, "r");
+      const { size } = await handle.stat();
+      if (size <= this.offset) {
+        if (size < this.offset) {
+          this.offset = 0;
+          this.decoder = new StringDecoder("utf8");
+        }
+        return { bytes: Buffer.alloc(0), text: "" };
+      }
+      const length = size - this.offset;
+      const buffer = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, this.offset);
+      this.offset += bytesRead;
+      const bytes = Buffer.from(buffer.subarray(0, bytesRead));
+      const text = this.decoder.write(bytes);
+      return { bytes, text };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { bytes: Buffer.alloc(0), text: "" };
+      }
+      throw error;
+    } finally {
+      await handle?.close().catch(() => {
+      });
+    }
+  }
+  /**
+   * Flush incomplete multibyte sequence as presentation text only.
+   * Authoritative raw observers already received those bytes on the read that
+   * advanced the offset — do not re-deliver them as raw chunks.
+   */
+  flushText() {
+    return this.decoder.end();
+  }
+};
+function deliverRawBytes(observer, bytes) {
+  if (!observer || bytes.length === 0) {
+    return;
+  }
+  try {
+    observer(bytes);
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function parseTmuxPanePid(value) {
+  const text = value?.trim();
+  if (!text || !/^\d+$/.test(text)) return void 0;
+  const pid = Number.parseInt(text, 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+function firstUsefulDiagnosticLine(text) {
+  return text.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "no error output";
+}
+function tmuxTransportStreamOptions(fullStdout, fullStderr, options) {
+  return providerExecutionTransportStreamOptions(fullStdout, fullStderr, {
+    maxPublicLength: options?.maxPublicLength ?? 4096
+  });
+}
+function throwIfTmuxNonZeroExit(options, result, fullStreams) {
+  if (result.exitCode === 0) {
+    return;
+  }
+  const streams = tmuxTransportStreamOptions(
+    fullStreams?.stdout ?? result.stdout,
+    fullStreams?.stderr ?? result.stderr,
+    { maxPublicLength: 4096 }
+  );
+  const diagnostic = firstUsefulDiagnosticLine(streams.stderr || streams.stdout || "");
+  throw new ProviderExecutionError(
+    `${options.metadata.name} CLI exited with code ${result.exitCode}: ${diagnostic}`,
+    {
+      retryable: false,
+      exitCode: result.exitCode,
+      reason: "non_zero_exit",
+      ...streams
+    }
+  );
+}
+async function tmuxSessionExists(session, env) {
+  const result = await execa("tmux", ["has-session", "-t", session], {
+    env: tmuxClientEnv(env),
+    reject: false,
+    timeout: 5e3
+  }).catch(() => void 0);
+  return result?.exitCode === 0;
+}
+async function killTmuxSession(params) {
+  return killTmuxSessionWithPaneFallback({
+    session: params.session,
+    tmuxEnv: params.env,
+    panePid: params.panePid,
+    timeoutMs: 1e4
+  });
+}
+async function registerTmuxProcessLifecycle(params) {
+  const plm = getProcessLifecycleManager();
+  if (!plm) return void 0;
+  try {
+    return await plm.registerProcessWithOptions({
+      completionPromise: params.completionPromise,
+      terminateFn: async () => {
+        await params.terminate();
+      },
+      verificationFn: async () => true,
+      processType: "local",
+      timeoutMs: 0,
+      metadata: {
+        provider: params.options.metadata.name,
+        command: params.options.command,
+        args: params.options.args,
+        cwd: params.options.workingDir,
+        transport: "tmux-exec",
+        session: params.session,
+        ...params.panePid !== void 0 ? { panePid: params.panePid } : {},
+        startTime: Date.now()
+      }
+    });
+  } catch (error) {
+    transportLogger.warn("[tmux-exec] ProcessLifecycleManager registration failed", {
+      provider: params.options.metadata.name,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+function tmuxClientEnv(env) {
+  const source = env ?? process.env;
+  const allowList = ["PATH", "HOME", "TMUX", "TMUX_TMPDIR", "TMPDIR", "USER", "LOGNAME", "TERM"];
+  const minimal = {};
+  for (const key of allowList) {
+    const value = source[key];
+    if (typeof value === "string") {
+      minimal[key] = value;
+    }
+  }
+  return minimal;
+}
+async function removeTmpDir(tmpDir) {
+  await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+  });
+}
+async function executeProviderCommandTmuxExec(options) {
+  const session = sessionName(options.metadata.id ?? options.metadata.name);
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const idleTimeouts = resolveIdleTimeoutsMs(options.command, options.args, timeout, {
+    idleWarnMs: options.idleWarnMs,
+    idleKillMs: options.idleKillMs
+  });
+  const tmpDir = await fs.mkdtemp(path.join("/var/tmp", "poetic-tmux-exec-"));
+  const stdoutFile = path.join(tmpDir, "stdout.log");
+  const stderrFile = path.join(tmpDir, "stderr.log");
+  const statusFile = path.join(tmpDir, "status");
+  let shellCommand;
+  try {
+    const promptFile = await writePromptFile(tmpDir, options.input);
+    const envFile = await writeEnvFile(tmpDir, options.env);
+    await fs.writeFile(stdoutFile, "");
+    await fs.writeFile(stderrFile, "");
+    const sandboxed = options.disablePoeticSandbox === true ? { command: options.command, args: options.args, sandboxed: false } : wrapWithSandbox({
+      workingDir: options.workingDir,
+      command: options.command,
+      args: options.args,
+      providerName: options.metadata.name,
+      extraWritePaths: options.extraWritePaths,
+      readOnlyWorkingDir: options.readOnlyWorkingDir,
+      // Provider execution path (tmux transport), so the same
+      // write-boundary requirement as base-runner applies. Read-only runs
+      // still pass readOnlyWorkingDir and stay exempt.
+      requiresBoundaryForWrites: true,
+      env: options.env,
+      providerId: options.metadata.id ?? resolveCommandName(options.command)
+    });
+    assertProviderBypassHasBoundaryProof(
+      options.metadata,
+      options.args,
+      sandboxed,
+      options.providerInternalSandboxBypass
+    );
+    shellCommand = buildTmuxShellCommand({
+      command: sandboxed.command,
+      args: sandboxed.args,
+      envFile,
+      promptFile,
+      stdoutFile,
+      stderrFile,
+      statusFile
+    });
+  } catch (error) {
+    await removeTmpDir(tmpDir);
+    throw error;
+  }
+  const readFullTerminalStdout = () => readTextIfPresent(stdoutFile);
+  const readFullTerminalStderr = () => readTextIfPresent(stderrFile);
+  const startedAt = Date.now();
+  let aborted = false;
+  let stdoutTail;
+  let stderrTail;
+  let firstOutputSeen = false;
+  let completionSignalSeen = false;
+  let completionSignalSeenAt = null;
+  let exitedForCompletionSignal = false;
+  let lastActivityAt = startedAt;
+  const completionSignalGraceMs = Math.max(
+    0,
+    options.completionSignalGraceMs ?? TMUX_COMPLETION_SIGNAL_GRACE_MS
+  );
+  let tmuxPanePid;
+  let lastCpuTimeSeconds;
+  let consecutiveBusyCpuPolls = 0;
+  const abort = async () => {
+    aborted = true;
+    return killTmuxSession({ session, env: options.env, panePid: tmuxPanePid });
+  };
+  const abortListener = () => {
+    void abort();
+  };
+  const limiterDescription = `${options.metadata.name} tmux-exec provider command: ${options.command}`.trim();
+  let reservation;
+  try {
+    stdoutTail = new OutputFileTail(stdoutFile);
+    stderrTail = new OutputFileTail(stderrFile);
+    if (options.abortSignal?.aborted) {
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort"
+      });
+    }
+    const reservationOrWait = acquireProcessSlot(limiterDescription, options.abortSignal);
+    reservation = reservationOrWait instanceof Promise ? await reservationOrWait : reservationOrWait;
+  } catch (error) {
+    await removeTmpDir(tmpDir);
+    throw error;
+  }
+  let activeReservationId = typeof reservation === "number" ? reservation : void 0;
+  const reservationRenewTimer = activeReservationId !== void 0 ? setInterval(() => {
+    if (activeReservationId === void 0) return;
+    if (globalProcessLimiter.renewReservation(activeReservationId)) return;
+    const replacement = globalProcessLimiter.reserve();
+    activeReservationId = typeof replacement === "number" ? replacement : void 0;
+  }, 1e4) : void 0;
+  reservationRenewTimer?.unref?.();
+  const releaseReservation = () => {
+    if (reservationRenewTimer) {
+      clearInterval(reservationRenewTimer);
+    }
+    if (activeReservationId !== void 0) {
+      globalProcessLimiter.cancelReservation(activeReservationId);
+      activeReservationId = void 0;
+    }
+  };
+  options.abortSignal?.addEventListener("abort", abortListener, { once: true });
+  let tmuxPlmProcessId;
+  let registryPersisted = false;
+  let sessionStarted = false;
+  let settleTmuxPlmCompletion;
+  try {
+    await registerTmuxSession(session, {
+      env: options.env,
+      category: "variant",
+      type: "spawned",
+      provider: options.metadata.id ?? options.metadata.name,
+      tmpDir
+    });
+    registryPersisted = true;
+    if (aborted || options.abortSignal?.aborted) {
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort",
+        ...tmuxTransportStreamOptions(
+          await readFullTerminalStdout(),
+          await readFullTerminalStderr()
+        )
+      });
+    }
+    options.beforeSpawn?.();
+    const tmuxLaunch = await execa(
+      "tmux",
+      [
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_pid}",
+        "-s",
+        session,
+        "-c",
+        options.workingDir,
+        shellCommand
+      ],
+      {
+        // Launch the tmux CLIENT with a minimal env. Provider secrets travel
+        // ONLY through the 0600 env file sourced inside the pane; handing them
+        // to the client would leak them into the tmux server/session env if
+        // this call starts the server.
+        env: tmuxClientEnv(options.env),
+        cancelSignal: options.abortSignal,
+        reject: true
+      }
+    );
+    sessionStarted = true;
+    tmuxPanePid = parseTmuxPanePid(tmuxLaunch.stdout);
+    await recordTmuxSessionPanePid(session, tmuxPanePid);
+    const tmuxPlmCompletion = new Promise((resolve2, reject) => {
+      settleTmuxPlmCompletion = { resolve: resolve2, reject, settled: false };
+    });
+    tmuxPlmCompletion.catch(() => {
+    });
+    tmuxPlmProcessId = await registerTmuxProcessLifecycle({
+      options,
+      session,
+      panePid: tmuxPanePid,
+      completionPromise: tmuxPlmCompletion,
+      terminate: abort
+    });
+    const drainUnreadRawTails = async () => {
+      const stdout = await stdoutTail.read();
+      const stderr = await stderrTail.read();
+      deliverRawBytes(options.onStdoutChunk, stdout.bytes);
+      deliverRawBytes(options.onStderrChunk, stderr.bytes);
+    };
+    while (!aborted) {
+      const stdoutChunk = await stdoutTail.read();
+      const stderrChunk = await stderrTail.read();
+      if (stdoutChunk.bytes.length > 0) {
+        const now = Date.now();
+        lastActivityAt = now;
+        options.onActivity?.({ source: "stdout", timestampMs: now });
+        if (!firstOutputSeen && stdoutChunk.text.trim().length > 0) {
+          firstOutputSeen = true;
+          options.onFirstOutput?.(now);
+        }
+        deliverRawBytes(options.onStdoutChunk, stdoutChunk.bytes);
+        if (stdoutChunk.text.length > 0) {
+          try {
+            if (options.completionSignal?.(stdoutChunk.text, "stdout") === true) {
+              completionSignalSeen = true;
+              completionSignalSeenAt ??= Date.now();
+            }
+          } catch {
+          }
+          if (options.streamOutput === true) {
+            options.onData?.(stdoutChunk.text);
+          }
+        }
+      }
+      if (stderrChunk.bytes.length > 0) {
+        const now = Date.now();
+        lastActivityAt = now;
+        options.onActivity?.({ source: "stderr", timestampMs: now });
+        deliverRawBytes(options.onStderrChunk, stderrChunk.bytes);
+        if (stderrChunk.text.length > 0) {
+          try {
+            if (options.completionSignal?.(stderrChunk.text, "stderr") === true) {
+              completionSignalSeen = true;
+              completionSignalSeenAt ??= Date.now();
+            }
+          } catch {
+          }
+          if (options.streamOutput === true) {
+            options.onErrorData?.(stderrChunk.text);
+          }
+        }
+      }
+      if (idleTimeouts) {
+        const currentCpuTimeSeconds = tmuxPanePid === void 0 ? void 0 : readCpuTimeSeconds(tmuxPanePid);
+        const cpuProgress = evaluateCpuTimeProgressStreak({
+          currentCpuSeconds: currentCpuTimeSeconds,
+          previousCpuSeconds: lastCpuTimeSeconds,
+          currentBusyPolls: consecutiveBusyCpuPolls
+        });
+        consecutiveBusyCpuPolls = cpuProgress.nextBusyPolls;
+        if (currentCpuTimeSeconds !== void 0) {
+          lastCpuTimeSeconds = currentCpuTimeSeconds;
+        }
+        if (cpuProgress.shouldCountAsActivity) {
+          const now = Date.now();
+          lastActivityAt = now;
+          options.onActivity?.({ source: "cpu", timestampMs: now });
+        }
+        const idleFor = Date.now() - lastActivityAt;
+        if (idleFor >= idleTimeouts.killMs) {
+          options.onIdleTermination?.();
+          const killResult = await abort();
+          await drainUnreadRawTails();
+          const fullStdout2 = await readFullTerminalStdout();
+          const fullStderr2 = await readFullTerminalStderr();
+          const stderrDetail = fullStderr2.trim().length > 0 ? " Recent stderr was captured privately." : "";
+          const killDetail = killResult.removed ? "" : " Tmux session removal failed after pane SIGTERM/SIGKILL fallback; registry retained for orphan cleanup.";
+          throw new ProviderExecutionError(
+            `[${options.metadata.name}] tmux-exec provider execution idle timed out after ${Math.round(
+              idleTimeouts.killMs / 1e3
+            )}s with no stdout/stderr activity.${stderrDetail}${killDetail}`,
+            {
+              retryable: false,
+              reason: "idle_timeout",
+              idleTerminated: true,
+              ...tmuxTransportStreamOptions(fullStdout2, fullStderr2)
+            }
+          );
+        }
+      }
+      const statusText2 = await readTextIfPresent(statusFile);
+      if (isTmuxExecStatusAuthoritative({
+        statusPresent: statusText2.trim().length > 0,
+        sessionAlive: sessionStarted ? await tmuxSessionExists(session, options.env) : false
+      })) {
+        break;
+      }
+      if (completionSignalSeen && completionSignalSeenAt !== null && Date.now() - completionSignalSeenAt >= completionSignalGraceMs) {
+        exitedForCompletionSignal = true;
+        await killTmuxSession({ session, env: options.env, panePid: tmuxPanePid });
+        break;
+      }
+      if (Date.now() - startedAt > timeout) {
+        const killResult = await abort();
+        await drainUnreadRawTails();
+        const killDetail = killResult.removed ? "" : "; tmux session removal failed after pane SIGTERM/SIGKILL fallback; registry retained for orphan cleanup";
+        throw new ProviderExecutionError(
+          `[${options.metadata.name}] tmux-exec provider execution timed out after ${timeout}ms${killDetail}`,
+          {
+            retryable: false,
+            reason: "timeout",
+            ...tmuxTransportStreamOptions(
+              await readFullTerminalStdout(),
+              await readFullTerminalStderr()
+            )
+          }
+        );
+      }
+      await sleep(250);
+    }
+    if (aborted) {
+      await drainUnreadRawTails();
+      throw new ProviderExecutionError(`[${options.metadata.name}] Provider execution aborted`, {
+        retryable: false,
+        reason: "abort",
+        ...tmuxTransportStreamOptions(
+          await readFullTerminalStdout(),
+          await readFullTerminalStderr()
+        )
+      });
+    }
+    const finalStdout = await stdoutTail.read();
+    const finalStderr = await stderrTail.read();
+    const finalStdoutText = finalStdout.text + stdoutTail.flushText();
+    const finalStderrText = finalStderr.text + stderrTail.flushText();
+    deliverRawBytes(options.onStdoutChunk, finalStdout.bytes);
+    deliverRawBytes(options.onStderrChunk, finalStderr.bytes);
+    if (finalStdoutText.length > 0) {
+      try {
+        if (options.completionSignal?.(finalStdoutText, "stdout") === true) {
+          completionSignalSeen = true;
+          completionSignalSeenAt ??= Date.now();
+        }
+      } catch {
+      }
+    }
+    if (finalStderrText.length > 0) {
+      try {
+        if (options.completionSignal?.(finalStderrText, "stderr") === true) {
+          completionSignalSeen = true;
+          completionSignalSeenAt ??= Date.now();
+        }
+      } catch {
+      }
+    }
+    if (options.streamOutput === true) {
+      if (finalStdoutText) options.onData?.(finalStdoutText);
+      if (finalStderrText) options.onErrorData?.(finalStderrText);
+    }
+    const statusText = await readTextIfPresent(statusFile);
+    const trimmedStatus = statusText.trim();
+    const statusIsValid = /^-?\d+$/.test(trimmedStatus);
+    let resolvedExitCode;
+    if (statusIsValid) {
+      resolvedExitCode = Number.parseInt(trimmedStatus, 10);
+    } else if (exitedForCompletionSignal || completionSignalSeen) {
+      resolvedExitCode = 0;
+    } else {
+      resolvedExitCode = 1;
+    }
+    const fullStdout = await readTextIfPresent(stdoutFile);
+    const fullStderr = await readTextIfPresent(stderrFile);
+    const dualPublic = resolvedExitCode === 0 ? void 0 : tmuxTransportStreamOptions(fullStdout, fullStderr, {
+      maxPublicLength: 4096
+    });
+    const publicStdout = resolvedExitCode === 0 ? fullStdout : dualPublic?.stdout ?? "";
+    const publicStderr = resolvedExitCode === 0 ? fullStderr : dualPublic?.stderr ?? "";
+    if (options.streamOutput !== true) {
+      if (publicStdout) options.onData?.(publicStdout);
+      if (publicStderr) options.onErrorData?.(publicStderr);
+    } else if (resolvedExitCode === 1 && !statusIsValid && !exitedForCompletionSignal && !completionSignalSeen) {
+      options.onErrorData?.(
+        `[${options.metadata.name}] tmux-exec produced no terminal exit status; treating as failure.`
+      );
+    }
+    const result = {
+      stdout: publicStdout,
+      stderr: publicStderr,
+      exitCode: resolvedExitCode,
+      ...tmuxPanePid !== void 0 ? { pid: tmuxPanePid } : {}
+    };
+    throwIfTmuxNonZeroExit(options, result, { stdout: fullStdout, stderr: fullStderr });
+    if (settleTmuxPlmCompletion && !settleTmuxPlmCompletion.settled) {
+      settleTmuxPlmCompletion.settled = true;
+      settleTmuxPlmCompletion.resolve(result);
+    }
+    return result;
+  } catch (error) {
+    if (settleTmuxPlmCompletion && !settleTmuxPlmCompletion.settled) {
+      settleTmuxPlmCompletion.settled = true;
+      settleTmuxPlmCompletion.reject(error);
+    }
+    throw error;
+  } finally {
+    options.abortSignal?.removeEventListener("abort", abortListener);
+    releaseReservation();
+    let orphanHandoffSucceeded = false;
+    if (registryPersisted) {
+      try {
+        orphanHandoffSucceeded = await markTmuxSessionOrphaned(session);
+      } catch (error) {
+        transportLogger.warn("[tmux-exec] failed to mark retained tmux session orphaned", {
+          provider: options.metadata.name,
+          session,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const killResult = registryPersisted || sessionStarted ? await killTmuxSession({ session, env: options.env, panePid: tmuxPanePid }) : { removed: true, killed: false };
+    if (killResult.removed) {
+      await unregisterTmuxSession(session);
+    }
+    if (killResult.removed) {
+      if (tmuxPlmProcessId) {
+        getProcessLifecycleManager()?.unregisterProcess(tmuxPlmProcessId);
+      }
+      await removeTmpDir(tmpDir);
+    } else {
+      if (orphanHandoffSucceeded && tmuxPlmProcessId) {
+        getProcessLifecycleManager()?.unregisterProcess(tmuxPlmProcessId);
+      }
+      transportLogger.warn("[tmux-exec] tmux session cleanup failed; retaining registry record", {
+        provider: options.metadata.name,
+        session,
+        ...tmuxPanePid !== void 0 ? { panePid: tmuxPanePid } : {},
+        registryOrphaned: orphanHandoffSucceeded
+      });
+    }
+  }
+}
+
+// src/core/providers/shared/invocation-telemetry.ts
+import path2 from "path";
+async function recordInvocationTiming(record) {
+  try {
+    const requestSentMs = Number(record.timeRequestSentMs);
+    if (!Number.isFinite(requestSentMs) || requestSentMs <= 0) {
+      return;
+    }
+    const executionSource = resolveInvocationExecutionSource(record);
+    const providerId = normalizeTelemetryId(record.providerId);
+    const modelId = normalizeTelemetryId(record.canonicalModelId) ?? normalizeTelemetryId(record.modelId);
+    if (executionSource === "live" && (!providerId || !modelId)) {
+      debugLog("[Telemetry] Skipped live invocation timing without provider/model identity");
+      return;
+    }
+    const firstTokenMs = typeof record.timeFirstTokenMs === "number" && Number.isFinite(record.timeFirstTokenMs) ? record.timeFirstTokenMs : null;
+    const lastTokenMs = typeof record.timeLastTokenMs === "number" && Number.isFinite(record.timeLastTokenMs) ? record.timeLastTokenMs : null;
+    const timeToFirstTokenMs = firstTokenMs !== null ? Math.max(0, Math.floor(firstTokenMs - requestSentMs)) : null;
+    const totalTimeMs = lastTokenMs !== null ? Math.max(0, Math.floor(lastTokenMs - requestSentMs)) : null;
+    const poeticDir = record.poeticDir ?? path2.join(resolvePoeticRoot(process.cwd()), ".poetic");
+    const invocationsDbPath = resolveInvocationsDbPath(poeticDir);
+    const db = new ModelInvocationsDB(invocationsDbPath);
+    try {
+      const registryVersion = resolveInvocationRegistryVersion(db);
+      db.insertInvocation({
+        id: generateInvocationId(),
+        timestamp: requestSentMs,
+        providerId: providerId ?? "unknown",
+        modelId: modelId ?? "auto",
+        registryVersion,
+        tokensIn: record.tokensIn ?? null,
+        tokensOut: record.tokensOut ?? null,
+        timeRequestSentMs: requestSentMs,
+        timeFirstTokenMs: firstTokenMs,
+        timeLastTokenMs: lastTokenMs,
+        timeToFirstTokenMs,
+        totalTimeMs,
+        status: record.status,
+        errorCode: record.errorCode ?? null,
+        agentRole: record.agentRole ?? null,
+        copilotSubcommand: record.copilotSubcommand ?? null,
+        parentWorkflowId: record.parentWorkflowId ?? null,
+        executionSource,
+        // ModelIdentity fields (canonicalModelId already mapped into modelId above)
+        requestedModelId: normalizeTelemetryId(record.requestedModelId),
+        executionModelId: normalizeTelemetryId(record.executionModelId),
+        reportedModelId: normalizeTelemetryId(record.reportedModelId),
+        backend: normalizeTelemetryId(record.backend),
+        scope: normalizeTelemetryId(record.scope),
+        contextSelector: normalizeTelemetryId(record.contextSelector),
+        resolutionSource: normalizeTelemetryId(record.resolutionSource),
+        ...resolveInvocationCostAttribution(record)
+      });
+      try {
+        await ensurePendingInvocationCostEnrichment(db, {
+          aggregate: false,
+          refreshRegistrySnapshot: false
+        });
+      } catch (error) {
+        debugLog(
+          `[Telemetry] Failed to enrich invocation cost: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    debugLog(
+      `[Telemetry] Failed to record invocation timing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function resolveInvocationExecutionSource(record = {}) {
+  if (record.executionSource) return record.executionSource;
+  const env = record.env;
+  if (env?.POETIC_MOCK_PROVIDERS === "1") {
+    return "mock";
+  }
+  if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") return "test";
+  if (readEnv(POETIC_MOCK_PROVIDERS).value === "1") return "mock";
+  return "live";
+}
+function normalizeTelemetryId(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function firstTelemetryId(...values) {
+  for (const value of values) {
+    const normalized = normalizeTelemetryId(value);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+function resolveEnvAttributionId(record, key, spec) {
+  if (record.env) {
+    return normalizeTelemetryId(record.env[key]);
+  }
+  const value = readEnv(spec).value;
+  return typeof value === "string" ? normalizeTelemetryId(value) : null;
+}
+function resolveInvocationCostAttribution(record) {
+  const taskId = firstTelemetryId(
+    record.taskId,
+    resolveEnvAttributionId(record, POETIC_ACTIVE_TASK_ID.name, POETIC_ACTIVE_TASK_ID)
+  );
+  const variantId = firstTelemetryId(
+    record.variantId,
+    resolveEnvAttributionId(record, POETIC_WORKER_VARIANT.name, POETIC_WORKER_VARIANT)
+  );
+  const competitionId = firstTelemetryId(record.competitionId, taskId);
+  return { taskId, competitionId, variantId };
+}
+
+// src/core/providers/shared/provider-timeout.ts
+function resolveProviderTimeoutMs(providerId, explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const parsedProviderEnv = readProviderTimeoutEnvMs(providerId);
+  if (parsedProviderEnv !== void 0) {
+    return parsedProviderEnv;
+  }
+  const parsedGlobalEnv = readEnv(POETIC_TIMEOUT_MS).value;
+  if (parsedGlobalEnv !== void 0 && parsedGlobalEnv > 0) {
+    return parsedGlobalEnv;
+  }
+  try {
+    const timeoutFromConfig = ProviderRegistry.getTimeout(providerId);
+    if (typeof timeoutFromConfig === "number" && timeoutFromConfig > 0) return timeoutFromConfig;
+  } catch {
+  }
+  return DEFAULT_TIMEOUT;
+}
+function readProviderTimeoutEnvMs(providerId) {
+  const providerEnvKey = `POETIC_TIMEOUT_${providerId.toUpperCase()}_MS`;
+  const providerEnv = process.env[providerEnvKey];
+  const parsed = providerEnv ? Number.parseInt(providerEnv, 10) : NaN;
+  return !Number.isNaN(parsed) && parsed > 0 ? parsed : void 0;
+}
+
+// src/core/providers/shared/retry-budget.ts
+var RetryBudget = class {
+  maxTotalAttempts;
+  usedAttempts;
+  constructor(options) {
+    this.maxTotalAttempts = options?.maxTotalAttempts ?? 5;
+    this.usedAttempts = 0;
+  }
+  /**
+   * Returns true if there are remaining attempts in the budget.
+   */
+  hasRemaining() {
+    return this.usedAttempts < this.maxTotalAttempts;
+  }
+  /**
+   * Number of remaining attempts.
+   */
+  get remaining() {
+    return Math.max(0, this.maxTotalAttempts - this.usedAttempts);
+  }
+  /**
+   * Number of attempts consumed so far.
+   */
+  get used() {
+    return this.usedAttempts;
+  }
+  /**
+   * Consume one attempt from the budget.
+   * @returns true if the attempt was allowed, false if the budget is exhausted.
+   */
+  consume() {
+    if (this.usedAttempts >= this.maxTotalAttempts) {
+      return false;
+    }
+    this.usedAttempts += 1;
+    return true;
+  }
+  /**
+   * Reset the budget to its initial state.
+   */
+  reset() {
+    this.usedAttempts = 0;
+  }
+};
+
+// src/core/providers/shared/retry-worktree-state.ts
+import { createHash } from "crypto";
+import { promises as fs2 } from "fs";
+import * as path3 from "path";
+async function captureRetryWorktreeState(workingDir) {
+  try {
+    const [head, status, staged, unstaged, untracked] = await Promise.all([
+      execGit(["rev-parse", "HEAD"], { cwd: workingDir }),
+      execGit(["status", "--porcelain=v1", "--untracked-files=all", "-z"], {
+        cwd: workingDir
+      }),
+      execGit(["diff", "--cached", "--binary", "--full-index", "--no-ext-diff"], {
+        cwd: workingDir
+      }),
+      execGit(["diff", "--binary", "--full-index", "--no-ext-diff"], { cwd: workingDir }),
+      execGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd: workingDir })
+    ]);
+    const failed = [head, status, staged, unstaged, untracked].find(
+      (result) => result.exitCode !== 0
+    );
+    if (failed) {
+      return {
+        available: false,
+        error: failed.stderr.trim() || "git state query failed"
+      };
+    }
+    const hash = createHash("sha256");
+    for (const [label, value] of [
+      ["head", head.stdout],
+      ["status", status.stdout],
+      ["staged", staged.stdout],
+      ["unstaged", unstaged.stdout]
+    ]) {
+      hash.update(label).update("\0").update(value).update("\0");
+    }
+    const untrackedPaths = untracked.stdout.split("\0").filter(Boolean).sort();
+    for (const relativePath of untrackedPaths) {
+      const absolutePath = path3.join(workingDir, relativePath);
+      const stats = await fs2.lstat(absolutePath);
+      hash.update("untracked\0").update(relativePath).update("\0");
+      if (stats.isSymbolicLink()) {
+        hash.update("symlink\0").update(await fs2.readlink(absolutePath));
+      } else if (stats.isFile()) {
+        hash.update("file\0").update(await fs2.readFile(absolutePath));
+      } else {
+        hash.update(`other:${stats.mode}:${stats.size}\0`);
+      }
+      hash.update("\0");
+    }
+    return { available: true, fingerprint: hash.digest("hex") };
+  } catch (error) {
+    return {
+      available: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function suppressUnsafeRetryAfterMutatedWorktree(providerName, reason, originalError, detail) {
+  const explanation = reason === "changed" ? "the failed attempt changed HEAD, the index, the working tree, or untracked files" : `Poetic could not verify that the worktree stayed unchanged${detail ? `: ${detail}` : ""}`;
+  return new ProviderExecutionError(
+    `${providerName} retry suppressed because ${explanation}. Inspect the worktree and preserve or revert the attempt's changes before running ${providerName} again.`,
+    {
+      retryable: false,
+      reason: reason === "changed" ? "workspace_changed_during_attempt" : "workspace_state_unknown",
+      providerName,
+      cause: originalError
+    }
+  );
+}
+function isRetryableProviderError(error) {
+  return error instanceof ProviderExecutionError && error.retryable === true;
+}
+async function rejectUnsafeFullPromptRetry(options) {
+  if (!options.requireCleanState && !isRetryableProviderError(options.error) || options.isResumeSafe === true) {
+    return;
+  }
+  const attemptEndState = await captureRetryWorktreeState(options.workingDir);
+  if (!options.attemptStartState.available || !attemptEndState.available) {
+    throw suppressUnsafeRetryAfterMutatedWorktree(
+      options.providerName,
+      "unavailable",
+      options.error,
+      options.attemptStartState.error ?? attemptEndState.error
+    );
+  }
+  if (options.attemptStartState.fingerprint !== attemptEndState.fingerprint) {
+    throw suppressUnsafeRetryAfterMutatedWorktree(options.providerName, "changed", options.error);
+  }
+}
+
+// src/core/providers/shared/workspace-edits-parser.ts
+import * as path4 from "path";
+function isUnsafePath(candidate, options = {}) {
+  if (!candidate) return true;
+  const { rootDir = process.cwd(), allowAbsolute = false, allowHomeExpansion = false } = options;
+  const normalized = candidate.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\\/g, "/");
+  if (normalized.includes("\0")) return true;
+  if (!allowAbsolute && path4.isAbsolute(candidate)) return true;
+  if (!allowHomeExpansion && normalized.startsWith("~")) return true;
+  if (normalized.startsWith("../")) return true;
+  if (normalized.includes("/../")) return true;
+  if (/^[a-zA-Z]:[\\/]/.test(candidate)) return true;
+  try {
+    const resolved = path4.resolve(rootDir, normalized);
+    const resolvedRoot = path4.resolve(rootDir);
+    const relative2 = path4.relative(resolvedRoot, resolved);
+    const escapesRoot = relative2.startsWith("..") || path4.isAbsolute(relative2);
+    return escapesRoot;
+  } catch {
+    return true;
+  }
+}
+function parseWorkspaceEditsFromJsonl(rawOutput, options = {}) {
+  if (!rawOutput) {
+    return { cleanedOutput: rawOutput, edits: [], errors: [] };
+  }
+  const edits = [];
+  const errors = [];
+  const kept = [];
+  const pathSafetyOptions = options.workspaceRoot ? { rootDir: options.workspaceRoot } : {};
+  for (const line of rawOutput.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+      kept.push(line);
+      continue;
+    }
+    let parsed = null;
+    try {
+      parsed = safeJsonParse(trimmed, {
+        debug: false,
+        context: "workspace edit JSON"
+      });
+    } catch (error) {
+      const baseMessage = error instanceof JsonParseError ? error.message : `Failed to parse workspace edit JSON: ${error instanceof Error ? error.message : String(error)}`;
+      const message = `Malformed workspace edit (${baseMessage})`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    if (parsed.type && parsed.type !== "poetic_edit") {
+      kept.push(line);
+      continue;
+    }
+    if (!parsed.op || !parsed.path) {
+      const message = `Incomplete workspace edit payload (missing op/path): ${trimmed}`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    const validOps = ["writeFile", "appendFile", "deleteFile", "renameFile"];
+    if (!validOps.includes(parsed.op)) {
+      const message = `Invalid workspace edit operation "${parsed.op}" (expected: ${validOps.join(", ")})`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    if (isUnsafePath(parsed.path, pathSafetyOptions) || parsed.fromPath && isUnsafePath(parsed.fromPath, pathSafetyOptions)) {
+      const message = `Rejected unsafe workspace edit path: ${parsed.path}${parsed.fromPath ? ` (from: ${parsed.fromPath})` : ""}`;
+      errors.push(message);
+      options.onError?.(message);
+      kept.push(line);
+      continue;
+    }
+    edits.push({
+      op: parsed.op,
+      path: parsed.path.replace(/\\/g, "/"),
+      contents: parsed.contents,
+      fromPath: parsed.fromPath?.replace(/\\/g, "/")
+    });
+  }
+  return {
+    cleanedOutput: kept.join("\n"),
+    edits,
+    errors
+  };
+}
+
+// src/core/providers/shared/write-workspace-edits.ts
+import * as fs3 from "fs/promises";
+import * as path5 from "path";
+var MAX_WRITE_RETRIES = 3;
+var RETRY_BASE_DELAY_MS = 10;
+async function appendWithRetry(editsFile, payload) {
+  let attempt = 0;
+  while (true) {
+    try {
+      await fs3.appendFile(editsFile, payload, "utf8");
+      return;
+    } catch (error) {
+      attempt += 1;
+      if (attempt >= MAX_WRITE_RETRIES) {
+        throw error;
+      }
+      const delayMs = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+    }
+  }
+}
+async function writeWorkspaceEditsToFile(worktreePath, edits) {
+  if (!edits || edits.length === 0) {
+    return { success: true, written: 0, failed: 0, skipped: 0 };
+  }
+  const editsDir = path5.join(worktreePath, ".poetic");
+  const editsFile = path5.join(editsDir, "edits.jsonl");
+  let written = 0;
+  let skipped = 0;
+  try {
+    await fs3.mkdir(editsDir, { recursive: true });
+    const payloads = [];
+    for (const edit of edits) {
+      if (isUnsafePath(edit.path, { rootDir: worktreePath }) || shouldExcludeFile(edit.path) || edit.fromPath && (isUnsafePath(edit.fromPath, { rootDir: worktreePath }) || shouldExcludeFile(edit.fromPath))) {
+        emitWarning(
+          "WS-003",
+          {
+            subsystem: "workspace-edits",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: "Unsafe workspace edit path",
+              path: edit.path,
+              fromPath: edit.fromPath,
+              operation: "writeWorkspaceEdits"
+            }
+          }
+        );
+        skipped += 1;
+        continue;
+      }
+      const payload = {
+        type: "poetic_edit",
+        op: edit.op,
+        path: edit.path,
+        ...edit.contents !== void 0 ? { contents: edit.contents } : {},
+        ...edit.fromPath !== void 0 ? { fromPath: edit.fromPath } : {}
+      };
+      payloads.push(`${JSON.stringify(payload)}
+`);
+    }
+    if (payloads.length > 0) {
+      await appendWithRetry(editsFile, payloads.join(""));
+      written = payloads.length;
+    }
+    return {
+      success: written > 0 || skipped === 0,
+      written,
+      failed: written === 0 && skipped > 0 ? skipped : 0,
+      skipped,
+      ...written === 0 && skipped > 0 ? { error: "All workspace edits were skipped by safety filters" } : {}
+    };
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
+    emitWarning(
+      "WS-003",
+      {
+        subsystem: "workspace-edits",
+        executionPhase: "execution"
+      },
+      {
+        severity: "ERROR" /* ERROR */,
+        metadata: {
+          error: errorMessage2,
+          operation: "writeWorkspaceEdits",
+          editsFile
+        }
+      }
+    );
+    return {
+      success: false,
+      written,
+      failed: edits.length - written - skipped,
+      skipped,
+      error: errorMessage2
+    };
+  }
+}
+
+// src/core/providers/shared/runner-lifecycle.ts
+var DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS = createCircuitBreakerOptions({
+  failureThreshold: 5,
+  recoveryTimeout: 6e4
+});
+async function executeWithResilience(fn, options) {
+  const {
+    providerName,
+    operation = "execute_prompt",
+    maxAttempts = 3,
+    retryBudget,
+    onRetry,
+    abortSignal,
+    circuitBreakerOptions = DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+    errorParser,
+    providerId,
+    fastRetryMode = false,
+    initialDelayMs,
+    maxDelayMs,
+    backoffMultiplier,
+    deadlineMs,
+    minimumAttemptTimeMs,
+    circuitBreakerScope,
+    retryWorktreeDir,
+    isRetryResumeSafe
+  } = options;
+  const retryOptions = createRetryOptions({
+    providerName,
+    operation,
+    maxAttempts,
+    initialDelayMs: fastRetryMode ? 0 : initialDelayMs,
+    maxDelayMs: fastRetryMode ? 0 : maxDelayMs,
+    backoffMultiplier,
+    retryBudget,
+    onRetry,
+    abortSignal,
+    suppressDelayFloors: fastRetryMode,
+    deadlineMs,
+    minimumAttemptTimeMs
+  });
+  const wrappedFn = async () => {
+    const attemptStartState = retryWorktreeDir ? await captureRetryWorktreeState(retryWorktreeDir) : void 0;
+    try {
+      return await executeWithCircuitBreaker(
+        providerName,
+        fn,
+        circuitBreakerOptions,
+        circuitBreakerScope
+      );
+    } catch (error) {
+      const thrown = errorParser ? wrapProviderError(error, errorParser, providerId ?? providerName) : error;
+      if (retryWorktreeDir && attemptStartState) {
+        await rejectUnsafeFullPromptRetry({
+          workingDir: retryWorktreeDir,
+          attemptStartState,
+          error: thrown,
+          providerName: providerId ?? providerName,
+          isResumeSafe: isRetryResumeSafe?.() === true
+        });
+      }
+      throw thrown;
+    }
+  };
+  return withRetry(wrappedFn, retryOptions);
+}
+function wrapProviderError(error, errorParser, providerId) {
+  if (error instanceof CircuitBreakerError) {
+    return new ProviderExecutionError(error.message, {
+      retryable: false,
+      reason: "circuit_open",
+      providerName: providerId,
+      cause: error
+    });
+  }
+  const parsed = errorParser(error);
+  if (error instanceof ProviderExecutionError) {
+    const GENERIC_FALLBACK_REASONS = /* @__PURE__ */ new Set(["non_zero_exit", "provider_cli_error"]);
+    const hasExplicitTerminalReason = typeof error.reason === "string" && error.reason.length > 0 && !GENERIC_FALLBACK_REASONS.has(error.reason);
+    const retryable = error.retryable === false && hasExplicitTerminalReason ? false : parsed.retryable;
+    return new ProviderExecutionError(error.message, {
+      retryable,
+      exitCode: error.exitCode,
+      statusCode: error.statusCode,
+      reason: error.reason,
+      signal: error.signal,
+      terminationSource: error.terminationSource,
+      // Preserve truncated public fields and non-enumerable full raw carriers.
+      ...providerExecutionErrorStreamOptions(error),
+      providerName: providerId,
+      cause: error.cause,
+      parsedError: parsed
+    });
+  }
+  const originalMessage = error instanceof Error ? error.message : String(error);
+  return new ProviderExecutionError(originalMessage, {
+    retryable: parsed.retryable,
+    providerName: providerId,
+    cause: error,
+    parsedError: parsed
+  });
+}
+async function persistWorkspaceEdits(workingDir, edits) {
+  if (edits.length === 0) return;
+  try {
+    await writeWorkspaceEditsToFile(workingDir, edits);
+  } catch (error) {
+    if (process.env.NODE_ENV !== "test") {
+      console.warn(
+        `[runner-lifecycle] Failed to persist workspace edits for ${workingDir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+// src/core/providers/shared/workspace-retry-safety.ts
+import { createHash as createHash2 } from "crypto";
+import { promises as fs4 } from "fs";
+import * as path6 from "path";
+function isEnoentError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function captureWorkspaceFingerprintOnce(workingDir) {
+  const [head, status, staged, unstaged, untracked] = await Promise.all([
+    execGit(["rev-parse", "HEAD"], { cwd: workingDir }),
+    execGit(["status", "--porcelain=v1", "--untracked-files=all", "-z"], {
+      cwd: workingDir
+    }),
+    execGit(["diff", "--cached", "--binary", "--full-index", "--no-ext-diff"], {
+      cwd: workingDir
+    }),
+    execGit(["diff", "--binary", "--full-index", "--no-ext-diff"], { cwd: workingDir }),
+    execGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd: workingDir })
+  ]);
+  const failed = [status, staged, unstaged, untracked].find((result) => result.exitCode !== 0);
+  if (failed) {
+    return {
+      kind: "unavailable",
+      error: failed.stderr.trim() || "git state query failed"
+    };
+  }
+  const hash = createHash2("sha256");
+  for (const [label, value] of [
+    ["head", head.exitCode === 0 ? head.stdout : "<unborn>"],
+    ["status", status.stdout],
+    ["staged", staged.stdout],
+    ["unstaged", unstaged.stdout]
+  ]) {
+    hash.update(label).update("\0").update(value).update("\0");
+  }
+  const untrackedPaths = untracked.stdout.split("\0").filter(Boolean).sort();
+  for (const relativePath of untrackedPaths) {
+    const absolutePath = path6.join(workingDir, relativePath);
+    let stats;
+    try {
+      stats = await fs4.lstat(absolutePath);
+    } catch (error) {
+      if (isEnoentError(error)) {
+        return { kind: "unstable", error: errorMessage(error) };
+      }
+      throw error;
+    }
+    hash.update("untracked\0").update(relativePath).update("\0");
+    try {
+      if (stats.isSymbolicLink()) {
+        hash.update("symlink\0").update(await fs4.readlink(absolutePath));
+      } else if (stats.isFile()) {
+        hash.update("file\0").update(await fs4.readFile(absolutePath));
+      } else {
+        hash.update(`other:${stats.mode}:${stats.size}\0`);
+      }
+    } catch (error) {
+      if (isEnoentError(error)) {
+        return { kind: "unstable", error: errorMessage(error) };
+      }
+      throw error;
+    }
+    hash.update("\0");
+  }
+  return { kind: "ready", fingerprint: hash.digest("hex") };
+}
+async function captureWorkspaceRetryState(workingDir) {
+  try {
+    const insideWorkTree = await execGit(["rev-parse", "--is-inside-work-tree"], {
+      cwd: workingDir
+    });
+    if (insideWorkTree.exitCode !== 0 || insideWorkTree.stdout.trim() !== "true") {
+      return {
+        available: false,
+        error: insideWorkTree.stderr.trim() || "working directory is not inside a Git worktree"
+      };
+    }
+    const first = await captureWorkspaceFingerprintOnce(workingDir);
+    if (first.kind === "ready") {
+      return { available: true, fingerprint: first.fingerprint };
+    }
+    if (first.kind === "unavailable") {
+      return { available: false, error: first.error };
+    }
+    const second = await captureWorkspaceFingerprintOnce(workingDir);
+    if (second.kind === "ready") {
+      return { available: true, fingerprint: second.fingerprint };
+    }
+    return {
+      available: false,
+      error: second.error
+    };
+  } catch (error) {
+    return {
+      available: false,
+      error: errorMessage(error)
+    };
+  }
+}
+async function assertWorkspaceRetryIsSafe(options) {
+  if (!options.retryable) {
+    return;
+  }
+  const attemptEndState = await captureWorkspaceRetryState(options.workingDir);
+  const unavailable = !options.attemptStartState.available || !attemptEndState.available;
+  const changed = !unavailable && options.attemptStartState.fingerprint !== attemptEndState.fingerprint;
+  if (!unavailable && !changed) {
+    return;
+  }
+  const detail = options.attemptStartState.error ?? attemptEndState.error ?? "workspace fingerprint could not be captured";
+  const explanation = changed ? "the failed attempt changed HEAD, the index, the working tree, or untracked files" : `Poetic could not verify that the worktree stayed unchanged: ${detail}`;
+  throw new ProviderExecutionError(
+    `${options.providerName} retry suppressed because ${explanation}. Inspect the worktree and preserve or revert the attempt changes before retrying.`,
+    {
+      retryable: false,
+      reason: changed ? "workspace_changed_during_attempt" : "workspace_state_unknown",
+      providerName: options.providerId,
+      cause: options.originalError instanceof Error ? options.originalError : void 0
+    }
+  );
+}
+
+export {
+  resolveProviderTransportDecision,
+  reportTransportDecision,
+  selectProviderExecutor,
+  executeProviderCommandTmuxExec,
+  recordInvocationTiming,
+  resolveProviderTimeoutMs,
+  readProviderTimeoutEnvMs,
+  RetryBudget,
+  captureRetryWorktreeState,
+  rejectUnsafeFullPromptRetry,
+  parseWorkspaceEditsFromJsonl,
+  DEFAULT_PROVIDER_CIRCUIT_BREAKER_OPTIONS,
+  executeWithResilience,
+  wrapProviderError,
+  persistWorkspaceEdits,
+  captureWorkspaceRetryState,
+  assertWorkspaceRetryIsSafe
+};
+//# sourceMappingURL=chunk-WZ6U3O7I.js.map