@poetic-ai/poetic 1.42.0

package/dist/chunk-TAJPCXSB.js

@@ -0,0 +1,13 @@
+// src/core/runtime/runtime-readiness-diagnostics.ts
+var NODE_VERSION_MISMATCH_MARKER = "Node.js version mismatch";
+var NATIVE_TELEMETRY_UNAVAILABLE_MARKER = "Native telemetry is unavailable";
+var NATIVE_SQLITE_INITIALIZATION_MARKER = "[sqlite-wrapper] Failed to initialize native better-sqlite3";
+var TELEMETRY_FALLBACK_MARKER = "Telemetry fallback";
+
+export {
+  NODE_VERSION_MISMATCH_MARKER,
+  NATIVE_TELEMETRY_UNAVAILABLE_MARKER,
+  NATIVE_SQLITE_INITIALIZATION_MARKER,
+  TELEMETRY_FALLBACK_MARKER
+};
+//# sourceMappingURL=chunk-TAJPCXSB.js.map

package/dist/chunk-TAOOYK3P.js

@@ -0,0 +1,358 @@
+import {
+  GENERATED_PROVIDER_CONCURRENCY
+} from "./chunk-RE5VZDFQ.js";
+
+// src/core/providers/routing/provider-capabilities.ts
+function getProviderConcurrencyLimit(provider) {
+  return GENERATED_PROVIDER_CONCURRENCY[provider]?.maxConcurrent ?? 4;
+}
+var PROVIDER_CAPABILITY_MATRIX = {
+  claude: {
+    provider: "claude",
+    // overfit-allow[B]: central registry entry, not a default or fallback
+    strengths: [
+      "Exceptional long-context reasoning",
+      "Strong judgement for reviews and comparisons",
+      "Consistent output formatting for multi-step plans"
+    ],
+    limitations: [
+      "Higher latency than local providers",
+      "Cloud-only availability",
+      "Cost tier requires selective usage for bulk runs"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("claude"),
+    preferredDomains: ["backend", "docs", "testing"],
+    supportedDomains: ["frontend", "backend", "docs", "testing", "infra", "general"],
+    costTier: "high",
+    setup: "cloud",
+    speedRating: 3,
+    reasoningRating: 5,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "planning", "docs", "tests"],
+    webSearch: { mode: "default" },
+    notes: [
+      "Use when tasks need deep analysis, comparisons, or synthesised feedback.",
+      "Pairs well with evaluation or when `compareIntent` is detected."
+    ]
+  },
+  cursor: {
+    provider: "cursor",
+    strengths: [
+      "Fast iteration on local repositories",
+      "High precision for surgical edits and refactors",
+      "Excellent context awareness for existing codebases"
+    ],
+    limitations: [
+      "Local concurrency is bounded by workstation CPU, memory, and editor resources",
+      "Struggles with extremely large prompts without manual curation"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("cursor"),
+    preferredDomains: ["frontend", "backend", "testing"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "general"],
+    costTier: "low",
+    setup: "hybrid",
+    speedRating: 4,
+    reasoningRating: 3,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "tests", "docs"],
+    webSearch: {
+      mode: "default",
+      // Validated live 2026-08-12: `cursor-agent -p --force` invoked its native
+      // `web_search` tool and returned a correctly grounded current answer with a
+      // source URL. Poetic imposes no web-tool restriction on cursor, so clearance
+      // needs no argv change — only an accurate capability mode.
+      note: "Native web_search validated live 2026-08-12; Poetic imposes no web-tool restriction, so no enable flag is required."
+    },
+    notes: [
+      "Leverage for quick fixes, file-focused work, and interactive sessions.",
+      "Ideal fallback when local control or offline access is required.",
+      "Runs through Poetic local execution; setup remains hybrid for routing classification."
+    ]
+  },
+  codex: {
+    provider: "codex",
+    strengths: [
+      "Balanced reasoning with rapid synthesis",
+      "Native local repository execution through the Codex CLI",
+      "Strong fit for exploratory builds with git-tracked delivery"
+    ],
+    limitations: [
+      "Requires API quota management",
+      "Evaluation loops need guardrails to avoid hallucinated diffs"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("codex"),
+    preferredDomains: ["backend", "data", "infra"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 4,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "docs", "tests"],
+    webSearch: { mode: "default", enableArgs: ["--enable", "web_search_request"] },
+    notes: ["Default choice for balanced local auto orchestration."]
+  },
+  gemini: {
+    provider: "gemini",
+    strengths: [
+      "High throughput with reliable batching",
+      "Cost-effective for large parallel workloads",
+      "Strong multilingual and documentation support"
+    ],
+    limitations: [
+      "Reasoning quality can dip on highly novel code patterns",
+      "Requires careful prompt grounding for refactors"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("gemini"),
+    preferredDomains: ["frontend", "docs", "testing", "data"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "low",
+    setup: "cloud",
+    speedRating: 5,
+    reasoningRating: 3,
+    reliabilityRating: 3,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "docs", "tests", "planning"],
+    webSearch: {
+      mode: "probe",
+      note: "Web-search-capable in model-update; gate native research on a runtime probe."
+    },
+    notes: [
+      "Great for large-scale validation, documentation sweeps, and test generation.",
+      "Best used alongside a higher-reasoning fallback provider."
+    ]
+  },
+  opencode: {
+    provider: "opencode",
+    strengths: [
+      "CLI-first local execution with predictable workspace access",
+      "Strong code generation with fast iteration loops",
+      "Good fit for competitive runs where deterministic tooling is required"
+    ],
+    limitations: [
+      "Local execution is bounded by workstation CPU/memory",
+      "No provider-side auto-batching; concurrency must be managed externally",
+      "Requires local CLI setup and authentication"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("opencode"),
+    preferredDomains: ["backend", "testing", "infra"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 4,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "tests", "docs", "planning"],
+    webSearch: {
+      mode: "default",
+      // Validated live 2026-08-12: `opencode run` invoked its native `websearch`
+      // tool and returned a correctly grounded current answer with a source URL.
+      // Poetic imposes no web-tool restriction on opencode, so clearance needs no
+      // argv change — only an accurate capability mode.
+      note: "Native websearch validated live 2026-08-12; Poetic imposes no web-tool restriction, so no enable flag is required."
+    },
+    notes: [
+      "Designed for local CLI execution (OpenCode) with provider-aware concurrency limits.",
+      "Use for local competitions where cloud providers are unavailable or restricted."
+    ]
+  },
+  copilot: {
+    provider: "copilot",
+    strengths: [
+      "Generates focused diffs and markdown guidance from the terminal",
+      "Great for iterative refactors and docstrings",
+      "Runs locally via the Copilot CLI (per-seat licensing)",
+      "Executes code via CLI with --allow-all-tools"
+    ],
+    limitations: [
+      "Limited multi-file awareness without explicit file hints",
+      "May require careful tool allowlist configuration"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("copilot"),
+    preferredDomains: ["frontend", "backend", "testing", "docs"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 4,
+    reasoningRating: 3,
+    reliabilityRating: 4,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "planning", "docs", "tests"],
+    webSearch: {
+      mode: "default",
+      note: "Poetic denies the fetch tool by default; the denial is lifted on a cleared native-research run."
+    },
+    notes: [
+      "Install the Copilot CLI (`npm install -g @github/copilot`) and launch `copilot` once to complete sign-in.",
+      "Executes code with --allow-all-tools flag enabled."
+    ]
+  },
+  grok: {
+    provider: "grok",
+    strengths: [
+      "Headless local CLI execution through Grok Build",
+      "Good fit for code-oriented tasks when xAI CLI auth is already configured",
+      "Supports tool use through the Grok CLI while Poetic owns outer sandboxing"
+    ],
+    limitations: [
+      "Local CLI setup and authentication are required",
+      "Reasoning effort is disabled until a validated Grok model supports it",
+      "Concurrency should remain low to avoid local process and provider contention"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("grok"),
+    preferredDomains: ["backend", "testing", "general"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 3,
+    executionModel: "code-executor",
+    workspaceEditSupport: "patch-protocol",
+    expectedOutputTypes: ["code", "tests", "docs", "planning"],
+    webSearch: {
+      mode: "off",
+      // Not a deferral: analysis-intent runs (every Fusion run) lock Grok's
+      // positive tool list to Read,Grep and add --deny MCPTool(*). Grok's search
+      // surface is MCP-dispatched, so it is unreachable without relaxing that
+      // fail-closed read-only posture — a security decision, not a labelling one.
+      note: "Unreachable on analysis runs: the locked read-only posture allows only Read,Grep and denies MCPTool(*), which is Grok search surface."
+    },
+    notes: [
+      "Use explicit Grok variants when local Grok Build CLI execution is desired.",
+      "Poetic passes prompts with --prompt-file and does not pass Grok sandbox or effort flags."
+    ]
+  },
+  kiro: {
+    provider: "kiro",
+    strengths: [
+      "Headless local CLI automation through Kiro CLI",
+      "Workspace tool use through a config-driven templated provider",
+      "Reusable YAML-based auth and model discovery probes"
+    ],
+    limitations: [
+      "Experimental provider pending authenticated end-to-end validation",
+      "Requires KIRO_API_KEY for headless automation",
+      "Concurrency is intentionally limited while workspace edit behavior is validated"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("kiro"),
+    preferredDomains: ["backend", "testing", "general"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    workspaceEditSupport: "passthrough",
+    expectedOutputTypes: ["code", "tests", "docs", "planning"],
+    webSearch: {
+      mode: "probe",
+      note: "Poetic imposes no web-tool restriction on kiro; native search capability is unvalidated, so clearance requires a live probe."
+    },
+    notes: [
+      "Use explicit Kiro variants while the provider remains experimental.",
+      "Poetic invokes Kiro with chat --no-interactive --trust-all-tools, delivering the prompt via stdin (positional prompts fail with ENOENT)."
+    ]
+  },
+  pi: {
+    provider: "pi",
+    strengths: [
+      "Local CLI automation through the Pi coding agent",
+      "Backend-agnostic: one adapter fronts cloud APIs and local OpenAI-compatible endpoints",
+      "Structured JSON event stream with per-turn usage and cost",
+      "Native thinking-level control across all five Poetic effort levels"
+    ],
+    limitations: [
+      "Experimental provider pending authenticated end-to-end validation",
+      // Pi is a host, not a vendor: cost, speed, and reasoning quality are
+      // properties of the operator-configured backend, not of Pi. These ratings
+      // are deliberately conservative because the real values are unknowable
+      // from the provider id alone.
+      "Cost and capability depend on the operator-configured backend, so ratings are conservative",
+      "Concurrency is intentionally limited to one while workspace edit behavior is validated",
+      "Session resume is unsupported (--session prompts interactively and deadlocks headless)"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("pi"),
+    preferredDomains: ["backend", "testing", "general"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    workspaceEditSupport: "passthrough",
+    expectedOutputTypes: ["code", "tests", "docs", "planning"],
+    webSearch: {
+      mode: "off",
+      note: "No native web search tool in Pi built-ins (read, bash, edit, write, grep, find, ls)."
+    },
+    notes: [
+      "Use explicit Pi variants while the provider remains experimental.",
+      "Poetic invokes Pi with --print --mode json --no-approve and a positional prompt.",
+      "Pi --provider names the INNER inference backend; Poetic never emits it and passes qualified backend/model ids through --model."
+    ]
+  },
+  antigravity: {
+    provider: "antigravity",
+    strengths: [
+      "Google-provided Antigravity CLI integration through the agy binary",
+      "Terminal-first access to Antigravity agents and subagents",
+      "Config-driven templated provider that can track CLI flag changes in YAML"
+    ],
+    limitations: [
+      "Validated 2026-07-25 against authenticated agy 1.1.7; passive auth readiness reports unknown (no non-interactive agy probe)",
+      "Google documentation emphasizes the TUI; print-mode automation must be validated per installed CLI version",
+      "Model selection is fixed to the CLI default until a supported agy model flag is verified",
+      "Concurrency is intentionally limited while workspace edit behavior is validated"
+    ],
+    maxConcurrent: getProviderConcurrencyLimit("antigravity"),
+    preferredDomains: ["backend", "testing", "general"],
+    supportedDomains: ["frontend", "backend", "testing", "docs", "infra", "data", "general"],
+    costTier: "medium",
+    setup: "local",
+    speedRating: 3,
+    reasoningRating: 3,
+    reliabilityRating: 2,
+    executionModel: "code-executor",
+    workspaceEditSupport: "passthrough",
+    expectedOutputTypes: ["code", "tests", "docs", "planning"],
+    webSearch: {
+      mode: "probe",
+      note: "Poetic imposes no web-tool restriction on antigravity; native search capability is unvalidated, so clearance requires a live probe."
+    },
+    notes: [
+      "Successor to the sunsetting gemini provider; on default surfaces as supported beta.",
+      "Poetic invokes the Google agy CLI with --print and --dangerously-skip-permissions in headless mode."
+    ]
+  }
+};
+function getProviderCapability(provider) {
+  const capability = PROVIDER_CAPABILITY_MATRIX[provider];
+  if (!capability) {
+    throw new Error(`Unknown provider capability: ${provider}`);
+  }
+  return capability;
+}
+function resolveWebSearchMode(provider) {
+  const capability = PROVIDER_CAPABILITY_MATRIX[provider];
+  return capability?.webSearch?.mode ?? "off";
+}
+
+export {
+  PROVIDER_CAPABILITY_MATRIX,
+  getProviderCapability,
+  resolveWebSearchMode
+};
+//# sourceMappingURL=chunk-TAOOYK3P.js.map

package/dist/chunk-TDSEX5CF.js

@@ -0,0 +1,24 @@
+// src/planning/errors.ts
+var StaleVersionError = class extends Error {
+  constructor(currentVersion, expectedVersion, entityId, field, lastModifiedBy) {
+    super(
+      `Stale version for ${entityId}: expected ${expectedVersion}, current is ${currentVersion}`
+    );
+    this.currentVersion = currentVersion;
+    this.expectedVersion = expectedVersion;
+    this.entityId = entityId;
+    this.field = field;
+    this.lastModifiedBy = lastModifiedBy;
+    this.name = "StaleVersionError";
+  }
+  currentVersion;
+  expectedVersion;
+  entityId;
+  field;
+  lastModifiedBy;
+};
+
+export {
+  StaleVersionError
+};
+//# sourceMappingURL=chunk-TDSEX5CF.js.map

package/dist/chunk-TFTGP7Z7.js

@@ -0,0 +1,174 @@
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+
+// src/telemetry/routing-events.ts
+function resolveRegistryProviderIds() {
+  try {
+    return ProviderRegistry.getAllProviderIds();
+  } catch {
+    return [];
+  }
+}
+var InMemoryRoutingTelemetryCollector = class {
+  events = [];
+  maxEvents = 1e3;
+  async emitEvent(event) {
+    this.events.push(event);
+    if (this.events.length > this.maxEvents) {
+      this.events = this.events.slice(-this.maxEvents);
+    }
+    if (isDebugMode()) {
+      console.log(`[RoutingTelemetry] ${event.type}:`, {
+        timestamp: event.timestamp,
+        taskId: event.taskId,
+        duration: event.duration,
+        // Add type-specific logging
+        ...event.type === "routing_decision_finalized" && {
+          primaryProvider: event.finalDecision.primary.provider,
+          confidence: event.finalDecision.primary.confidence,
+          wasOverride: event.wasOverride
+        },
+        ...event.type === "provider_selected" && {
+          provider: event.provider,
+          confidence: event.confidence,
+          domain: event.domain
+        }
+      });
+    }
+  }
+  async getRoutingStats(startTime, endTime) {
+    const filteredEvents = this.events.filter(
+      (event) => new Date(event.timestamp) >= startTime && new Date(event.timestamp) <= endTime
+    );
+    const completedEvents = filteredEvents.filter((e) => e.type === "routing_decision_finalized");
+    const analysisEvents = filteredEvents.filter((e) => e.type === "domain_analysis_completed");
+    const planningEvents = filteredEvents.filter((e) => e.type === "routing_planning_completed");
+    const totalRoutings = completedEvents.length;
+    const averageAnalysisTime = analysisEvents.length > 0 ? analysisEvents.reduce((sum, e) => sum + (e.duration ?? 0), 0) / analysisEvents.length : 0;
+    const averageRoutingTime = planningEvents.length > 0 ? planningEvents.reduce((sum, e) => sum + (e.duration ?? 0), 0) / planningEvents.length : 0;
+    const providerUsageCounts = {};
+    for (const providerId of resolveRegistryProviderIds()) {
+      providerUsageCounts[providerId] = 0;
+    }
+    completedEvents.forEach((event) => {
+      if (event.type !== "routing_decision_finalized") return;
+      const provider = event.finalDecision.primary.provider;
+      providerUsageCounts[provider] = (providerUsageCounts[provider] ?? 0) + 1;
+    });
+    const successRate = null;
+    const cacheHitRate = null;
+    return {
+      totalRoutings,
+      averageAnalysisTime,
+      averageRoutingTime,
+      providerUsageCounts,
+      successRate,
+      cacheHitRate
+    };
+  }
+  async getProviderPerformance(startTime, endTime) {
+    const filteredEvents = this.events.filter(
+      (event) => new Date(event.timestamp) >= startTime && new Date(event.timestamp) <= endTime
+    );
+    const completedEvents = filteredEvents.filter(
+      (e) => e.type === "routing_decision_finalized"
+    );
+    const providerEvents = filteredEvents.filter(
+      (e) => e.type === "provider_selected"
+    );
+    const result = {};
+    const sums = {};
+    const ensureProvider = (provider) => {
+      let metrics = result[provider];
+      if (!metrics) {
+        metrics = {
+          assignments: 0,
+          averageConfidence: 0,
+          successRate: null,
+          averageRoutingTime: 0,
+          domainDistribution: {}
+        };
+        result[provider] = metrics;
+        sums[provider] = { confidence: 0, routingTime: 0 };
+      }
+      return metrics;
+    };
+    for (const providerId of resolveRegistryProviderIds()) {
+      ensureProvider(providerId);
+    }
+    for (const event of completedEvents) {
+      const provider = event.finalDecision.primary.provider;
+      const providerMetrics = ensureProvider(provider);
+      providerMetrics.assignments++;
+      const providerSums = sums[provider];
+      providerSums.confidence += event.finalDecision.primary.confidence;
+      providerSums.routingTime += event.totalRoutingTime ?? 0;
+    }
+    providerEvents.forEach((event) => {
+      const provider = event.provider;
+      const providerMetrics = ensureProvider(provider);
+      const domain = event.domain;
+      providerMetrics.domainDistribution[domain] = (providerMetrics.domainDistribution[domain] || 0) + 1;
+    });
+    for (const provider of Object.keys(result)) {
+      const providerMetrics = result[provider];
+      const providerSums = sums[provider];
+      if (!providerMetrics || !providerSums) continue;
+      const count = providerMetrics.assignments;
+      if (count > 0) {
+        providerMetrics.averageConfidence = providerSums.confidence / count;
+        providerMetrics.averageRoutingTime = providerSums.routingTime / count;
+      }
+    }
+    return result;
+  }
+  /**
+   * Clear all stored events (useful for testing)
+   */
+  clear() {
+    this.events = [];
+  }
+  /**
+   * Get all stored events (useful for debugging)
+   */
+  getAllEvents() {
+    return [...this.events];
+  }
+};
+var PersistentRoutingTelemetryCollector = class extends InMemoryRoutingTelemetryCollector {
+  async emitEvent(event) {
+    await super.emitEvent(event);
+    try {
+      const { getGlobalRoutingHistoryStore } = await import("./routing-history-store-UWCEXAP3.js");
+      getGlobalRoutingHistoryStore().persistEvent(event);
+    } catch (error) {
+      if (isDebugMode()) {
+        console.warn("[RoutingTelemetry] Failed to persist event to history store:", error);
+      }
+    }
+  }
+};
+var routingTelemetry = new PersistentRoutingTelemetryCollector();
+function setRoutingTelemetryCollector(collector) {
+  if (isDebugMode()) {
+    console.warn(
+      "[RoutingTelemetry] setRoutingTelemetryCollector() is deprecated and ignored; telemetry now persists via the global history store."
+    );
+  }
+  void collector;
+}
+function getRoutingTelemetryCollector() {
+  return routingTelemetry;
+}
+
+export {
+  InMemoryRoutingTelemetryCollector,
+  routingTelemetry,
+  setRoutingTelemetryCollector,
+  getRoutingTelemetryCollector
+};
+//# sourceMappingURL=chunk-TFTGP7Z7.js.map