issue-flow 0.11.1 → 0.13.0

package/dist/chunk-ARFVHC2F.js

@@ -0,0 +1,1111 @@
+#!/usr/bin/env node
+import {
+  decideRouting
+} from "./chunk-3XLCNVMD.js";
+import {
+  parseJournal
+} from "./chunk-QCXPNSEL.js";
+import {
+  ensureRunnersRegistered,
+  getActiveResilienceConfig,
+  getAgentCliOverrides,
+  getRegisteredProviders,
+  getShutdownSignal,
+  hasExplicitAgentSelection,
+  loadAgentConfig,
+  loadRoutingConfig,
+  peekHarnessVersion,
+  resolveAgentFor,
+  resolveAntigravityTimeoutMs,
+  runnerFor
+} from "./chunk-CNBYCMSU.js";
+import {
+  resolveProjectPaths
+} from "./chunk-HQAHNIAR.js";
+import {
+  ElapsedTimer,
+  createSpinner,
+  formatDuration,
+  getActivityCallback,
+  getIcons,
+  getInactivityTimeout,
+  getOutputCallback,
+  getSessionPublisher,
+  isVerbose,
+  useColor
+} from "./chunk-IYV6KNVF.js";
+import {
+  beginExecution,
+  endExecution
+} from "./chunk-6FDFRNXZ.js";
+import {
+  isoNow,
+  sumUsage
+} from "./chunk-DIG5XKQQ.js";
+import {
+  isAgentProviderId,
+  providersHealthSchema
+} from "./chunk-NEZZ6KDR.js";
+import {
+  ensureCursorStorageGrant
+} from "./chunk-TVN2JVOF.js";
+import {
+  abortableDelay,
+  resolvePolicy,
+  shouldFailover,
+  withRetry
+} from "./chunk-KQHB7ZT3.js";
+import {
+  classify
+} from "./chunk-XEYH6ZZI.js";
+
+// src/routing/budget.ts
+var DEFAULT_CEILINGS = {
+  maxCostUsdPerIssue: null,
+  maxDurationMsPerIssue: null,
+  maxExecutionsPerIssue: null,
+  onCeiling: "block"
+};
+function evaluateCeilings(input) {
+  const ceilings = { ...DEFAULT_CEILINGS, ...input.ceilings };
+  const enforced = [];
+  if (ceilings.maxCostUsdPerIssue !== null && input.spent.costStatus === "reported") {
+    enforced.push("cost");
+  }
+  if (ceilings.maxDurationMsPerIssue !== null) enforced.push("duration");
+  if (ceilings.maxExecutionsPerIssue !== null) enforced.push("executions");
+  if (ceilings.maxCostUsdPerIssue !== null && input.spent.costStatus === "reported" && input.spent.reportedUsd >= ceilings.maxCostUsdPerIssue) {
+    return {
+      ok: false,
+      stopReason: "max_cost",
+      binding: "cost",
+      onCeiling: "block",
+      numbers: { spent: input.spent.reportedUsd, ceiling: ceilings.maxCostUsdPerIssue },
+      enforced
+    };
+  }
+  if (ceilings.maxDurationMsPerIssue !== null && input.spent.durationMs >= ceilings.maxDurationMsPerIssue) {
+    return {
+      ok: false,
+      stopReason: "max_duration",
+      binding: "duration",
+      onCeiling: "block",
+      numbers: { spent: input.spent.durationMs, ceiling: ceilings.maxDurationMsPerIssue },
+      enforced
+    };
+  }
+  if (ceilings.maxExecutionsPerIssue !== null && input.spent.executions >= ceilings.maxExecutionsPerIssue) {
+    return {
+      ok: false,
+      stopReason: "max_attempts",
+      binding: "executions",
+      onCeiling: "block",
+      numbers: { spent: input.spent.executions, ceiling: ceilings.maxExecutionsPerIssue },
+      enforced
+    };
+  }
+  return { ok: true, binding: null };
+}
+function spendFromCost(cost) {
+  if (cost.status === "reported") {
+    return { reportedUsd: cost.amount, costStatus: "reported" };
+  }
+  return { reportedUsd: 0, costStatus: cost.status };
+}
+
+// src/agents/health.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var DEFAULT_PROVIDER_COOLDOWN_MS = 6e4;
+var DEFAULT_PROVIDER_MAX_COOLDOWN_MS = 30 * 6e4;
+var DEFAULT_PROVIDER_FAILURE_WINDOW_MS = 5 * 6e4;
+var DEFAULT_PROVIDER_FAILURES_TO_TRIP = 3;
+function resolveProviderHealthConfig(config = {}) {
+  return {
+    cooldownMs: Math.max(0, config.cooldownMs ?? DEFAULT_PROVIDER_COOLDOWN_MS),
+    maxCooldownMs: Math.max(
+      config.cooldownMs ?? DEFAULT_PROVIDER_COOLDOWN_MS,
+      config.maxCooldownMs ?? DEFAULT_PROVIDER_MAX_COOLDOWN_MS
+    ),
+    failureWindowMs: Math.max(1, config.failureWindowMs ?? DEFAULT_PROVIDER_FAILURE_WINDOW_MS),
+    failuresToTrip: Math.max(
+      1,
+      Math.trunc(config.failuresToTrip ?? DEFAULT_PROVIDER_FAILURES_TO_TRIP)
+    )
+  };
+}
+function emptyHealth() {
+  return providersHealthSchema.parse({});
+}
+function emptyRecord() {
+  return providersHealthSchema.parse({ providers: { provider: {} } }).providers.provider;
+}
+async function readProvidersHealth(filePath) {
+  try {
+    return providersHealthSchema.parse(JSON.parse(await readFile(filePath, "utf-8")));
+  } catch {
+    return emptyHealth();
+  }
+}
+async function writeProvidersHealth(filePath, value) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}`;
+  await writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+  await rename(tmp, filePath);
+}
+async function updateRecord(filePath, provider, update) {
+  const health = await readProvidersHealth(filePath);
+  const next = update(health.providers[provider] ?? emptyRecord());
+  await writeProvidersHealth(filePath, {
+    ...health,
+    providers: { ...health.providers, [provider]: next }
+  });
+  return next;
+}
+function cooldownDelay(level, config) {
+  return Math.min(config.maxCooldownMs, config.cooldownMs * 2 ** Math.max(0, level));
+}
+var BREAKER_KINDS = /* @__PURE__ */ new Set([
+  "timeout",
+  "stalled",
+  "provider_down",
+  "provider_crash"
+]);
+async function recordProviderFailure(filePath, provider, failure, options = {}) {
+  const nowMs = options.now?.() ?? Date.now();
+  const at = new Date(nowMs).toISOString();
+  const config = resolveProviderHealthConfig(options.config);
+  return updateRecord(filePath, provider, (record) => {
+    const failures = [
+      ...record.failures.filter((entry) => {
+        const timestamp = Date.parse(entry.at);
+        return Number.isFinite(timestamp) && nowMs - timestamp <= config.failureWindowMs;
+      }),
+      { at, kind: failure.kind }
+    ];
+    const consecutiveFailures = record.consecutiveFailures + 1;
+    if (failure.kind === "authentication") {
+      return {
+        ...record,
+        status: "auth_failed",
+        failures,
+        consecutiveFailures,
+        cooldownUntil: null,
+        lastFailureKind: failure.kind,
+        lastFailureAt: at,
+        probeInFlight: false,
+        probeStartedAt: null
+      };
+    }
+    if (failure.kind === "rate_limit") {
+      const delay = failure.retryAfterMs ?? cooldownDelay(record.cooldownLevel, config);
+      return {
+        ...record,
+        status: "rate_limited",
+        failures,
+        consecutiveFailures,
+        cooldownLevel: failure.retryAfterMs === void 0 ? record.cooldownLevel + 1 : record.cooldownLevel,
+        cooldownUntil: new Date(nowMs + delay).toISOString(),
+        lastFailureKind: failure.kind,
+        lastFailureAt: at,
+        probeInFlight: false,
+        probeStartedAt: null
+      };
+    }
+    if (BREAKER_KINDS.has(failure.kind)) {
+      const recentProviderFailures = failures.filter(
+        (entry) => BREAKER_KINDS.has(entry.kind)
+      ).length;
+      const unavailable = record.status === "half_open" || recentProviderFailures >= config.failuresToTrip;
+      const delay = unavailable ? cooldownDelay(record.cooldownLevel, config) : 0;
+      return {
+        ...record,
+        status: unavailable ? "unavailable" : "degraded",
+        failures,
+        consecutiveFailures,
+        cooldownLevel: unavailable ? record.cooldownLevel + 1 : record.cooldownLevel,
+        cooldownUntil: unavailable ? new Date(nowMs + delay).toISOString() : null,
+        lastFailureKind: failure.kind,
+        lastFailureAt: at,
+        probeInFlight: false,
+        probeStartedAt: null
+      };
+    }
+    return {
+      ...record,
+      lastFailureKind: failure.kind,
+      lastFailureAt: at,
+      probeInFlight: false,
+      probeStartedAt: null
+    };
+  });
+}
+async function recordProviderSuccess(filePath, provider, options = {}) {
+  const at = new Date(options.now?.() ?? Date.now()).toISOString();
+  return updateRecord(filePath, provider, (record) => ({
+    ...record,
+    status: "healthy",
+    failures: [],
+    consecutiveFailures: 0,
+    cooldownLevel: 0,
+    cooldownUntil: null,
+    lastFailureKind: null,
+    lastSuccessAt: at,
+    probeInFlight: false,
+    probeStartedAt: null
+  }));
+}
+async function openProviderCircuit(filePath, provider, options = {}) {
+  const nowMs = options.now?.() ?? Date.now();
+  const config = resolveProviderHealthConfig(options.config);
+  return updateRecord(filePath, provider, (record) => {
+    if (record.status === "unavailable" || record.status === "rate_limited") return record;
+    const delay = cooldownDelay(record.cooldownLevel, config);
+    return {
+      ...record,
+      status: "unavailable",
+      cooldownLevel: record.cooldownLevel + 1,
+      cooldownUntil: new Date(nowMs + delay).toISOString(),
+      probeInFlight: false,
+      probeStartedAt: null
+    };
+  });
+}
+async function acquireHalfOpenProbe(filePath, provider, options = {}) {
+  const nowMs = options.now?.() ?? Date.now();
+  const at = new Date(nowMs).toISOString();
+  const config = resolveProviderHealthConfig(options.config);
+  let acquired = false;
+  const record = await updateRecord(filePath, provider, (current) => {
+    const cooldownUntil = current.cooldownUntil === null ? 0 : Date.parse(current.cooldownUntil);
+    if (Number.isFinite(cooldownUntil) && cooldownUntil > nowMs) return current;
+    const probeStarted = current.probeStartedAt === null ? 0 : Date.parse(current.probeStartedAt);
+    const probeIsFresh = current.probeInFlight && Number.isFinite(probeStarted) && nowMs - probeStarted < config.cooldownMs;
+    if (probeIsFresh) return current;
+    acquired = true;
+    return {
+      ...current,
+      status: "half_open",
+      cooldownUntil: null,
+      probeInFlight: true,
+      probeStartedAt: at
+    };
+  });
+  return { acquired, record };
+}
+
+// src/agents/select.ts
+var AgentSelectionBlockedError = class extends Error {
+  provider;
+  kind;
+  constructor(provider, kind) {
+    super(
+      `Authentication failed for agent provider '${provider}' (${kind}); the run is blocked. Authenticate or repair that provider before resuming.`
+    );
+    this.name = "AgentSelectionBlockedError";
+    this.provider = provider;
+    this.kind = kind;
+  }
+};
+function remainingMs(until, nowMs) {
+  if (until === null) return null;
+  const parsed = Date.parse(until);
+  return Number.isFinite(parsed) ? Math.max(0, parsed - nowMs) : null;
+}
+function failoverIsDue(record, config) {
+  if (record?.lastFailureKind == null) return false;
+  return shouldFailover(resolvePolicy(record.lastFailureKind, config), record.consecutiveFailures);
+}
+async function verdictFor(provider, record, options) {
+  if (record === void 0 || record.status === "healthy") {
+    return { available: true, waitMs: null, cooldownUntil: null, reason: null, blocked: false };
+  }
+  const reason = record.lastFailureKind;
+  if (record.status === "auth_failed") {
+    const mayFailover = reason !== null && failoverIsDue(record, options.config);
+    return {
+      available: false,
+      waitMs: null,
+      cooldownUntil: null,
+      reason,
+      blocked: options.primary && !mayFailover
+    };
+  }
+  if (record.status === "degraded") {
+    const due = failoverIsDue(record, options.config);
+    const opened = due ? await openProviderCircuit(options.healthFile, provider, {
+      now: () => options.nowMs,
+      config: options.config.providers
+    }) : record;
+    return {
+      available: !due,
+      waitMs: due ? remainingMs(opened.cooldownUntil, options.nowMs) : null,
+      cooldownUntil: opened.cooldownUntil,
+      reason,
+      blocked: false
+    };
+  }
+  if (record.status === "unavailable" || record.status === "rate_limited" || record.status === "half_open") {
+    const waitMs = remainingMs(record.cooldownUntil, options.nowMs);
+    if (waitMs !== null && waitMs > 0) {
+      return {
+        available: false,
+        waitMs,
+        cooldownUntil: record.cooldownUntil,
+        reason,
+        blocked: false
+      };
+    }
+    const probe = await acquireHalfOpenProbe(options.healthFile, provider, {
+      now: () => options.nowMs,
+      config: options.config.providers
+    });
+    return {
+      available: probe.acquired,
+      waitMs: probe.acquired ? null : resolveProviderHealthConfig(options.config.providers).cooldownMs,
+      cooldownUntil: probe.record.cooldownUntil,
+      reason,
+      blocked: false
+    };
+  }
+  return { available: true, waitMs: null, cooldownUntil: null, reason, blocked: false };
+}
+function providerOrder(primary, config) {
+  ensureRunnersRegistered();
+  const registered = getRegisteredProviders();
+  const configured = (config.providers?.chain ?? []).filter(isAgentProviderId);
+  return [.../* @__PURE__ */ new Set([primary, ...configured, ...registered])];
+}
+function settingsFor(base, provider) {
+  if (provider === base.provider) return base;
+  return {
+    ...base,
+    provider,
+    // A model name belongs to the configured primary unless the selected
+    // provider is that primary. Passing a Claude alias to Codex (or vice
+    // versa) is less useful than letting the fallback use its own default.
+    model: null
+  };
+}
+async function selectAgentForInvocation(phase, options = {}) {
+  const config = options.config ?? getActiveResilienceConfig();
+  const base = await resolveAgentFor(phase);
+  const failover = config.providers?.failover === true;
+  if (!failover) {
+    return {
+      primary: base.provider,
+      provider: base.provider,
+      settings: base,
+      healthFile: null,
+      failover: false,
+      reason: null,
+      cooldownUntil: null
+    };
+  }
+  let healthFile;
+  try {
+    healthFile = (await resolveProjectPaths()).providersHealthFile;
+  } catch {
+    return {
+      primary: base.provider,
+      provider: base.provider,
+      settings: base,
+      healthFile: null,
+      failover: true,
+      reason: null,
+      cooldownUntil: null
+    };
+  }
+  const delay = options.delay ?? abortableDelay;
+  selection: for (; ; ) {
+    const nowMs = options.now?.() ?? Date.now();
+    const health = await readProvidersHealth(healthFile);
+    const waits = [];
+    let primaryReason = null;
+    let primaryCooldown = null;
+    for (const provider of providerOrder(base.provider, config)) {
+      const verdict = await verdictFor(provider, health.providers[provider], {
+        healthFile,
+        config,
+        primary: provider === base.provider,
+        nowMs
+      });
+      if (provider === base.provider) {
+        primaryReason = verdict.reason;
+        primaryCooldown = verdict.cooldownUntil;
+      }
+      if (verdict.blocked && verdict.reason !== null) {
+        throw new AgentSelectionBlockedError(provider, verdict.reason);
+      }
+      if (provider === base.provider && !verdict.available && verdict.waitMs !== null && !failoverIsDue(health.providers[provider], config)) {
+        if (!await delay(Math.max(1, verdict.waitMs), { signal: getShutdownSignal() })) {
+          throw new Error("Agent provider selection was interrupted while waiting for cooldown.");
+        }
+        continue selection;
+      }
+      if (verdict.available) {
+        return {
+          primary: base.provider,
+          provider,
+          settings: settingsFor(base, provider),
+          healthFile,
+          failover: provider !== base.provider,
+          reason: provider === base.provider ? null : primaryReason,
+          cooldownUntil: primaryCooldown
+        };
+      }
+      if (verdict.waitMs !== null) waits.push(verdict.waitMs);
+    }
+    const waitMs = waits.length > 0 ? Math.max(1, Math.min(...waits)) : null;
+    if (waitMs === null) {
+      throw new Error(
+        "No healthy agent provider is available and none has a cooldown to wait for."
+      );
+    }
+    if (!await delay(waitMs, { signal: getShutdownSignal() })) {
+      throw new Error("Agent provider selection was interrupted while waiting for cooldown.");
+    }
+  }
+}
+
+// src/agents/invoke.ts
+async function selectionForForced(invocation) {
+  const settings = await resolveAgentFor(invocation.phase, {
+    cli: { forceProvider: invocation.forceProvider }
+  });
+  return {
+    primary: settings.provider,
+    provider: settings.provider,
+    settings,
+    healthFile: null,
+    failover: false,
+    reason: null,
+    cooldownUntil: null
+  };
+}
+var attempts = /* @__PURE__ */ new Map();
+var lastFailure = /* @__PURE__ */ new Map();
+var issueSpend = {
+  reportedUsd: 0,
+  durationMs: 0,
+  executions: 0,
+  sawReported: false
+};
+function declaredAgentIdentity(provider) {
+  switch (provider) {
+    case "claude":
+      return { harness: "claude-code", vendor: "anthropic" };
+    case "codex":
+      return { harness: "codex-cli", vendor: "openai" };
+    case "cursor":
+      return { harness: "cursor-cli", vendor: "cursor" };
+    case "antigravity":
+      return { harness: "antigravity-cli", vendor: "google" };
+    default: {
+      const _exhaustive = provider;
+      return _exhaustive;
+    }
+  }
+}
+function triggerOf(selection, attempt) {
+  if (selection.failover) return "fallback";
+  if (attempt > 1) return "retry";
+  return "initial";
+}
+function nextAttempt(phase) {
+  const attempt = (attempts.get(phase) ?? 0) + 1;
+  attempts.set(phase, attempt);
+  return attempt;
+}
+function resetAgentInvocationState() {
+  attempts.clear();
+  lastFailure.clear();
+  issueSpend.reportedUsd = 0;
+  issueSpend.durationMs = 0;
+  issueSpend.executions = 0;
+  issueSpend.sawReported = false;
+}
+async function invokeSelectedAgent(invocation) {
+  const config = getActiveResilienceConfig();
+  const selection = invocation.forceProvider === void 0 ? await selectAgentForInvocation(invocation.phase, { config }) : await selectionForForced(invocation);
+  const attempt = nextAttempt(invocation.phase);
+  const publisher = getSessionPublisher();
+  publisher.publish({
+    type: "agent:attempt",
+    at: isoNow(),
+    attempt,
+    provider: selection.provider,
+    model: selection.settings.model,
+    primaryProvider: selection.primary
+  });
+  if (selection.failover) {
+    publisher.publish({
+      type: "failover",
+      at: isoNow(),
+      from: selection.primary,
+      to: selection.provider,
+      reason: selection.reason,
+      cooldownUntil: selection.cooldownUntil
+    });
+  }
+  const identity = declaredAgentIdentity(selection.provider);
+  const requested = selection.settings.model;
+  const routingCfg = await loadRoutingConfig();
+  const agentCfg = await loadAgentConfig();
+  const routingDecision = decideRouting({
+    phase: invocation.phase,
+    actualHarness: identity.harness,
+    mode: routingCfg.mode,
+    profile: routingCfg.profile,
+    skipScore: hasExplicitAgentSelection(agentCfg, getAgentCliOverrides()),
+    requiresExtraDirectories: (invocation.addDirs?.length ?? 0) > 0
+  });
+  const executionId = await beginExecution({
+    purpose: invocation.purpose ?? invocation.phase,
+    attempt,
+    trigger: triggerOf(selection, attempt),
+    triggerReason: selection.failover ? selection.reason : attempt > 1 ? lastFailure.get(invocation.phase) ?? null : null,
+    harness: identity.harness,
+    provider: identity.vendor,
+    harnessVersion: peekHarnessVersion(selection.provider) ?? null,
+    modelRequested: requested,
+    modelResolved: null,
+    modelSource: requested ? "config" : "unavailable",
+    ...routingDecision === null ? {} : { routingDecision }
+  });
+  const runner = runnerFor(selection.provider);
+  const ceiling = evaluateCeilings({
+    ceilings: routingCfg.ceilings,
+    spent: {
+      reportedUsd: issueSpend.reportedUsd,
+      costStatus: issueSpend.sawReported ? "reported" : "unknown",
+      durationMs: issueSpend.durationMs,
+      executions: issueSpend.executions
+    }
+  });
+  if (!ceiling.ok) {
+    const detail = `blocked by ${ceiling.binding} ceiling (${ceiling.numbers.spent} \u2265 ${ceiling.numbers.ceiling}). Enforced by Issue Flow, not by a harness flag.`;
+    const run2 = {
+      success: false,
+      result: "",
+      rawOutput: detail,
+      exitCode: 1,
+      usage: null,
+      error: detail,
+      agent: { provider: selection.provider, model: selection.settings.model },
+      harnessVersion: peekHarnessVersion(selection.provider)
+    };
+    if (executionId !== null) {
+      await endExecution({
+        id: executionId,
+        status: "failed",
+        error: detail,
+        exitCode: 1,
+        stopReason: ceiling.stopReason
+      });
+    }
+    return {
+      run: run2,
+      failure: null,
+      selection,
+      attempt,
+      health: null,
+      blocked: { stopReason: ceiling.stopReason, detail, actor: "human" }
+    };
+  }
+  if (runner.capabilities.nativeTimeout && invocation.timeout === 0 && resolveAntigravityTimeoutMs(invocation, selection.settings) === null) {
+    const run2 = {
+      success: false,
+      result: "",
+      rawOutput: "configuration: provider has nativeTimeout and received timeout: 0 without a ceiling.",
+      exitCode: 1,
+      usage: null,
+      error: "configuration: provider has nativeTimeout and received timeout: 0 without a ceiling. Set agent.antigravity.executeTimeout.",
+      agent: { provider: selection.provider, model: selection.settings.model },
+      harnessVersion: peekHarnessVersion(selection.provider)
+    };
+    if (executionId !== null) {
+      await endExecution({
+        id: executionId,
+        status: "failed",
+        error: run2.error,
+        exitCode: 1
+      });
+    }
+    const failure2 = classify({ source: "agent", exitCode: 1, stdout: run2.error });
+    return { run: run2, failure: failure2, selection, attempt, health: null };
+  }
+  if ((invocation.addDirs?.length ?? 0) > 0 && runner.capabilities.extraDirectories === "permission-file") {
+    const grant = selection.settings.cursor.permissionsFile === "none" ? { skipped: true, reason: "none" } : await ensureCursorStorageGrant({
+      mode: selection.settings.cursor.permissionsFile ?? "global"
+    });
+    if ("skipped" in grant && selection.settings.cursor.permissionsFile !== "none") {
+      throw new Error(
+        `Phase '${invocation.phase}' needs extraDirectories on '${selection.provider}', which only grants them via a permission file. Run \`issue-flow agent use cursor\` or set agent.cursor.permissionsFile.`
+      );
+    }
+  } else if ((invocation.addDirs?.length ?? 0) > 0 && runner.capabilities.extraDirectories === "none") {
+    throw new Error(
+      `Phase '${invocation.phase}' needs extraDirectories, but '${selection.provider}' cannot grant them.`
+    );
+  }
+  let run;
+  const startedMs = Date.now();
+  try {
+    run = await runner.run(
+      {
+        ...invocation,
+        onLine: (line) => {
+          publisher.publish({
+            type: "agent:activity",
+            at: isoNow(),
+            provider: selection.provider
+          });
+          invocation.onLine?.(line);
+        }
+      },
+      selection.settings
+    );
+  } catch (err) {
+    if (executionId !== null) {
+      await endExecution({
+        id: executionId,
+        status: "failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    throw err;
+  }
+  issueSpend.executions += 1;
+  issueSpend.durationMs += Math.max(0, Date.now() - startedMs);
+  if (run.usage?.costUsd !== void 0) {
+    issueSpend.reportedUsd += run.usage.costUsd;
+    issueSpend.sawReported = true;
+  }
+  const failure = run.success && run.exitCode === 0 ? null : classify({
+    source: "agent",
+    exitCode: run.exitCode,
+    stdout: run.rawOutput || run.error || ""
+  });
+  if (executionId !== null) {
+    await endExecution({
+      id: executionId,
+      status: failure === null ? "completed" : failure.kind === "timeout" ? "timeout" : "failed",
+      usage: run.usage,
+      error: failure === null ? null : run.error ?? run.rawOutput,
+      exitCode: run.exitCode,
+      modelResolved: run.agent.model,
+      modelSource: run.agent.model ? requested ? "config" : "provider" : requested ? "config" : "unavailable",
+      harnessVersion: run.harnessVersion ?? peekHarnessVersion(selection.provider) ?? null,
+      providerSessionId: run.sessionId ?? null
+    });
+  }
+  if (failure === null) lastFailure.delete(invocation.phase);
+  else lastFailure.set(invocation.phase, failure.kind);
+  let health = null;
+  if (selection.healthFile !== null) {
+    health = failure === null ? await recordProviderSuccess(selection.healthFile, selection.provider) : await recordProviderFailure(selection.healthFile, selection.provider, failure, {
+      config: config.providers
+    });
+  }
+  publisher.publish({
+    type: "agent:result",
+    at: isoNow(),
+    provider: selection.provider,
+    success: failure === null,
+    ...failure === null ? {} : { failureKind: failure.kind },
+    cooldownUntil: health?.cooldownUntil ?? null
+  });
+  if (failure === null) attempts.delete(invocation.phase);
+  return { run, failure, selection, attempt, health };
+}
+
+// src/core/decompose.ts
+var DECOMPOSITION_THRESHOLDS = {
+  /** Timeouts on the same phase. Two is already a pattern, not bad luck. */
+  timeoutsPerPhase: 2,
+  /** Stories in the plan. Past this, the plan is a backlog. */
+  stories: 15,
+  /** Iterations in a row that completed no story. */
+  barrenIterations: 5,
+  /** Files touched on the branch. */
+  filesTouched: 40,
+  /** Characters in the issue body. */
+  issueBodyChars: 2e4
+};
+var DECOMPOSITION_MIN_SIGNALS = 2;
+function timeoutsByPhase(journal) {
+  const counts = /* @__PURE__ */ new Map();
+  let phase = "(unknown)";
+  for (const { event } of parseJournal(journal)) {
+    if (event.type === "phase:start") {
+      phase = event.phase;
+      continue;
+    }
+    if (event.type !== "retry") continue;
+    const kind = event.kind;
+    const reason = event.reason ?? "";
+    const timedOut = kind === "timeout" || kind === "stalled" || /timed out|stalled/i.test(reason);
+    if (!timedOut) continue;
+    counts.set(phase, (counts.get(phase) ?? 0) + 1);
+  }
+  return counts;
+}
+function longestBarrenRun(journal) {
+  let passing = 0;
+  let current = 0;
+  let longest = 0;
+  for (const { event } of parseJournal(journal)) {
+    if (event.type === "iteration:start") {
+      current++;
+      longest = Math.max(longest, current);
+      continue;
+    }
+    if (event.type !== "stories:update") continue;
+    const nowPassing = event.stories.filter((story) => story.passes).length;
+    if (nowPassing > passing) current = 0;
+    passing = Math.max(passing, nowPassing);
+  }
+  return longest;
+}
+function assessDecomposition(input) {
+  const signals = [];
+  const journal = input.journal ?? "";
+  for (const [phase, count] of timeoutsByPhase(journal)) {
+    if (count >= DECOMPOSITION_THRESHOLDS.timeoutsPerPhase) {
+      signals.push({
+        id: "repeated-timeouts",
+        detail: `The '${phase}' phase timed out ${count} times (threshold: ${DECOMPOSITION_THRESHOLDS.timeoutsPerPhase}).`
+      });
+    }
+  }
+  const stories = input.plan?.userStories.length ?? 0;
+  if (stories > DECOMPOSITION_THRESHOLDS.stories) {
+    signals.push({
+      id: "story-count",
+      detail: `The plan has ${stories} user stories (threshold: ${DECOMPOSITION_THRESHOLDS.stories}).`
+    });
+  }
+  const barren = longestBarrenRun(journal);
+  if (barren >= DECOMPOSITION_THRESHOLDS.barrenIterations) {
+    signals.push({
+      id: "barren-iterations",
+      detail: `${barren} iterations in a row completed no story (threshold: ${DECOMPOSITION_THRESHOLDS.barrenIterations}).`
+    });
+  }
+  const files = input.filesTouched ?? 0;
+  if (files > DECOMPOSITION_THRESHOLDS.filesTouched) {
+    signals.push({
+      id: "files-touched",
+      detail: `${files} files were touched on this branch (threshold: ${DECOMPOSITION_THRESHOLDS.filesTouched}).`
+    });
+  }
+  const body = input.issueBody?.length ?? 0;
+  if (body > DECOMPOSITION_THRESHOLDS.issueBodyChars) {
+    signals.push({
+      id: "issue-size",
+      detail: `The issue body is ${body} characters (threshold: ${DECOMPOSITION_THRESHOLDS.issueBodyChars}).`
+    });
+  }
+  if (input.hitMaxIterations === true) {
+    signals.push({
+      id: "max-iterations",
+      detail: "The execute loop stopped because it ran out of iterations, not because it finished."
+    });
+  }
+  return { signals, oversized: signals.length >= DECOMPOSITION_MIN_SIGNALS };
+}
+var STORIES_PER_SUBISSUE = 5;
+function proposeSubIssues(plan) {
+  const pending = [...plan?.userStories ?? []].filter((story) => !story.passes).sort((a, b) => a.priority - b.priority);
+  if (pending.length === 0) return [];
+  const chunks = [];
+  for (let index = 0; index < pending.length; index += STORIES_PER_SUBISSUE) {
+    const stories = pending.slice(index, index + STORIES_PER_SUBISSUE);
+    const first = stories[0];
+    const last = stories[stories.length - 1];
+    const range = first === void 0 || last === void 0 || first.id === last.id ? first?.id ?? "" : `${first.id}\u2013${last.id}`;
+    chunks.push({
+      title: `${plan?.description ?? "Issue"} \u2014 part ${chunks.length + 1} (${range})`,
+      stories,
+      dependsOn: chunks.length === 0 ? [] : [chunks[chunks.length - 1]?.title ?? ""]
+    });
+  }
+  return chunks;
+}
+function buildDecompositionReport(input) {
+  const { issueNumber, assessment, plan, at } = input;
+  const proposals = proposeSubIssues(plan);
+  const lines = [];
+  lines.push(`# Issue #${issueNumber} looks larger than one run`, "");
+  lines.push(`Detected at ${at}.`, "");
+  lines.push(
+    "This is a report, not an action. Nothing has been split, and nothing will be",
+    "without you asking for it.",
+    ""
+  );
+  lines.push("## What was detected", "");
+  for (const signal of assessment.signals) {
+    lines.push(`- **${signal.id}** \u2014 ${signal.detail}`);
+  }
+  lines.push("");
+  if (proposals.length === 0) {
+    lines.push("## Proposed split", "");
+    lines.push(
+      "No pending user stories were found, so there is nothing to cut here.",
+      "The signals above are about the run rather than about the plan.",
+      ""
+    );
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("## Proposed split", "");
+  lines.push(
+    `The ${proposals.reduce((total, proposal) => total + proposal.stories.length, 0)} pending stories, in priority order, cut into ${proposals.length} sub-issues of at most ${STORIES_PER_SUBISSUE}. Each depends on the one before it, which is the only`,
+    "dependency shape that can be derived from the plan alone \u2014 read it as a starting",
+    "point, not as an answer.",
+    ""
+  );
+  for (const proposal of proposals) {
+    lines.push(`### ${proposal.title}`, "");
+    if (proposal.dependsOn.length > 0) {
+      lines.push(`Depends on: ${proposal.dependsOn.join(", ")}`, "");
+    }
+    for (const story of proposal.stories) {
+      lines.push(`- \`${story.id}\` ${story.title}`);
+    }
+    lines.push("");
+  }
+  lines.push("## What to do next", "");
+  lines.push(
+    "- Adjust the cut above until it matches how you would actually split the work;",
+    '- create the sub-issues (`issue-flow generate "\u2026"`) and run them as a queue;',
+    "- or decide the issue is fine as it is and re-run it \u2014 nothing here blocks that,",
+    "  beyond the report you are reading.",
+    ""
+  );
+  return `${lines.join("\n")}
+`;
+}
+
+// src/core/headless.ts
+import { readFile as readFile2 } from "fs/promises";
+import chalk from "chalk";
+var DEFAULT_HEADLESS_TIMEOUT_MS = 9e5;
+async function escalatedTimeout(timeoutMs, history) {
+  if (timeoutMs === 0 || history === void 0) return timeoutMs;
+  const journal = (await Promise.all(
+    history.journalFiles.map(async (file) => {
+      try {
+        return await readFile2(file, "utf-8");
+      } catch {
+        return "";
+      }
+    })
+  )).join("");
+  const timeouts = timeoutsByPhase(journal).get(history.phase) ?? 0;
+  if (timeouts < DECOMPOSITION_THRESHOLDS.timeoutsPerPhase) return timeoutMs;
+  return Math.min(timeoutMs * 2, Number.MAX_SAFE_INTEGER);
+}
+function printAgentEvent(event, onOutput) {
+  const icons = getIcons();
+  const colored = useColor();
+  const emit = onOutput ?? ((msg) => process.stdout.write(`${msg}
+`));
+  if (event.kind === "text") {
+    const lines = event.text.split("\n");
+    for (const textLine of lines) {
+      if (!textLine.trim()) continue;
+      const prefix2 = colored ? chalk.dim(`  ${icons.connector}  `) : `  ${icons.connector}  `;
+      const text = colored ? chalk.dim(textLine) : textLine;
+      emit(`${prefix2}${text}`);
+    }
+    return;
+  }
+  getSessionPublisher().publish({
+    type: "activity",
+    at: isoNow(),
+    tool: event.name,
+    detail: event.detail
+  });
+  const toolName = event.name.padEnd(12);
+  const prefix = colored ? chalk.dim(`  ${icons.connector}  `) : `  ${icons.connector}  `;
+  const toolIcon = colored ? chalk.cyan(icons.tool) : icons.tool;
+  const toolLabel = colored ? chalk.cyan(toolName) : toolName;
+  const contextText = event.detail ? colored ? chalk.dim(event.detail) : event.detail : "";
+  emit(`${prefix}${toolIcon} ${toolLabel} ${contextText}`);
+}
+async function invokeHeadlessAgent(invocation) {
+  const config = getActiveResilienceConfig();
+  if (config.providers?.failover !== true) {
+    return { run: (await invokeSelectedAgent(invocation)).run, retryExhausted: false };
+  }
+  let usage = null;
+  const outcome = await withRetry(() => invokeSelectedAgent(invocation), {
+    policy: (failure) => resolvePolicy(failure.kind, config),
+    signal: getShutdownSignal(),
+    evaluate: (selected) => selected.failure,
+    onAttempt: ({ value, failure, willRetry, delayMs, attempt }) => {
+      if (value.run.usage !== null) usage = sumUsage(usage, value.run.usage);
+      if (failure === null || !willRetry) return;
+      getSessionPublisher().publish({
+        type: "retry",
+        at: isoNow(),
+        attempt,
+        delaySeconds: delayMs / 1e3,
+        reason: failure.message,
+        kind: failure.kind
+      });
+    }
+  });
+  return {
+    run: usage === null ? outcome.value.run : { ...outcome.value.run, usage },
+    retryExhausted: outcome.exhausted
+  };
+}
+async function runHeadless(options) {
+  const {
+    prompt,
+    maxTurns = 10,
+    timeout: configuredTimeout = DEFAULT_HEADLESS_TIMEOUT_MS,
+    outputFormat = "json",
+    allowedTools,
+    addDirs,
+    statusMessage,
+    onOutput,
+    phase = "analyze",
+    permission = "workspace",
+    forceProvider,
+    purpose
+  } = options;
+  const timeout = await escalatedTimeout(configuredTimeout, options.timeoutHistory);
+  const settings = await resolveAgentFor(phase);
+  const verbose = isVerbose();
+  const effectiveOnOutput = onOutput ?? getOutputCallback();
+  if (verbose) {
+    const icons = getIcons();
+    const colored = useColor();
+    const emit = effectiveOnOutput ?? ((msg) => process.stdout.write(`${msg}
+`));
+    if (statusMessage) {
+      const msg = colored ? chalk.blue(`${icons.start} ${statusMessage}`) : `${icons.start} ${statusMessage}`;
+      emit(msg);
+    }
+    const connectorLine = colored ? chalk.dim(`  ${icons.connector}`) : `  ${icons.connector}`;
+    emit(connectorLine);
+    const startTime = Date.now();
+    const { run, retryExhausted } = await invokeHeadlessAgent({
+      prompt,
+      phase,
+      addDirs,
+      timeout,
+      permission,
+      maxTurns,
+      allowedTools,
+      ...forceProvider === void 0 ? {} : { forceProvider },
+      ...purpose === void 0 ? {} : { purpose },
+      onEvent: (event) => printAgentEvent(event, effectiveOnOutput)
+    });
+    const elapsedSec = Math.floor((Date.now() - startTime) / 1e3);
+    const durationStr = formatDuration(elapsedSec);
+    const doneLine = colored ? chalk.dim(`  ${icons.connector}  ${chalk.italic(`Done in ${durationStr}`)}`) : `  ${icons.connector}  Done in ${durationStr}`;
+    emit(doneLine);
+    emit(connectorLine);
+    return mapHeadlessResult(run, outputFormat, retryExhausted);
+  }
+  const spinner = statusMessage ? createSpinner(statusMessage).start() : null;
+  let timer = null;
+  if (spinner) {
+    timer = new ElapsedTimer((elapsed) => {
+      spinner.suffixText = useColor() ? chalk.dim(`(${elapsed})`) : `(${elapsed})`;
+    }).start();
+  }
+  try {
+    const { run, retryExhausted } = await invokeHeadlessAgent({
+      prompt,
+      phase,
+      addDirs,
+      timeout,
+      permission,
+      maxTurns,
+      allowedTools,
+      inactivityTimeoutMs: getInactivityTimeout(),
+      ...forceProvider === void 0 ? {} : { forceProvider },
+      ...purpose === void 0 ? {} : { purpose },
+      onEvent: (event) => {
+        if (event.kind === "text") return;
+        getSessionPublisher().publish({
+          type: "activity",
+          at: isoNow(),
+          tool: event.name,
+          detail: event.detail
+        });
+        getActivityCallback()?.({ tool: event.name, detail: event.detail });
+      }
+    });
+    const elapsed = timer?.stop() ?? 0;
+    const dur = useColor() ? chalk.dim(` (${formatDuration(elapsed)})`) : ` (${formatDuration(elapsed)})`;
+    if (!run.success) {
+      spinner?.fail(`${statusMessage}${dur}`);
+      return mapHeadlessResult(run, outputFormat, retryExhausted);
+    }
+    spinner?.succeed(`${statusMessage}${dur}`);
+    return mapHeadlessResult(run, outputFormat, retryExhausted);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const catchElapsed = timer?.stop() ?? 0;
+    const catchDur = useColor() ? chalk.dim(` (${formatDuration(catchElapsed)})`) : ` (${formatDuration(catchElapsed)})`;
+    spinner?.fail(`${statusMessage}${catchDur}`);
+    return {
+      success: false,
+      result: "",
+      cost: null,
+      error: message,
+      agent: { provider: settings.provider, model: settings.model }
+    };
+  }
+}
+function mapHeadlessResult(run, outputFormat, retryExhausted = false) {
+  if (outputFormat === "text") {
+    return {
+      success: run.success,
+      result: run.success ? run.rawOutput || run.result : "",
+      cost: null,
+      error: run.error,
+      agent: run.agent,
+      ...retryExhausted ? { retryExhausted: true } : {}
+    };
+  }
+  if (!run.success) {
+    return {
+      success: false,
+      result: "",
+      cost: null,
+      error: run.error,
+      agent: run.agent,
+      ...retryExhausted ? { retryExhausted: true } : {}
+    };
+  }
+  return {
+    success: true,
+    result: run.result,
+    cost: run.usage,
+    error: null,
+    agent: run.agent,
+    ...retryExhausted ? { retryExhausted: true } : {}
+  };
+}
+
+export {
+  evaluateCeilings,
+  spendFromCost,
+  resetAgentInvocationState,
+  invokeSelectedAgent,
+  assessDecomposition,
+  proposeSubIssues,
+  buildDecompositionReport,
+  DEFAULT_HEADLESS_TIMEOUT_MS,
+  runHeadless
+};
+//# sourceMappingURL=chunk-ARFVHC2F.js.map