@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-Y55LZN5U.js

@@ -0,0 +1,52 @@
+// src/planning/issue-types.ts
+var LeaseExpiredError = class extends Error {
+  constructor(entityId, expiredAt) {
+    super(`Lease expired for ${entityId} at ${expiredAt}`);
+    this.entityId = entityId;
+    this.expiredAt = expiredAt;
+    this.name = "LeaseExpiredError";
+  }
+  entityId;
+  expiredAt;
+};
+var InvalidTransitionError = class extends Error {
+  constructor(entityId, fromStatus, toStatus, reason) {
+    super(
+      `Invalid transition for ${entityId}: ${fromStatus} \u2192 ${toStatus}${reason ? ` (${reason})` : ""}`
+    );
+    this.entityId = entityId;
+    this.fromStatus = fromStatus;
+    this.toStatus = toStatus;
+    this.reason = reason;
+    this.name = "InvalidTransitionError";
+  }
+  entityId;
+  fromStatus;
+  toStatus;
+  reason;
+};
+var HumanReviewRequiredError = class extends Error {
+  constructor(entityId, transition, category, severity) {
+    super(
+      `Human review required for ${entityId}: ${transition} (category=${category}, severity=${severity ?? "n/a"})`
+    );
+    this.entityId = entityId;
+    this.transition = transition;
+    this.category = category;
+    this.severity = severity;
+    this.name = "HumanReviewRequiredError";
+  }
+  entityId;
+  transition;
+  category;
+  severity;
+};
+var DEFAULT_LEASE_TTL_MS = 30 * 60 * 1e3;
+
+export {
+  LeaseExpiredError,
+  InvalidTransitionError,
+  HumanReviewRequiredError,
+  DEFAULT_LEASE_TTL_MS
+};
+//# sourceMappingURL=chunk-Y55LZN5U.js.map

package/dist/chunk-Y5677NDO.js

@@ -0,0 +1,183 @@
+import {
+  canonicalizeOpencodeModelId,
+  getCachedOpencodeModelIds
+} from "./chunk-CJHRFSNY.js";
+import {
+  resolveProviderModel
+} from "./chunk-IZZK3H6I.js";
+import {
+  readCanonicalPoeticConfig,
+  selectedPoeticConfigCandidate
+} from "./chunk-G36W2T2S.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  ModelNameSchema
+} from "./chunk-QOCOVLUH.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  getConfigPaths
+} from "./chunk-L6OM4A22.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/orchestrator/utils/resolve-variant-model.ts
+import { statSync } from "fs";
+var AUTO_MODEL_SENTINEL_PROVIDERS = /* @__PURE__ */ new Set(["claude", "codex", "opencode"]);
+var cachedUserAliasConfig = null;
+function normalizeAliasKey(key) {
+  return key.trim().toLowerCase();
+}
+var warnedUnreadableUserConfigs = /* @__PURE__ */ new Set();
+function warnUnreadableUserConfig(configPath, mtimeMs, error) {
+  const dedupeKey = `${configPath}@${mtimeMs ?? "unstattable"}`;
+  if (warnedUnreadableUserConfigs.has(dedupeKey)) return;
+  warnedUnreadableUserConfigs.add(dedupeKey);
+  emitWarning(
+    "CFG-011",
+    { taskId: "model-aliases", subsystem: "config", executionPhase: "setup" },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "loadUserModelAliases",
+        configPath,
+        reason: error.reason,
+        detail: error.message
+      }
+    }
+  );
+}
+function collectAliasesByProvider(providers) {
+  const aliasesByProvider = {};
+  if (!providers || typeof providers !== "object") return aliasesByProvider;
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    if (!providerConfig || typeof providerConfig !== "object") continue;
+    const aliases = providerConfig.aliases;
+    const models = aliases && typeof aliases === "object" ? aliases.models : null;
+    if (!models || typeof models !== "object") continue;
+    const record = {};
+    for (const [aliasKey, modelId] of Object.entries(models)) {
+      if (typeof aliasKey !== "string" || typeof modelId !== "string") continue;
+      const normalizedKey = normalizeAliasKey(aliasKey);
+      if (!normalizedKey) continue;
+      const parsed = ModelNameSchema.safeParse(modelId.trim());
+      if (!parsed.success) continue;
+      record[normalizedKey] = parsed.data;
+    }
+    if (Object.keys(record).length > 0) {
+      aliasesByProvider[providerId.trim().toLowerCase()] = record;
+    }
+  }
+  return aliasesByProvider;
+}
+function loadUserModelAliases() {
+  const configPath = selectedPoeticConfigCandidate(getConfigPaths().userConfigFile);
+  let mtimeMs = null;
+  try {
+    mtimeMs = statSync(configPath).mtimeMs;
+  } catch {
+    mtimeMs = null;
+  }
+  if (mtimeMs !== null && cachedUserAliasConfig && cachedUserAliasConfig.path === configPath && cachedUserAliasConfig.mtimeMs === mtimeMs) {
+    return cachedUserAliasConfig.aliasesByProvider;
+  }
+  const read = readCanonicalPoeticConfig(configPath);
+  if (read.status === "invalid") {
+    warnUnreadableUserConfig(configPath, mtimeMs, read.error);
+    if (read.parsed === void 0) {
+      cachedUserAliasConfig = null;
+      return {};
+    }
+  }
+  if (read.status === "missing") {
+    cachedUserAliasConfig = null;
+    return {};
+  }
+  const config = read.status === "valid" ? read.config : read.parsed;
+  const providers = config && typeof config === "object" ? config.providers : void 0;
+  const aliasesByProvider = collectAliasesByProvider(providers);
+  cachedUserAliasConfig = mtimeMs === null ? null : { path: configPath, mtimeMs, aliasesByProvider };
+  return aliasesByProvider;
+}
+function shouldDisableModelAliases() {
+  const value = String(getRuntimeEnv("POETIC_DISABLE_MODEL_ALIASES") ?? "").trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+}
+function normalizeModelLiteral(model) {
+  if (!model) return void 0;
+  const trimmed = model.trim();
+  if (trimmed.length === 0) return void 0;
+  const lowered = trimmed.toLowerCase();
+  if (lowered === "undefined" || lowered === "null") return void 0;
+  return trimmed;
+}
+function isProviderDefaultSentinel(providerId, model) {
+  const normalized = model?.trim().toLowerCase();
+  return normalized === "auto" && AUTO_MODEL_SENTINEL_PROVIDERS.has(providerId);
+}
+function hasProviderScopedModelSource(providerId, resolved) {
+  if (resolved.source === "cli" || resolved.source === "env" || resolved.source === "env-legacy") {
+    return true;
+  }
+  const sourcePath = resolved.sourcePath ?? "";
+  return sourcePath.includes(`#defaults.providers.${providerId}.model`);
+}
+function resolveVariantModel(provider, model, options) {
+  const providerId = String(provider ?? "").trim().toLowerCase();
+  const modelInput = normalizeModelLiteral(model);
+  if (modelInput) {
+    if (isProviderDefaultSentinel(providerId, modelInput)) {
+      return { model: void 0, modelInput, modelResolutionProvenance: "native-default" };
+    }
+    let effectiveModel = modelInput;
+    let modelAliasUsed;
+    if (!options?.ignoreUserModelAliases && !shouldDisableModelAliases()) {
+      const aliases = loadUserModelAliases();
+      const providerAliases = aliases[providerId];
+      const aliasKey = normalizeAliasKey(modelInput);
+      const mapped = providerAliases?.[aliasKey];
+      if (mapped && mapped !== modelInput) {
+        effectiveModel = mapped;
+        modelAliasUsed = modelInput;
+      }
+    }
+    if (providerId === "opencode") {
+      const cachedModels = getCachedOpencodeModelIds();
+      effectiveModel = canonicalizeOpencodeModelId(effectiveModel, cachedModels);
+    }
+    return {
+      model: effectiveModel,
+      modelInput,
+      modelAliasUsed,
+      modelResolutionProvenance: "explicit"
+    };
+  }
+  try {
+    const registryDefault = normalizeModelLiteral(
+      ProviderRegistry.getProviderConfig(providerId).models?.default
+    );
+    if (options?.ignoreUserModelAliases) {
+      if (isProviderDefaultSentinel(providerId, registryDefault)) {
+        return { model: void 0, modelResolutionProvenance: "omitted" };
+      }
+      return { model: registryDefault, modelResolutionProvenance: "omitted" };
+    }
+    const resolved = resolveProviderModel(providerId);
+    const providerDefault = hasProviderScopedModelSource(providerId, resolved) ? normalizeModelLiteral(resolved.value) : registryDefault;
+    if (isProviderDefaultSentinel(providerId, providerDefault)) {
+      return { model: void 0, modelResolutionProvenance: "omitted" };
+    }
+    return { model: providerDefault, modelResolutionProvenance: "omitted" };
+  } catch {
+    return { model: void 0, modelResolutionProvenance: "omitted" };
+  }
+}
+
+export {
+  resolveVariantModel
+};
+//# sourceMappingURL=chunk-Y5677NDO.js.map

package/dist/chunk-YESZJFK6.js

@@ -0,0 +1,220 @@
+// src/cli/utils/command-tiers.ts
+var TIER_LABELS = {
+  default: "Public",
+  operator: "Advanced",
+  power: "Internal",
+  hidden: "Compatibility"
+};
+var PUBLIC_DOMAIN_ORDER = [
+  "Overview",
+  "Plan",
+  "Run",
+  "Settings"
+];
+var PUBLIC_DOMAIN_MEMBERS = {
+  Overview: ["build", "ask"],
+  Plan: ["plan", "scan"],
+  Run: ["run"],
+  Settings: ["init", "provider", "config", "doctor", "telemetry", "cleanup"]
+};
+var PUBLIC_ROOT_SUMMARIES = {
+  init: "Create or repair project-level Poetic state",
+  provider: "Install, connect, list, and manage AI providers",
+  config: "Inspect and update Poetic configuration",
+  doctor: "Diagnose readiness and repair supported problems",
+  plan: "Define, classify, prioritize, and organize work before execution",
+  ask: "Ask a provider for read-only help",
+  run: "Execute via engines: task | sprint | fusion | competition",
+  build: "Pursue intent through planning and delivery (not a project compiler)",
+  scan: "Analyze code and manage adjudicable findings",
+  telemetry: "View metrics, performance, outcomes, history, and cost",
+  cleanup: "Clean up worktrees, branches, artifacts, and temp state"
+};
+var CANONICAL_COMPAT_PATHS = {
+  backlog: "plan backlog",
+  next: "plan next",
+  capture: "plan capture",
+  debt: "plan debt",
+  parking: "plan parking",
+  roadmap: "plan roadmap",
+  sprint: "plan sprint",
+  task: "plan task",
+  finding: "scan findings",
+  issue: "scan issues",
+  ingest: "scan ingest",
+  suppression: "scan suppressions",
+  fusion: "run fusion",
+  flywheel: "run flywheel",
+  autoloop: "run --autoloop (or run autoloop)",
+  knowledge: "init knowledge",
+  "generate-instructions": "init generate-instructions",
+  instructions: "config instructions",
+  quickstart: "init quickstart",
+  providers: "provider",
+  do: "do (hidden compatibility; not redirected to run)",
+  cost: "telemetry cost (advisory)",
+  route: "route (advanced)",
+  routing: "routing (advanced)",
+  prompts: "prompts (advanced)",
+  prompt: "prompt (advanced)",
+  "telemetry-checkpoint": "telemetry checkpoint",
+  "validate-telemetry": "telemetry validate-consistency",
+  compete: "run competition"
+};
+var TIER_MAP = {
+  // --- Public roots (default) ---
+  init: "default",
+  plan: "default",
+  ask: "default",
+  run: "default",
+  build: "default",
+  scan: "default",
+  provider: "default",
+  config: "default",
+  doctor: "default",
+  telemetry: "default",
+  cleanup: "default",
+  // Nested public-domain subcommands (informational)
+  "plan.capture": "default",
+  "plan.next": "default",
+  "plan.backlog": "default",
+  "plan.sprint": "operator",
+  "plan.task": "operator",
+  "plan.debt": "default",
+  "plan.parking": "default",
+  "plan.roadmap": "default",
+  "plan.approve": "power",
+  "scan.findings": "default",
+  "scan.issues": "operator",
+  "scan.ingest": "default",
+  "scan.suppressions": "operator",
+  "run.task": "default",
+  "run.sprint": "default",
+  "run.competition": "default",
+  "run.fusion": "default",
+  "run.flywheel": "power",
+  "run.autoloop": "power",
+  "init.knowledge": "default",
+  "init.generate-instructions": "operator",
+  "config.instructions": "operator",
+  "config.context": "operator",
+  "backlog.add": "default",
+  "backlog.refine": "default",
+  "backlog.show": "default",
+  "backlog.list": "default",
+  "backlog.execute": "operator",
+  "backlog.finalize": "operator",
+  "sprint.status": "default",
+  "sprint.list": "default",
+  "sprint.create": "operator",
+  "sprint.add-task": "operator",
+  "sprint.close": "operator",
+  "sprint.complete": "operator",
+  "sprint.migrate-task": "operator",
+  "sprint.remove-task": "operator",
+  "sprint.unlock": "operator",
+  "sprint.capacity": "operator",
+  "sprint.run": "power",
+  // --- Advanced roots (operator) ---
+  analytics: "operator",
+  backup: "operator",
+  ci: "operator",
+  context: "operator",
+  cost: "operator",
+  coverage: "operator",
+  data: "operator",
+  find: "operator",
+  guard: "operator",
+  hook: "operator",
+  intent: "operator",
+  lifecycle: "operator",
+  loop: "operator",
+  migrate: "operator",
+  monitor: "operator",
+  package: "operator",
+  patterns: "operator",
+  planning: "operator",
+  preferences: "operator",
+  profile: "operator",
+  prompt: "operator",
+  prompts: "operator",
+  route: "operator",
+  routing: "operator",
+  sandbox: "operator",
+  scaffold: "operator",
+  sync: "operator",
+  "task-type": "operator",
+  upgrade: "operator",
+  worktree: "operator",
+  // Hidden compatibility aliases still listed under operator when not demoted:
+  "telemetry-checkpoint": "hidden",
+  "validate-telemetry": "hidden",
+  "version-check": "operator",
+  // --- Internal roots (power) ---
+  assert: "hidden",
+  auto: "hidden",
+  debug: "power",
+  explain: "power",
+  internal: "hidden",
+  judge: "power",
+  lab: "power",
+  "planning-checkpoint": "power",
+  processes: "power",
+  quality: "power",
+  review: "power",
+  simulation: "power",
+  swarm: "hidden",
+  // --- Hidden compatibility roots (legacy demoted forms) ---
+  backlog: "hidden",
+  next: "hidden",
+  capture: "hidden",
+  debt: "hidden",
+  parking: "hidden",
+  roadmap: "hidden",
+  sprint: "hidden",
+  task: "hidden",
+  finding: "hidden",
+  issue: "hidden",
+  ingest: "hidden",
+  suppression: "hidden",
+  fusion: "hidden",
+  flywheel: "hidden",
+  autoloop: "hidden",
+  knowledge: "hidden",
+  "generate-instructions": "hidden",
+  instructions: "hidden",
+  quickstart: "hidden",
+  providers: "hidden",
+  do: "hidden",
+  compete: "hidden",
+  // Legacy inert extension storage cleanup (not an active plugin system)
+  extension: "hidden"
+};
+function getCommandTier(name) {
+  return TIER_MAP[name];
+}
+function listClassifiedRootNames() {
+  return Object.keys(TIER_MAP).filter((key) => !key.includes(".")).sort();
+}
+function listRootsByTier(tier) {
+  return listClassifiedRootNames().filter((name) => TIER_MAP[name] === tier);
+}
+function listPublicRootsByDomain() {
+  return PUBLIC_DOMAIN_ORDER.map((domain) => ({
+    domain,
+    roots: [...PUBLIC_DOMAIN_MEMBERS[domain]]
+  }));
+}
+function getCanonicalCompatPath(legacyRoot) {
+  return CANONICAL_COMPAT_PATHS[legacyRoot];
+}
+
+export {
+  TIER_LABELS,
+  PUBLIC_ROOT_SUMMARIES,
+  getCommandTier,
+  listRootsByTier,
+  listPublicRootsByDomain,
+  getCanonicalCompatPath
+};
+//# sourceMappingURL=chunk-YESZJFK6.js.map