@poetic-ai/poetic 1.42.0

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