@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-6TZJRKNW.js

@@ -0,0 +1,321 @@
+// src/core/providers/pi/backend-env.ts
+var PI_BACKEND_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY"
+];
+
+// src/core/providers/shared/child-env.ts
+var RESERVED_HEADERS = [
+  "ANTHROPIC_CUSTOM_HEADERS",
+  // Claude Code session markers — all must be removed to prevent
+  // "Claude Code cannot be launched inside another Claude Code session" errors.
+  "CLAUDECODE",
+  "CLAUDE_CODE",
+  "CLAUDE_CODE_SSE_PORT",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CLAUDE_CODE_ENABLE_TELEMETRY",
+  "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR",
+  "AI_SDK"
+];
+var CLAUDE_SESSION_PREFIX = "CLAUDE_CODE_";
+var CLAUDE_SESSION_MARKER_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_EFFORT_LEVEL",
+  // Capability flag, not a session marker: it disables the 1M context window.
+  // Poetic reads the same variable when deciding whether to append the `[1m]`
+  // selector, so suppressing the selector in the parent while letting the child
+  // run unrestricted would desync the two.
+  "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX"
+]);
+var RESERVED_HEADER_SET = new Set(RESERVED_HEADERS);
+var PARENT_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+  "CI",
+  "COLORTERM",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "LOGNAME",
+  "NODE_EXTRA_CA_CERTS",
+  "PATH",
+  "PWD",
+  "SHELL",
+  "TERM",
+  "TMPDIR",
+  "USER",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_EFFORT_LEVEL",
+  "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "CLOUD_ML_REGION",
+  // Vertex model-default knobs. The Claude CLI resolves the bare aliases
+  // (`opus`/`sonnet`/`haiku`) to provider-specific model ids via these env
+  // vars; stripping them on Vertex silently resolves the wrong model and drops
+  // the operator's override before it reaches the child. These are model
+  // names / region knobs, not secrets. ANTHROPIC_MODEL is safe to forward
+  // because an explicit `--model` flag takes precedence over it (verified
+  // against Anthropic docs: "--model and /model override ANTHROPIC_MODEL").
+  // Poetic emits `--model` for any model that resolves and omits it only for
+  // unresolvable/cross-provider input (commands.ts), so ANTHROPIC_MODEL governs
+  // just that no-flag fallback — it can never override an explicit selection.
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "CURSOR_CONFIG_DIR",
+  "CURSOR_DATA_DIR",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_LOCATION",
+  "GCLOUD_PROJECT",
+  "CLOUDSDK_CONFIG",
+  // Grok API keys are intentionally absent: re-admitted only via grok provider
+  // execution policy (provider-execution-env.ts), not the generic parent allowlist.
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_KEY",
+  "BLACKBOX_API_KEY",
+  "ZAI_API_KEY",
+  "ZHIPU_API_KEY",
+  "KIRO_API_KEY",
+  "ANTIGRAVITY_API_KEY",
+  // Pi's agent directory holds auth.json and models.json. An operator who moves
+  // it must have the override reach the child, or Pi reads ~/.pi/agent instead
+  // and fails to resolve their configured backend or credential. A directory
+  // path, not a secret (matches CURSOR_CONFIG_DIR above).
+  "PI_CODING_AGENT_DIR"
+]);
+var PARENT_ENV_ALLOWLIST_PREFIXES = ["AWS_", "POETIC_", "VERTEX_REGION_CLAUDE_"];
+var PARENT_ENV_DENYLIST = /* @__PURE__ */ new Set([
+  "POETIC_ALLOW_SKIP_AUTH",
+  "POETIC_CONFIG_ALLOW_DEFAULT_FALLBACK",
+  "POETIC_PROVIDER_HISTORY_RAW",
+  "POETIC_SKIP_AUTH",
+  "POETIC_WEBHOOK_SECRET",
+  "POETIC_WORKER_ALLOW_EMPTY_RESULTS",
+  "POETIC_WORKER_EXECUTION_INTENT",
+  // Native web-search clearance (Fusion Workstream B1) is an authority signal:
+  // it must come ONLY from the parent's per-run capability-matrix decision, never
+  // from an inherited shell env. Denylist it so a pre-set shell value cannot
+  // enable provider web tools outside an analysis-only --research run; the master
+  // re-applies the trusted value onto the worker env after this clean step.
+  "POETIC_RESEARCH_NATIVE_PROVIDERS"
+]);
+function isSandboxAuthorityEnvVar(name) {
+  return name.startsWith("POETIC_") && name.includes("SANDBOX");
+}
+function shouldStripClaudeSessionVar(name) {
+  if (RESERVED_HEADER_SET.has(name)) {
+    return true;
+  }
+  return name.startsWith(CLAUDE_SESSION_PREFIX) && !CLAUDE_SESSION_MARKER_ALLOWED_KEYS.has(name);
+}
+function shouldForwardParentEnvVar(name) {
+  if (PARENT_ENV_DENYLIST.has(name) || isSandboxAuthorityEnvVar(name)) {
+    return false;
+  }
+  return PARENT_ENV_ALLOWLIST.has(name) || PARENT_ENV_ALLOWLIST_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function filterParentEnvForProvider(baseEnv) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (value !== void 0 && shouldForwardParentEnvVar(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function stripClaudeSessionEnv(env) {
+  const mergedEnv = { ...env };
+  for (const key of Object.keys(mergedEnv)) {
+    if (shouldStripClaudeSessionVar(key)) {
+      delete mergedEnv[key];
+    }
+  }
+  return mergedEnv;
+}
+function createCleanChildEnv(overrides, baseEnv = filterParentEnvForProvider(process.env)) {
+  const mergedEnv = {
+    ...baseEnv,
+    ...overrides ?? {}
+  };
+  for (const key of PARENT_ENV_DENYLIST) {
+    delete mergedEnv[key];
+  }
+  for (const key of Object.keys(mergedEnv)) {
+    if (isSandboxAuthorityEnvVar(key)) {
+      delete mergedEnv[key];
+    }
+  }
+  return stripClaudeSessionEnv(mergedEnv);
+}
+function createProviderChildEnv(overrides) {
+  return createCleanChildEnv(overrides, overrides ? {} : filterParentEnvForProvider(process.env));
+}
+var PROVIDER_SECRET_KEYS = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "CLOUD_ML_REGION",
+  // Claude Vertex model-default knobs — scoped to claude/anthropic so a
+  // non-claude provider run does not carry claude model overrides (mirrors
+  // CLAUDE_CODE_USE_VERTEX / CLOUD_ML_REGION). Not secrets; listed here only so
+  // the per-provider scoping pass keeps them for claude and strips them
+  // elsewhere.
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_LOCATION",
+  "GCLOUD_PROJECT",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "CLOUDSDK_CONFIG",
+  "GROK_CODE_XAI_API_KEY",
+  "XAI_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_KEY",
+  "BLACKBOX_API_KEY",
+  "ZAI_API_KEY",
+  "ZHIPU_API_KEY",
+  "SYNTHETIC_API_KEY",
+  "KIRO_API_KEY",
+  "ANTIGRAVITY_API_KEY"
+]);
+var CLAUDE_VERTEX_REGION_PREFIX = "VERTEX_REGION_CLAUDE_";
+function providerSecretAllowlist(provider) {
+  switch ((provider ?? "").toLowerCase()) {
+    case "claude":
+    case "anthropic":
+      return /* @__PURE__ */ new Set([
+        "ANTHROPIC_API_KEY",
+        "CLAUDE_CODE_OAUTH_TOKEN",
+        "CLAUDE_CODE_USE_BEDROCK",
+        "CLAUDE_CODE_USE_VERTEX",
+        "ANTHROPIC_VERTEX_PROJECT_ID",
+        "CLOUD_ML_REGION",
+        // Vertex model-default knobs (see PROVIDER_SECRET_KEYS comment). Kept
+        // for claude so the scoping pass doesn't re-strip the model overrides.
+        "ANTHROPIC_MODEL",
+        "ANTHROPIC_DEFAULT_OPUS_MODEL",
+        "ANTHROPIC_DEFAULT_SONNET_MODEL",
+        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+        "ANTHROPIC_SMALL_FAST_MODEL",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "GOOGLE_CLOUD_PROJECT",
+        "GOOGLE_CLOUD_LOCATION",
+        "GCLOUD_PROJECT",
+        "CLOUDSDK_CONFIG"
+      ]);
+    case "gemini":
+      return /* @__PURE__ */ new Set([
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "GOOGLE_CLOUD_PROJECT",
+        "GOOGLE_CLOUD_LOCATION",
+        "GCLOUD_PROJECT",
+        "CLOUDSDK_CONFIG"
+      ]);
+    case "codex":
+    case "openai":
+      return /* @__PURE__ */ new Set(["OPENAI_API_KEY"]);
+    case "copilot":
+    case "cursor":
+      return /* @__PURE__ */ new Set();
+    case "grok":
+      return /* @__PURE__ */ new Set(["XAI_API_KEY", "GROK_CODE_XAI_API_KEY"]);
+    case "blackbox":
+      return /* @__PURE__ */ new Set(["BLACKBOX_API_KEY"]);
+    case "opencode":
+      return /* @__PURE__ */ new Set([
+        "OPENROUTER_API_KEY",
+        "OPENROUTER_KEY",
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "BLACKBOX_API_KEY",
+        "ZAI_API_KEY",
+        "ZHIPU_API_KEY",
+        "SYNTHETIC_API_KEY"
+      ]);
+    case "kiro":
+      return /* @__PURE__ */ new Set(["KIRO_API_KEY"]);
+    case "antigravity":
+      return /* @__PURE__ */ new Set(["ANTIGRAVITY_API_KEY"]);
+    // Pi is a backend-agnostic host, so the key that matters belongs to whichever
+    // inference backend the operator configured. Sourced from the Pi adapter so
+    // this list cannot drift from Pi's auth detection (pi/backend-env.ts explains
+    // why that drift is not hypothetical).
+    // quirks-allow: secret-allowlist membership is provider credential metadata owned by the provider adapter, not runtime CLI quirks expressible in the declarative table
+    case "pi":
+      return new Set(PI_BACKEND_ENV_KEYS);
+    default:
+      return /* @__PURE__ */ new Set();
+  }
+}
+function scopeChildEnvForProvider(env, provider, _options) {
+  const scoped = { ...env };
+  const normalizedProvider = (provider ?? "").toLowerCase();
+  const allowedSecrets = providerSecretAllowlist(provider);
+  for (const key of PROVIDER_SECRET_KEYS) {
+    if (!allowedSecrets.has(key)) {
+      delete scoped[key];
+    }
+  }
+  const isClaude = normalizedProvider === "claude" || normalizedProvider === "anthropic";
+  const keepAws = isClaude || // quirks-allow: AWS credential forwarding is child-env secret-boundary policy for Bedrock-capable families, not a runtime CLI quirk
+  normalizedProvider === "codex" || normalizedProvider === "openai" || normalizedProvider === "opencode";
+  if (!isClaude) {
+    for (const key of Object.keys(scoped)) {
+      if (key.startsWith(CLAUDE_VERTEX_REGION_PREFIX)) {
+        delete scoped[key];
+      }
+      if (!keepAws && key.startsWith("AWS_")) {
+        delete scoped[key];
+      }
+    }
+  }
+  delete scoped.SSH_AUTH_SOCK;
+  delete scoped.GIT_SSH;
+  delete scoped.GIT_SSH_COMMAND;
+  return scoped;
+}
+function createScopedProviderChildEnv(provider, baseEnv = process.env) {
+  return scopeChildEnvForProvider(
+    createCleanChildEnv(void 0, filterParentEnvForProvider(baseEnv)),
+    provider
+  );
+}
+
+export {
+  PI_BACKEND_ENV_KEYS,
+  isSandboxAuthorityEnvVar,
+  stripClaudeSessionEnv,
+  createCleanChildEnv,
+  createProviderChildEnv,
+  scopeChildEnvForProvider,
+  createScopedProviderChildEnv
+};
+//# sourceMappingURL=chunk-6TZJRKNW.js.map

package/dist/chunk-6V7HGQFZ.js

@@ -0,0 +1,20 @@
+// src/core/execution/surface-attribution.ts
+var INITIATED_BY_VALUES = ["cli", "tui", "plugin-slash", "agent", "unknown"];
+function isInitiatedBy(value) {
+  return INITIATED_BY_VALUES.includes(value);
+}
+function resolveInitiatedBy(options = {}) {
+  const env = options.env ?? process.env;
+  const raw = env.POETIC_INITIATED_BY?.trim();
+  if (raw && isInitiatedBy(raw)) {
+    return raw;
+  }
+  const stdinIsTTY = options.stdinIsTTY ?? Boolean(process.stdin?.isTTY);
+  const stdoutIsTTY = options.stdoutIsTTY ?? Boolean(process.stdout?.isTTY);
+  return stdinIsTTY && stdoutIsTTY ? "cli" : "unknown";
+}
+
+export {
+  resolveInitiatedBy
+};
+//# sourceMappingURL=chunk-6V7HGQFZ.js.map

package/dist/chunk-6Y5TWI7H.js

@@ -0,0 +1,146 @@
+// src/core/config/evaluation-criteria.ts
+import { z } from "zod";
+var EvaluationCriterionSchema = z.object({
+  /** Display name for the criterion */
+  name: z.string(),
+  /** Detailed description of what this criterion evaluates */
+  description: z.string(),
+  /** Weight in final scoring (0-1, should sum to 1.0 across all criteria) */
+  weight: z.number().min(0).max(1),
+  /** Minimum score threshold (0-100) for passing evaluation */
+  minThreshold: z.number().min(0).max(100),
+  /** Whether this criterion is currently active in evaluation */
+  active: z.boolean().default(true)
+});
+var QualityLevels = {
+  Fail: 1,
+  Poor: 2,
+  Average: 3,
+  Good: 4,
+  Excellent: 5
+};
+var EvaluationCriteriaConfigSchema = z.object({
+  /** Version of this criteria configuration */
+  version: z.string(),
+  /** Last updated timestamp */
+  lastUpdated: z.string().datetime(),
+  /** Individual criteria with weights and thresholds */
+  criteria: z.record(z.string(), EvaluationCriterionSchema),
+  /** Default strategy for combining criteria */
+  defaultStrategy: z.object({
+    /** Minimum overall score to pass evaluation (0-100) */
+    minOverallScore: z.number().min(0).max(100),
+    /** Whether to require all active criteria to pass minimum thresholds */
+    requireAllThresholds: z.boolean()
+  })
+});
+var DEFAULT_EVALUATION_CRITERIA = {
+  version: "2.3.0",
+  // P1-3: Added completeness criterion
+  lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+  criteria: {
+    functionality_correctness: {
+      name: "Functionality and Correctness",
+      description: "Core task completion accuracy, technical implementation quality, feature completeness. Maps to Technical Implementation with focus on correctness and reliability. v2.3: Maps DIRECTLY to AI correctnessScore when available.",
+      weight: 0.3,
+      // Unchanged
+      minThreshold: 75,
+      active: true
+    },
+    completeness: {
+      name: "Completeness",
+      description: "Coverage of requirements and edge cases. Evaluates whether all stated requirements are addressed and edge cases handled.",
+      weight: 0.2,
+      // NEW - P1-3 addition
+      minThreshold: 70,
+      active: true
+    },
+    code_quality_maintainability: {
+      name: "Code Quality and Maintainability",
+      description: "Code readability, maintainability, test coverage, documentation quality. Combines Test Coverage and Documentation aspects. v2.3: Reduced from 22% to 20% to accommodate completeness criterion.",
+      weight: 0.2,
+      // Reduced from 0.22
+      minThreshold: 75,
+      active: true
+    },
+    security_robustness: {
+      name: "Security and Robustness",
+      description: "Security vulnerability handling, error robustness, production readiness. v2.4: Increased from 15% to 18% after performance_efficiency removal.",
+      weight: 0.18,
+      // Increased from 0.15 (absorbed 3% from removed performance_efficiency)
+      minThreshold: 80,
+      active: true
+    },
+    scalability_adaptability: {
+      name: "Scalability and Adaptability",
+      description: "Growth handling capabilities, architecture innovation, modularity, flexibility. Maps to Architecture Innovation with emphasis on future-proofing. v2.4: Increased from 10% to 12% after performance_efficiency removal.",
+      weight: 0.12,
+      // Increased from 0.10 (absorbed 2% from removed performance_efficiency)
+      minThreshold: 70,
+      active: true
+    }
+  },
+  defaultStrategy: {
+    minOverallScore: 75,
+    requireAllThresholds: true
+  }
+};
+function getActiveCriteria(config) {
+  const active = {};
+  for (const [key, criterion] of Object.entries(config.criteria)) {
+    if (criterion.active) {
+      active[key] = criterion;
+    }
+  }
+  return active;
+}
+var QUALITY_LEVEL_DESCRIPTIONS = {
+  [QualityLevels.Excellent]: "Revolutionary/Outstanding - Exceeds all expectations with exceptional quality",
+  [QualityLevels.Good]: "Strong/Competent - Meets requirements with high quality",
+  [QualityLevels.Average]: "Adequate/Solid - Meets basic requirements with acceptable quality",
+  [QualityLevels.Poor]: "Limited/Basic - Falls short in significant areas",
+  [QualityLevels.Fail]: "Minimal/Broken - Does not meet basic requirements or is non-functional"
+};
+var CRITERIA_QUALITY_GUIDANCE = {
+  functionality_correctness: {
+    [QualityLevels.Excellent]: "Revolutionary accuracy & comprehensive features",
+    [QualityLevels.Good]: "Advanced reliability & solid feature implementation",
+    [QualityLevels.Average]: "Solid basic functionality with minor issues",
+    [QualityLevels.Poor]: "Basic functionality with noticeable errors",
+    [QualityLevels.Fail]: "Minimal or broken functionality"
+  },
+  completeness: {
+    [QualityLevels.Excellent]: "All requirements + edge cases handled comprehensively",
+    [QualityLevels.Good]: "Core requirements met with most edges covered",
+    [QualityLevels.Average]: "Partial coverage with some gaps",
+    [QualityLevels.Poor]: "Missing major requirements",
+    [QualityLevels.Fail]: "Barely addresses the task"
+  },
+  scalability_adaptability: {
+    [QualityLevels.Excellent]: "Cutting-edge modularity & exceptional flexibility",
+    [QualityLevels.Good]: "Modern architecture with good growth capabilities",
+    [QualityLevels.Average]: "Standard design with adequate scalability",
+    [QualityLevels.Poor]: "Outdated approach with limited growth potential",
+    [QualityLevels.Fail]: "Legacy limitations with no growth capability"
+  },
+  code_quality_maintainability: {
+    [QualityLevels.Excellent]: "Comprehensive tests, excellent documentation, highly readable",
+    [QualityLevels.Good]: "Good coding standards with adequate test coverage",
+    [QualityLevels.Average]: "Adequate coverage with basic documentation",
+    [QualityLevels.Poor]: "Minimal testing or documentation effort",
+    [QualityLevels.Fail]: "No testing, documentation, or unreadable code"
+  },
+  security_robustness: {
+    [QualityLevels.Excellent]: "Production-secure with comprehensive error handling",
+    [QualityLevels.Good]: "Near-ready defenses with good security practices",
+    [QualityLevels.Average]: "Basic security with areas needing improvement",
+    [QualityLevels.Poor]: "Major security risks or poor error handling",
+    [QualityLevels.Fail]: "Critical vulnerabilities or unusable state"
+  }
+};
+
+export {
+  DEFAULT_EVALUATION_CRITERIA,
+  getActiveCriteria
+};
+//# sourceMappingURL=chunk-6Y5TWI7H.js.map

package/dist/chunk-6Y5U7UFY.js

@@ -0,0 +1,91 @@
+import {
+  redactBlockerContext
+} from "./chunk-XV7NZL4B.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+
+// src/telemetry/privacy-redaction.ts
+var REDACTED = "[REDACTED]";
+function compactKey(key) {
+  return key.replace(/[._-]+/g, "").toLowerCase();
+}
+function isSensitiveKey(key) {
+  const compact = compactKey(key);
+  if (compact === "token" || compact === "secret" || compact === "password" || compact === "passwd" || compact === "pwd" || compact === "authorization" || compact === "credential" || compact === "credentials") {
+    return true;
+  }
+  return compact.endsWith("apikey") || compact.endsWith("authkey") || compact.endsWith("accesskey") || compact.endsWith("privatekey") || compact.endsWith("clientsecret") || compact.endsWith("authtoken") || compact.endsWith("accesstoken") || compact.endsWith("refreshtoken") || compact.endsWith("bearertoken");
+}
+function redactString(value) {
+  return sanitizeString(redactBlockerContext(value));
+}
+function maybeRedactJsonString(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2 || !(trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    return redactString(value);
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return JSON.stringify(redactTelemetryValue(parsed));
+  } catch {
+    return redactString(value);
+  }
+}
+function redactTelemetryValue(value, visited = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") {
+    return maybeRedactJsonString(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean" || value === null || value === void 0) {
+    return value ?? null;
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      return "[Circular]";
+    }
+    visited.add(value);
+    const mapped = value.map((entry) => redactTelemetryValue(entry, visited));
+    visited.delete(value);
+    return mapped;
+  }
+  if (typeof value !== "object") {
+    return redactString(String(value));
+  }
+  if (visited.has(value)) {
+    return "[Circular]";
+  }
+  visited.add(value);
+  const redacted = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    redacted[key] = isSensitiveKey(key) ? REDACTED : redactTelemetryValue(nestedValue, visited);
+  }
+  visited.delete(value);
+  return redacted;
+}
+function redactTelemetryObject(value) {
+  return redactTelemetryValue(value);
+}
+function redactPersistedTelemetryValue(value) {
+  return redactTelemetryValue(value);
+}
+function redactPersistedTestsExecuted(value) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  return redactPersistedTelemetryValue(value);
+}
+function redactPersistedTelemetryString(value) {
+  return String(redactTelemetryValue(value));
+}
+
+export {
+  redactTelemetryValue,
+  redactTelemetryObject,
+  redactPersistedTelemetryValue,
+  redactPersistedTestsExecuted,
+  redactPersistedTelemetryString
+};
+//# sourceMappingURL=chunk-6Y5U7UFY.js.map

package/dist/chunk-6ZLAK3XG.js

@@ -0,0 +1,14 @@
+// src/orchestrator/semantic-verdict.ts
+function resolveSemanticVerdict(validation) {
+  if (!validation) return void 0;
+  if (validation.enabled === false) return "disabled";
+  if (validation.skipped !== void 0 && validation.skipped !== "") return "skipped";
+  if (validation.passed === true) return "passed";
+  if (validation.passed === false) return "failed";
+  return void 0;
+}
+
+export {
+  resolveSemanticVerdict
+};
+//# sourceMappingURL=chunk-6ZLAK3XG.js.map

package/dist/chunk-72XCRQED.js

@@ -0,0 +1,34 @@
+// src/core/synthesis/ignored-planning-artifact-path.ts
+function normalizeIgnoredArtifactPath(candidate) {
+  let normalized = candidate.trim().replace(/\\/g, "/");
+  if (!normalized) return null;
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  if (normalized.startsWith("/")) {
+    const marker = "/.poetic/planning";
+    const markerIndex = normalized.indexOf(marker);
+    if (markerIndex < 0) return null;
+    normalized = normalized.slice(markerIndex + 1);
+  }
+  const parts = [];
+  for (const part of normalized.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (parts.length === 0) return null;
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.length > 0 ? parts.join("/") : null;
+}
+function isIgnoredPlanningArtifactPath(candidate) {
+  const normalized = normalizeIgnoredArtifactPath(candidate);
+  return normalized === ".poetic/planning" || normalized?.startsWith(".poetic/planning/") === true;
+}
+
+export {
+  isIgnoredPlanningArtifactPath
+};
+//# sourceMappingURL=chunk-72XCRQED.js.map