@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-RAK5HOIJ.js

@@ -0,0 +1,459 @@
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  detectSandboxBoundaryAttestation,
+  isSandboxEnabledForProvider,
+  isSandboxEnforcementOperational,
+  isSandboxEnforcementSupported,
+  isSandboxSupported,
+  resolveSandboxBoundaryPolicy,
+  willSandboxBeActive
+} from "./chunk-2AICM4P3.js";
+import {
+  getKnownSandboxProviderIds,
+  probeProviderSandboxCapability
+} from "./chunk-5WCQRDRB.js";
+import {
+  formatLinuxDesktopConsentFailure,
+  formatLinuxHostClassNote,
+  resolveLinuxHostClass,
+  revokeLinuxHostPolicy,
+  writeLinuxHostPolicy
+} from "./chunk-RWREC3KJ.js";
+import {
+  POETIC_SANDBOX_BOUNDARY_POLICY,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/cli/commands/sandbox.ts
+import os from "os";
+import { Command } from "commander";
+var LINUX_DARWIN_HOST_REFUSAL = "Error: linux host-class declarations are ignored on macOS.\nmacOS write-capable runs require an accepted Seatbelt boundary.";
+var LINUX_DESKTOP_RISK_PARAGRAPH = [
+  "Warning: This Linux host is not Seatbelt-sandboxed.",
+  "",
+  "Provider CLIs Poetic launches can write anywhere $USER can, including",
+  "$HOME and credential paths (~/.ssh, ~/.config, ~/.poetic, cloud-token",
+  "stores). Poetic cannot generate a macOS-Seatbelt-equivalent filesystem",
+  "write boundary on Linux.",
+  "",
+  "If this is a VM, container, or isolated cloud instance:",
+  "  poetic sandbox trust linux --host isolated",
+  "",
+  "WSL is treated as a desktop."
+].join("\n");
+var WRITE_CAPABLE_ROOTS = /* @__PURE__ */ new Set([
+  "run",
+  "compete",
+  "build",
+  "autoloop",
+  "do",
+  "auto",
+  "swarm",
+  "loop",
+  "fusion",
+  "flywheel",
+  "sprint",
+  "backlog",
+  "plan"
+]);
+var NEVER_PROMPT_ROOTS = /* @__PURE__ */ new Set([
+  "sandbox",
+  "doctor",
+  "provider",
+  "providers",
+  "ask",
+  "config",
+  "help",
+  "init",
+  "status"
+]);
+function summarizeCapability(result) {
+  return {
+    capable: result.capable,
+    missingPaths: result.missing.map((entry) => entry.path)
+  };
+}
+function buildProviderStatus(providerId, probe) {
+  const attestation = detectSandboxBoundaryAttestation(providerId, providerId);
+  const capability = probe ? summarizeCapability(
+    probeProviderSandboxCapability(providerId, {
+      includeSharedPaths: false,
+      env: process.env
+    })
+  ) : null;
+  return {
+    providerId,
+    sandboxEnabled: isSandboxEnabledForProvider(providerId, providerId),
+    willBeActive: willSandboxBeActive(providerId, providerId),
+    enforcementOperational: isSandboxEnforcementOperational(providerId, providerId),
+    provenance: attestation.provenance,
+    boundaryEvidence: { ...attestation.evidence },
+    probed: probe,
+    capability
+  };
+}
+function resolveLinuxHostForCli(options = {}) {
+  return resolveLinuxHostClass({
+    ...options.env ? { env: options.env } : {},
+    ...options.stateDir ? { stateDir: options.stateDir } : {}
+  });
+}
+function toSandboxLinuxHostStatus(resolution) {
+  return {
+    hostClass: resolution.hostClass,
+    source: resolution.source,
+    writesAllowed: resolution.writesAllowed,
+    policyVersionCurrent: resolution.policyVersionCurrent,
+    acknowledgedPolicyVersion: resolution.acknowledgedPolicyVersion,
+    hypervisorHint: resolution.evidence.hypervisorHint
+  };
+}
+function formatLinuxHostAck(linuxHost) {
+  if (linuxHost.hostClass === "isolated") return "n/a (isolated)";
+  if (linuxHost.hostClass === "not-applicable") return "n/a";
+  if (linuxHost.acknowledgedPolicyVersion != null) {
+    return String(linuxHost.acknowledgedPolicyVersion);
+  }
+  return "none";
+}
+function buildSandboxStatus(options = {}) {
+  const envValue = readRawEnv(POETIC_SANDBOX_BOUNDARY_POLICY);
+  const effective = resolveSandboxBoundaryPolicy(envValue);
+  const probe = options.probe ?? false;
+  let providerIds = [];
+  if (options.provider) {
+    providerIds = [options.provider.toLowerCase()];
+  } else if (options.all) {
+    providerIds = getKnownSandboxProviderIds();
+  }
+  const linuxHost = toSandboxLinuxHostStatus(
+    resolveLinuxHostForCli({
+      ...options.env ? { env: options.env } : {},
+      ...options.stateDir ? { stateDir: options.stateDir } : {}
+    })
+  );
+  return {
+    platform: os.platform(),
+    sandboxSupported: isSandboxSupported(),
+    enforcementSupported: isSandboxEnforcementSupported(),
+    boundaryPolicy: {
+      effective,
+      envKey: POETIC_SANDBOX_BOUNDARY_POLICY.name,
+      envValue: envValue ?? null
+    },
+    linuxHost,
+    providers: providerIds.map((id) => buildProviderStatus(id, probe)),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function printLinuxHostHuman(linuxHost) {
+  console.log(`Host class: ${linuxHost.hostClass} (source=${linuxHost.source})`);
+  console.log(`Writes allowed: ${linuxHost.writesAllowed}`);
+  console.log(`Ack: ${formatLinuxHostAck(linuxHost)}`);
+  console.log(`Policy version: ${linuxHost.policyVersionCurrent}`);
+}
+function printHuman(status, scoped) {
+  console.log(`Platform: ${status.platform}`);
+  console.log(`Sandbox supported: ${status.sandboxSupported}`);
+  console.log(`Enforcement supported: ${status.enforcementSupported}`);
+  printLinuxHostHuman(status.linuxHost);
+  console.log(
+    `Boundary policy: ${status.boundaryPolicy.effective} (${status.boundaryPolicy.envKey}=${status.boundaryPolicy.envValue ?? "unset"})`
+  );
+  if (status.providers.length === 0) {
+    console.log("");
+    console.log("Info: no provider scope. Use --provider <id> or --all for per-provider state.");
+    return;
+  }
+  for (const p of status.providers) {
+    console.log("");
+    console.log(`Provider: ${p.providerId}`);
+    console.log(`  Sandbox enabled: ${p.sandboxEnabled}`);
+    console.log(`  Will be active: ${p.willBeActive}`);
+    console.log(`  Enforcement operational: ${p.enforcementOperational}`);
+    console.log(`  Provenance: ${p.provenance}`);
+    if (!p.capability) {
+      console.log("  Capability: not probed (run with --probe to test writability)");
+    } else {
+      console.log(`  Capability: ${p.capability.capable ? "capable" : "denied"}`);
+      if (!p.capability.capable && p.capability.missingPaths.length > 0) {
+        console.log(`  Missing paths: ${p.capability.missingPaths.join(", ")}`);
+      }
+    }
+  }
+  void scoped;
+}
+function printLinuxHostClassification(resolution, json) {
+  if (json) {
+    console.log(JSON.stringify(resolution, null, 2));
+    if (resolution.hostClass === "desktop-unacked") {
+      throw new ExitCodeError(1, formatLinuxDesktopConsentFailure(resolution));
+    }
+    return;
+  }
+  const linuxHost = toSandboxLinuxHostStatus(resolution);
+  console.log(`Platform: ${resolution.platform}`);
+  printLinuxHostHuman(linuxHost);
+  console.log("Evidence:");
+  console.log(`  durableHostClass: ${resolution.evidence.durableHostClass}`);
+  console.log(`  envHostClass: ${resolution.evidence.envHostClass}`);
+  console.log(`  containerAttested: ${resolution.evidence.containerAttested}`);
+  console.log(`  containerOsSignal: ${resolution.evidence.containerOsSignal}`);
+  console.log(`  ciVendor: ${resolution.evidence.ciVendor}`);
+  console.log(`  cloudAgent: ${resolution.evidence.cloudAgent}`);
+  console.log(`  hypervisorHint: ${resolution.evidence.hypervisorHint}`);
+  if (resolution.hostClass === "desktop-unacked") {
+    process.stderr.write(`${LINUX_DESKTOP_RISK_PARAGRAPH}
+`);
+    if (resolution.evidence.hypervisorHint) {
+      process.stderr.write(
+        `
+This host looks like a VM (${resolution.evidence.hypervisorHint}). If it is a dedicated isolated instance, run:
+  poetic sandbox trust linux --host isolated
+`
+      );
+    }
+    process.stderr.write(`
+${formatLinuxDesktopConsentFailure(resolution)}
+`);
+    throw new ExitCodeError(1, formatLinuxDesktopConsentFailure(resolution));
+  }
+  const note = resolution.note ?? formatLinuxHostClassNote(resolution);
+  if (note) {
+    console.log(`Info: ${note}`);
+  }
+}
+function runSandboxClassify(options = {}) {
+  const resolution = resolveLinuxHostForCli(options);
+  printLinuxHostClassification(resolution, options.json === true);
+}
+function refuseDarwinLinuxHostMutation(platform) {
+  if (platform !== "darwin") return;
+  process.stderr.write(`${LINUX_DARWIN_HOST_REFUSAL}
+`);
+  throw new ExitCodeError(1, LINUX_DARWIN_HOST_REFUSAL);
+}
+function runSandboxTrustLinux(options) {
+  const platform = options.platform ?? os.platform();
+  const host = options.host?.trim();
+  const ackDesktop = options.ackDesktop === true;
+  const revoke = options.revoke === true;
+  if (host && host !== "isolated") {
+    const message = "Error: --host only accepts isolated.";
+    process.stderr.write(`${message}
+`);
+    throw new ExitCodeError(1, message);
+  }
+  if (host === "isolated" && ackDesktop) {
+    const message = "Error: --host isolated and --ack-desktop are mutually exclusive.";
+    process.stderr.write(`${message}
+`);
+    throw new ExitCodeError(1, message);
+  }
+  if (revoke && (host === "isolated" || ackDesktop)) {
+    const message = "Error: --revoke cannot be combined with --host or --ack-desktop.";
+    process.stderr.write(`${message}
+`);
+    throw new ExitCodeError(1, message);
+  }
+  if (!revoke && host !== "isolated" && !ackDesktop) {
+    const message = "Error: specify --host isolated, --ack-desktop, or --revoke.";
+    process.stderr.write(`${message}
+`);
+    throw new ExitCodeError(1, message);
+  }
+  refuseDarwinLinuxHostMutation(platform);
+  const writeInput = {
+    source: "cli",
+    ...options.env ? { env: options.env } : {},
+    ...options.stateDir ? { stateDir: options.stateDir } : {}
+  };
+  if (revoke) {
+    revokeLinuxHostPolicy({
+      ...options.stateDir ? { stateDir: options.stateDir } : {}
+    });
+    console.log("Info: revoked Linux host-class policy for this user state.");
+    return;
+  }
+  if (host === "isolated") {
+    writeLinuxHostPolicy({
+      hostClass: "isolated",
+      ...writeInput
+    });
+    console.log("Info: recorded Linux host class isolated for this user state.");
+    return;
+  }
+  process.stderr.write(`${LINUX_DESKTOP_RISK_PARAGRAPH}
+`);
+  writeLinuxHostPolicy({
+    hostClass: "desktop",
+    ...writeInput
+  });
+  console.log("Info: recorded Linux desktop write consent for this user state.");
+}
+function collectCommandPathNames(command) {
+  const names = [];
+  let current = command;
+  while (current?.parent) {
+    const name = current.name();
+    if (name) names.unshift(name);
+    current = current.parent;
+  }
+  return names;
+}
+function isWriteCapableCommand(commandNames) {
+  const root = commandNames[0];
+  if (!root || NEVER_PROMPT_ROOTS.has(root)) return false;
+  if (!WRITE_CAPABLE_ROOTS.has(root)) return false;
+  if (root === "sprint") return commandNames.includes("run");
+  if (root === "backlog") return commandNames.includes("execute");
+  if (root === "plan") {
+    if (commandNames.includes("execute")) return true;
+    if (commandNames.includes("sprint") && commandNames.includes("run")) return true;
+    return commandNames.length === 1;
+  }
+  return true;
+}
+function shouldPromptLinuxDesktopConsent(options) {
+  const platform = options.platform ?? os.platform();
+  if (platform !== "linux") return false;
+  if (options.hostClass !== "desktop-unacked") return false;
+  if (options.isTTY !== true) return false;
+  return isWriteCapableCommand(options.commandNames);
+}
+async function confirmYesNoViaReadline(question) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(question, (value) => resolve(value));
+    });
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function maybePromptLinuxDesktopConsent(options) {
+  const platform = options.platform ?? os.platform();
+  const isTTY = options.isTTY ?? Boolean(process.stdin.isTTY === true && process.stdout.isTTY === true);
+  const resolution = resolveLinuxHostForCli({
+    ...options.env ? { env: options.env } : {},
+    ...options.stateDir ? { stateDir: options.stateDir } : {}
+  });
+  if (!shouldPromptLinuxDesktopConsent({
+    commandNames: options.commandNames,
+    hostClass: resolution.hostClass,
+    isTTY,
+    platform
+  })) {
+    return;
+  }
+  process.stderr.write(`${LINUX_DESKTOP_RISK_PARAGRAPH}
+`);
+  if (resolution.evidence.hypervisorHint) {
+    process.stderr.write(
+      `
+This host looks like a VM (${resolution.evidence.hypervisorHint}). If it is a dedicated isolated instance, run:
+  poetic sandbox trust linux --host isolated
+`
+    );
+  }
+  const confirm = options.confirm ?? confirmYesNoViaReadline;
+  const accepted = await confirm("Proceed and remember this consent for this user state? [y/N] ");
+  if (accepted) {
+    writeLinuxHostPolicy({
+      hostClass: "desktop",
+      source: "cli",
+      ...options.env ? { env: options.env } : {},
+      ...options.stateDir ? { stateDir: options.stateDir } : {}
+    });
+    return;
+  }
+  const message = formatLinuxDesktopConsentFailure(resolution);
+  process.stderr.write(`${message}
+`);
+  throw new ExitCodeError(1, message);
+}
+async function offerLinuxDesktopTrustIfInteractive(options = {}) {
+  const platform = options.platform ?? os.platform();
+  const isTTY = options.isTTY ?? Boolean(process.stdin.isTTY === true && process.stdout.isTTY === true);
+  if (platform !== "linux" || !isTTY) return "not-needed";
+  const resolution = resolveLinuxHostForCli({
+    ...options.env ? { env: options.env } : {},
+    ...options.stateDir ? { stateDir: options.stateDir } : {}
+  });
+  if (resolution.hostClass !== "desktop-unacked") return "not-needed";
+  console.log("Info: this user state will need write consent before poetic run.");
+  process.stderr.write(`${LINUX_DESKTOP_RISK_PARAGRAPH}
+`);
+  const confirm = options.confirm ?? confirmYesNoViaReadline;
+  const accepted = await confirm("Record desktop write consent for this user state now? [y/N] ");
+  if (!accepted) {
+    console.log(
+      "Info: skipped. Before poetic run: poetic sandbox trust linux --ack-desktop\nIf this is a VM, container, or cloud instance: poetic sandbox trust linux --host isolated"
+    );
+    return "skipped";
+  }
+  writeLinuxHostPolicy({
+    hostClass: "desktop",
+    source: "cli",
+    ...options.env ? { env: options.env } : {},
+    ...options.stateDir ? { stateDir: options.stateDir } : {}
+  });
+  console.log("Info: recorded Linux desktop write consent for this user state.");
+  return "acked";
+}
+function createSandboxCommand() {
+  const sandbox = new Command("sandbox").description(
+    "Inspect sandbox state and declare Linux host-class write policy"
+  );
+  sandbox.command("status").description("Show resolved sandbox boundary/provenance state (read-only by default)").option("--provider <id>", "Scope to a single provider id").option("--all", "Show all known providers").option("--json", "Output as JSON").option(
+    "--probe",
+    "Run the active write-probe (PERFORMS WRITES: creates+removes a probe file under each provider state dir; reflects live CODEX_HOME/XDG_*)"
+  ).action((options) => {
+    const status = buildSandboxStatus({
+      provider: options.provider,
+      all: options.all,
+      probe: options.probe
+    });
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    printHuman(status, Boolean(options.provider));
+  });
+  sandbox.command("classify").description("Dry-run Linux host-class resolution (no writes)").option("--json", "Output as JSON").action((options) => {
+    runSandboxClassify({ json: options.json === true });
+  });
+  const trust = sandbox.command("trust").description("Persist or revoke the user-scoped Linux host-class policy");
+  trust.command("linux").description("Declare this Linux host isolated, acknowledge desktop risk, or revoke").option("--host <class>", "Persist host class (isolated)").option("--ack-desktop", "Print the risk paragraph and persist desktop consent").option("--revoke", "Delete the durable Linux host-class file").action((options) => {
+    runSandboxTrustLinux({
+      host: options.host,
+      ackDesktop: options.ackDesktop === true,
+      revoke: options.revoke === true
+    });
+  });
+  return sandbox;
+}
+
+export {
+  LINUX_DARWIN_HOST_REFUSAL,
+  LINUX_DESKTOP_RISK_PARAGRAPH,
+  resolveLinuxHostForCli,
+  toSandboxLinuxHostStatus,
+  formatLinuxHostAck,
+  buildSandboxStatus,
+  printLinuxHostClassification,
+  runSandboxClassify,
+  runSandboxTrustLinux,
+  collectCommandPathNames,
+  isWriteCapableCommand,
+  shouldPromptLinuxDesktopConsent,
+  maybePromptLinuxDesktopConsent,
+  offerLinuxDesktopTrustIfInteractive,
+  createSandboxCommand
+};
+//# sourceMappingURL=chunk-RAK5HOIJ.js.map

package/dist/chunk-RDFRCT64.js

@@ -0,0 +1,168 @@
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+
+// src/core/anchored-chat/capabilities.ts
+var ANCHORED_CHAT_FEATURE_ENV = "POETIC_TUI_ANCHOR";
+var CLAUDE_CONVERSATION = {
+  operations: ["start", "load/resume", "prompt", "cancel"],
+  output: "streaming",
+  readOnly: "enforced"
+};
+var CURSOR_CONVERSATION = {
+  operations: ["start", "load/resume", "prompt", "cancel"],
+  output: "buffered",
+  readOnly: "enforced",
+  qualification: "version"
+};
+var CODEX_CONVERSATION = {
+  operations: ["start", "prompt", "cancel"],
+  output: "buffered",
+  readOnly: "enforced"
+};
+var ANCHORED_PROVIDER_CAPABILITIES = {
+  claude: {
+    provider: "claude",
+    nativeResume: true,
+    readOnlyEnforced: true,
+    transcriptStrategy: "native-resume",
+    stability: "stable",
+    requiresQa: false,
+    conversation: CLAUDE_CONVERSATION
+  },
+  cursor: {
+    provider: "cursor",
+    nativeResume: true,
+    readOnlyEnforced: true,
+    transcriptStrategy: "native-resume",
+    stability: "experimental",
+    requiresQa: true,
+    conversation: CURSOR_CONVERSATION
+  },
+  codex: {
+    provider: "codex",
+    nativeResume: false,
+    readOnlyEnforced: true,
+    transcriptStrategy: "poetic-last-n",
+    stability: "stable",
+    requiresQa: false,
+    conversation: CODEX_CONVERSATION
+  },
+  gemini: {
+    provider: "gemini",
+    nativeResume: false,
+    readOnlyEnforced: false,
+    transcriptStrategy: "poetic-last-n",
+    stability: "experimental",
+    requiresQa: true
+  },
+  opencode: {
+    provider: "opencode",
+    nativeResume: false,
+    readOnlyEnforced: false,
+    transcriptStrategy: "poetic-last-n",
+    stability: "experimental",
+    requiresQa: true
+  }
+};
+function isAnchoredChatEnabled(env = process.env) {
+  const value = env[ANCHORED_CHAT_FEATURE_ENV];
+  if (value === void 0) return true;
+  const normalized = value.trim().toLowerCase();
+  return !(normalized === "0" || normalized === "false" || normalized === "off");
+}
+function getAnchoredProviderCapability(provider) {
+  const builtIn = ANCHORED_PROVIDER_CAPABILITIES[provider];
+  if (builtIn) return builtIn;
+  const declared = registryConversationCapability(provider);
+  if (!declared) {
+    throw new Error(`Provider ${provider} does not declare TUI conversation capabilities.`);
+  }
+  const nativeResume = declared.operations.includes("load/resume");
+  return {
+    provider,
+    nativeResume,
+    readOnlyEnforced: declared.readOnly === "enforced",
+    transcriptStrategy: nativeResume ? "native-resume" : "poetic-last-n",
+    stability: "experimental",
+    requiresQa: declared.qualification !== void 0,
+    conversation: declared
+  };
+}
+function resolveTuiConversationCapability(provider, registryCapability) {
+  if (registryCapability) {
+    return {
+      operations: registryCapability.operations,
+      output: registryCapability.output,
+      readOnly: registryCapability.read_only,
+      qualification: registryCapability.qualification
+    };
+  }
+  return isAnchoredChatProvider(provider) ? getAnchoredProviderCapability(provider).conversation : void 0;
+}
+function isAnchoredChatProvider(value) {
+  return value in ANCHORED_PROVIDER_CAPABILITIES || registryConversationCapability(value) !== void 0;
+}
+function listAnchoredChatProviders() {
+  const configured = safelyGetEnabledProviderIds().filter(
+    (provider) => registryConversationCapability(provider) !== void 0
+  );
+  return [.../* @__PURE__ */ new Set([...Object.keys(ANCHORED_PROVIDER_CAPABILITIES), ...configured])];
+}
+function listEnforcedAnchorProviders() {
+  return listAnchoredChatProviders().filter((provider) => {
+    try {
+      return getAnchoredProviderCapability(provider).readOnlyEnforced;
+    } catch {
+      return false;
+    }
+  });
+}
+function isEnforcedAnchorProvider(value) {
+  if (!isAnchoredChatProvider(value)) return false;
+  try {
+    return getAnchoredProviderCapability(value).readOnlyEnforced;
+  } catch {
+    return false;
+  }
+}
+function registryConversationCapability(provider) {
+  try {
+    const declared = ProviderRegistry.getProviderConfig(provider).capabilities.tui_conversation;
+    if (!declared) return void 0;
+    return {
+      operations: declared.operations,
+      output: declared.output,
+      readOnly: declared.read_only,
+      qualification: declared.qualification
+    };
+  } catch {
+    return void 0;
+  }
+}
+function safelyGetEnabledProviderIds() {
+  try {
+    return ProviderRegistry.getEnabledProviders().map((provider) => provider.id);
+  } catch {
+    return [];
+  }
+}
+function formatEnforcedAnchorProviderList() {
+  const providers = listEnforcedAnchorProviders();
+  if (providers.length <= 1) return providers.join("");
+  const head = providers.slice(0, -1).join(", ");
+  return `${head}, or ${providers[providers.length - 1]}`;
+}
+
+export {
+  ANCHORED_CHAT_FEATURE_ENV,
+  ANCHORED_PROVIDER_CAPABILITIES,
+  isAnchoredChatEnabled,
+  getAnchoredProviderCapability,
+  resolveTuiConversationCapability,
+  isAnchoredChatProvider,
+  listAnchoredChatProviders,
+  isEnforcedAnchorProvider,
+  formatEnforcedAnchorProviderList
+};
+//# sourceMappingURL=chunk-RDFRCT64.js.map

package/dist/chunk-RE5VZDFQ.js

@@ -0,0 +1,58 @@
+// src/core/providers/routing/generated/provider-concurrency.ts
+var GENERATED_PROVIDER_CONCURRENCY = {
+  claude: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Two concurrent local Claude CLI subprocesses - the shared local-provider baseline. This is a process count, not a request rate, so it does not encode the quota of any one backend or account. It is also not a promise about throughput, since an account that cannot sustain two concurrent runs surfaces its own throttling error from the provider CLI, after which the operator lowers this value. The observed-rate-limit penalty is a mitigation within a single run, not a justification for this number - it is reactive, recorded only after a leg completes, process-local, and matched on error text that does not cover every backend phrasing, so it cannot stop the first two legs from starting. Increase in user provider config after validating host resources and account quota."
+  },
+  codex: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Codex runs as a local CLI subprocess. Limit concurrency to the provider memory budget of two processes to avoid local CPU, memory, and state contention."
+  },
+  cursor: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. The previous 1 was justified by matching the max_processes budget below, but that field has no runtime consumer - Memory Guardian reads only the warn/critical/emergency thresholds in this block - so the two were never reconciled at runtime and agreement between them was never enforcing anything. No measured per-seat licensing or host-resource limit is known that distinguishes Cursor from the other local CLI providers, so it takes the shared baseline. Lower it in user provider config if a seat limit surfaces from the provider CLI."
+  },
+  grok: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: 'Baseline local-provider concurrency. The previous 1 deferred to "broader smoke/A-B data", which was never gathered, so it was indefinite caution rather than a measured limit. Grok CLI also supports native subagent fanout, which multiplies WITHIN a single leg and is opt-in, so this number bounds Poetic-owned processes only and is independent of that fanout. Lower it in user provider config if host contention appears when subagents are enabled.'
+  },
+  opencode: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. OpenCode executes through a local CLI process model (one subprocess per run) with the same host cost profile as the other local providers, so it takes the shared baseline rather than a higher number. This LOWERS the previous default of 5, which was never measured and was the outlier in this file - it also exceeded the max_processes budget declared below, a contradiction nothing detected because that field has no runtime consumer. Raise it in user provider config after validating host resources and upstream API quota. No internal batching support."
+  },
+  antigravity: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Google Antigravity CLI runs a local agent process with workspace tools and subagents. Keep default concurrency at one until workspace edit behavior is validated, to avoid competing file edits and local resource contention."
+  },
+  copilot: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. Copilot CLI runs locally with per-seat licensing and the same host cost profile as the other local providers. This LOWERS the previous default of 3, which exceeded the max_processes budget declared below - a contradiction nothing detected because that field has no runtime consumer. Raise it in user provider config after validating host resources and seat entitlement."
+  },
+  kiro: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Kiro CLI headless mode runs a local agent process with workspace tools. Keep default concurrency at one while experimental to avoid competing file edits and local resource contention."
+  },
+  gemini: {
+    maxConcurrent: 1,
+    hybridBatching: true,
+    rationale: "The only local provider below the shared baseline of 2. This was previously described as a CORRECTNESS ceiling on the grounds that concurrent Gemini CLI processes share mutable state under ~/.gemini because the CLI ignores GEMINI_CONFIG_DIR. That reasoning is now obsolete, because the parallel executor gives each worktree an isolated HOME and restores per-process isolation by a different mechanism than the one that broke. So this is unverified caution rather than a correctness requirement - two concurrent Gemini legs have simply never been exercised. Raise it to the baseline after one live 2-concurrent run confirms the isolated HOME holds. Internal batching remains enabled and is unaffected."
+  },
+  pi: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Pi runs a local agent process with workspace edit tools against an operator-configured backend of unknown rate limits. Keep concurrency at one while experimental to avoid competing file edits."
+  }
+};
+
+export {
+  GENERATED_PROVIDER_CONCURRENCY
+};
+//# sourceMappingURL=chunk-RE5VZDFQ.js.map