@poetic-ai/poetic 1.42.0

package/dist/chunk-BSE4R6XD.js

@@ -0,0 +1,322 @@
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+
+// src/config/feature-flags.ts
+var MATRIX_AUTHORITY_INVALID_WARNING_KEY = "__poeticMatrixAuthorityInvalidWarned";
+var globalFeatureFlagState = globalThis;
+function readTriStateMode(name, fallback) {
+  const raw = getRuntimeEnv(name);
+  if (raw === "off" || raw === "shadow" || raw === "on") {
+    return raw;
+  }
+  return fallback;
+}
+function readDefaultOnBoolean(name) {
+  const raw = getRuntimeEnv(name);
+  if (raw === void 0) return true;
+  const normalized = raw.toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  throw new Error(
+    `Invalid boolean value for ${name}: "${raw}". Expected one of: 1, true, yes, on, 0, false, no, off`
+  );
+}
+var JUDGE_FEATURE_FLAGS = {
+  get JUDGE_V2() {
+    return readDefaultOnBoolean("POETIC_JUDGE_V2");
+  },
+  get MULTI_LENS_CRITERIA() {
+    return getRuntimeEnv("POETIC_MULTI_LENS_CRITERIA") === "1";
+  },
+  get STRATEGY_LENS_V2() {
+    return readTriStateMode("POETIC_STRATEGY_LENS_V2", "off");
+  },
+  // Judge Refinement flags (Phase 1-4)
+  get TEST_GATE_FOR_TEST_INTENT() {
+    return getRuntimeEnv("POETIC_TEST_GATE_FOR_TEST_INTENT") !== "0";
+  },
+  get ENRICH_AI_WITH_TEST_RESULTS() {
+    return getRuntimeEnv("POETIC_ENRICH_AI_WITH_TEST_RESULTS") !== "0";
+  },
+  get PER_INTENT_WEIGHT_ADJUSTMENTS() {
+    return getRuntimeEnv("POETIC_PER_INTENT_WEIGHT_ADJUSTMENTS") === "1";
+  },
+  get JUDGE_TRACE_ARTIFACTS() {
+    return getRuntimeEnv("POETIC_JUDGE_TRACE_ARTIFACTS") === "1";
+  },
+  // Judge refactoring canary — controls all Phase 1-4 behavior changes
+  // 'off': Legacy behavior (pre-refactor)
+  // 'shadow': Old behavior enforced (same as off); new behavior may be computed for comparison logging
+  // 'on': New behavior active (default after validation)
+  // Gate pattern: `!== 'on'` = legacy path (off + shadow), `=== 'on'` = new path
+  get JUDGE_REFACTOR_V4() {
+    return readTriStateMode("POETIC_JUDGE_REFACTOR_V4", "on");
+  },
+  // Evidence reliability prompt mode (input-first, no post-LLM adjudication)
+  // Controls whether the Signal Reliability appendix is included and marked experimental.
+  // 'off': No reliability appendix
+  // 'shadow': Reliability appendix included with [EXPERIMENTAL] marker
+  // 'on': Reliability appendix included without [EXPERIMENTAL] marker
+  get EVIDENCE_PROPORTIONALITY_GATE() {
+    return readTriStateMode("POETIC_EVIDENCE_PROPORTIONALITY_GATE", "on");
+  },
+  // Scope adequacy signal — detects output disproportionate to task magnitude
+  // 'off': Not computed
+  // 'shadow': Computed + attached (wouldBePenalty), not enforced (appliedPenalty=0)
+  // 'on': Computed + enforced (appliedPenalty = wouldBePenalty)
+  //
+  // Default 'off' (decided 2026-07-09, expired shadow review): six months of
+  // shadow mode produced zero persisted evidence — the signal is not written to
+  // telemetry, not injected into judge prompts, and contributes 0 to scores, so
+  // shadow was pure wasted compute. Promotion requires wiring persistence first;
+  // opt in explicitly via POETIC_SCOPE_ADEQUACY to collect evidence.
+  get SCOPE_ADEQUACY() {
+    return readTriStateMode("POETIC_SCOPE_ADEQUACY", "off");
+  },
+  // Test signal rebalance rollout
+  // 'off'/'shadow': legacy behavior
+  // 'on': intent-gated test weighting behavior
+  get TEST_SIGNAL_REBALANCE() {
+    return readTriStateMode("POETIC_TEST_SIGNAL_REBALANCE", "off");
+  },
+  // Unified TypeScript-error policy surface.
+  // All modes currently map to advisory behavior; this getter exists so the
+  // policy contract is data-driven before any enforcement semantics are added.
+  get TSC_POLICY() {
+    const explicit = getRuntimeEnv("POETIC_TSC_POLICY");
+    return explicit === "off" ? "off" : "shadow";
+  },
+  // Legacy per-dimension judge scoring rollout.
+  // Env var name is retained for compatibility with existing configs.
+  // 'off': Dimensions flattened to unified score
+  // 'shadow': Unflattened dims computed + logged to telemetry, flattened used for scoring
+  // 'on': Unflattened dims used for scoring (default)
+  //
+  // Shadow collects per-dimension data without affecting outcomes, enabling analysis
+  // of score compression and dimension-level patterns before committing to 'on'.
+  get HYBRID_DIM_SCORES() {
+    return readTriStateMode("POETIC_HYBRID_DIM_SCORES", "on");
+  },
+  // Variant differentiation signals — controls M2 prompt instructions,
+  // A2 coherence signal, and A3 scope violation signal
+  // 'off': No differentiation signals added
+  // 'shadow': Signals computed + logged but not injected into prompts
+  // 'on': Signals active in prompts (default)
+  get VARIANT_DIFFERENTIATION_SIGNALS() {
+    return readTriStateMode("POETIC_VARIANT_DIFF_SIGNALS", "on");
+  },
+  // LLM final score authority — use LLM's fs (final score) as winner's qualityScore
+  // 'off': Current behavior (host-aggregated score from ns values)
+  // 'shadow': Log delta between LLM fs and host aggregate, use host aggregate
+  // 'on': Use LLM's fs as winner's qualityScore when present and valid; fall back to host aggregate
+  get LLM_FINAL_SCORE_AUTHORITY() {
+    return readTriStateMode("POETIC_LLM_FINAL_SCORE_AUTHORITY", "on");
+  },
+  // Cross-judge adjudication telemetry — majority comparison when judges disagree
+  // 'off': No adjudication metadata (default)
+  // 'shadow': Compute adjudication and attach metadata, preserving primary winner
+  // 'on': Same as shadow; kept for compatibility, never overrides the primary winner
+  //
+  // Disabled by default: adjudication depends on winnerSelectionMetadata.margin from
+  // the primary judge, but current primary paths do not consistently populate that field.
+  // Cross-judge adjudication is telemetry-only. Overriding a trusted primary with
+  // lower-reliability judges contradicts the purpose of selecting a primary.
+  get CROSS_JUDGE_ADJUDICATION() {
+    return readTriStateMode("POETIC_CROSS_JUDGE_ADJUDICATION", "off");
+  },
+  // Escalated Matrix authority policy.
+  // Matrix authority is always automatic. The env var is retained only to warn
+  // about legacy opt-out/advisory values instead of silently changing behavior.
+  get MATRIX_AUTHORITY() {
+    const raw = getRuntimeEnv("POETIC_MATRIX_AUTHORITY");
+    if (raw !== void 0 && !globalFeatureFlagState[MATRIX_AUTHORITY_INVALID_WARNING_KEY]) {
+      console.warn(
+        `Warning: Ignoring POETIC_MATRIX_AUTHORITY="${raw}". Matrix authority is automatic and cannot be disabled by this environment variable.`
+      );
+      globalFeatureFlagState[MATRIX_AUTHORITY_INVALID_WARNING_KEY] = true;
+    }
+    return "automatic";
+  },
+  // Correctness evidence gates — classify evidence signals as verified/neutral for prompt injection
+  // 'off': No evidence classification
+  // 'shadow': Classify and log, use legacy correctness-dominance text
+  // 'on': Replace static correctness-dominance text with evidence-class-aware versions
+  get CORRECTNESS_EVIDENCE_GATES() {
+    return readTriStateMode("POETIC_CORRECTNESS_EVIDENCE_GATES", "on");
+  },
+  // fs_check divergence rationale — validate LLM self-reported score coherence
+  // 'off': Skip all fs_check validation and the prompt rationale request
+  // 'shadow': Request rationale in the prompt + record coherence audit, never invalidate
+  // 'on': Incoherent or missing rationale -> judge-invalid with fallback
+  //
+  // PERMANENT shadow default (decided 2026-07-09, expired shadow review): shadow
+  // keeps the useful behavior (rationale requested from the LLM, coherence recorded
+  // in the audit) while 'on' converts formatting noncompliance into judge
+  // invalidation — pure availability loss, same reasoning as
+  // MX_VALIDATION_ENFORCEMENT below. 'on' remains available for strict/CI use.
+  get FS_DIVERGENCE_RATIONALE() {
+    return readTriStateMode("POETIC_FS_DIVERGENCE_RATIONALE", "shadow");
+  },
+  // Multi-Lens overlay — inject scanner signals and CoreLens anchors into arbiter prompt
+  // 'off': Skip computation entirely
+  // 'shadow': Compute scanner patterns and log to telemetry only; no prompt injection
+  // 'on': Inject scanner/CoreLens signals into arbiter prompt
+  //
+  // Default 'off' (decided 2026-07-09, expired shadow review): six months of
+  // shadow produced a single multi_lens_overlay_shadow telemetry event — far too
+  // little to evaluate the scanner/judge-outcome correlation shadow existed to
+  // measure, while paying a per-run diff scan on every multi-lens evaluation.
+  // Opt in via POETIC_MULTI_LENS_OVERLAY to resume collection or enable injection.
+  get MULTI_LENS_OVERLAY() {
+    return readTriStateMode("POETIC_MULTI_LENS_OVERLAY", "off");
+  },
+  // Judge independence tracking — multi-pair Spearman/agreement rate with CI and alerts
+  // 'off': No independence computation
+  // 'shadow': Compute and log, no alerts
+  // 'on': Compute, log, and emit alerts when convergence thresholds exceeded
+  get JUDGE_INDEPENDENCE_TRACKING() {
+    return readTriStateMode("POETIC_JUDGE_INDEPENDENCE_TRACKING", "on");
+  },
+  // Multi-lens extension (mx) validation enforcement
+  // mx is an explainability payload (lens reasoning + evidence citations) attached to
+  // audit/metadata only — it does NOT affect winner selection. Throwing on malformed mx
+  // is pure availability loss with no correctness upside, so the default is 'shadow'.
+  // 'on':     Throw on invalid/missing mx (strict/CI mode)
+  // 'shadow': Log warning + record in audit, continue without mx (default)
+  // 'off':    Skip mx validation entirely
+  get MX_VALIDATION_ENFORCEMENT() {
+    return readTriStateMode("POETIC_MX_VALIDATION_ENFORCEMENT", "shadow");
+  },
+  // Judge profile — selects the active configuration set for judge prompt construction.
+  // 'stable':       Production default. Deliverable-first ordering validated by AP7.
+  // 'legacy':       Pre-V1 ordering. Escape hatch only; use to revert if regressions found.
+  // 'shadow':       Stable prompt behavior + background shadow evaluation hooks (for canarying new judge logic).
+  // 'experimental': Reserved slot for next-iteration research. No stability guarantee.
+  //
+  // Env var: POETIC_JUDGE_PROFILE
+  get JUDGE_PROFILE() {
+    const raw = getRuntimeEnv("POETIC_JUDGE_PROFILE");
+    if (raw === "stable" || raw === "legacy" || raw === "shadow" || raw === "experimental")
+      return raw;
+    if (raw === "on") return "stable";
+    if (raw === "off") return "legacy";
+    return "stable";
+  },
+  // Timeout for multi-agent evaluation (ms)
+  get MULTI_AGENT_JUDGE_TIMEOUT_MS() {
+    const raw = getRuntimeEnv("POETIC_JUDGE_MULTI_AGENT_TIMEOUT_MS");
+    if (!raw) return 3e5;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return 3e5;
+    return parsed;
+  },
+  // Maximum variants the multi-agent judge will evaluate
+  get MULTI_AGENT_MAX_VARIANTS() {
+    const raw = getRuntimeEnv("POETIC_JUDGE_MULTI_AGENT_MAX_VARIANTS");
+    if (!raw) return 6;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return 6;
+    return parsed;
+  },
+  // Test production guidance — controls Changes 2-4 of Multi-Lens judge improvement
+  // Enables test production signal computation, testsExpected heuristic, and tiered scoring rules.
+  // Change 1 (provider workspace filtering) is ungated — always beneficial.
+  //
+  // 'off': No test-production prompt injection.
+  // 'shadow': Test production signal computed and attached to empirical signals.
+  //           No test-production prompt lines or scoring guidance injected.
+  // 'on': Full prompt injection including testsExpected heuristic and tiered scoring rules.
+  //
+  // Rollout acceptance criteria (shadow → on) remain as recorded in git history.
+  // Default 'off' (decided 2026-07-09, expired shadow review): in shadow the
+  // signal is computed and attached but never injected into prompts (both
+  // consumers gate on === 'on') and never persisted to telemetry, so six months
+  // of shadow produced zero reviewable evidence. Opt in explicitly via
+  // POETIC_TEST_PRODUCTION_GUIDANCE; promotion requires wiring persistence first.
+  get TEST_PRODUCTION_GUIDANCE() {
+    return readTriStateMode("POETIC_TEST_PRODUCTION_GUIDANCE", "off");
+  },
+  // Phase 1 Judge Quality Optimization flags
+  // All default to 'off' — no behavior change at deploy.
+  // 'off': Baseline behavior (control arm)
+  // 'shadow': Compute + log deltas without applying (instrumentation only)
+  // 'on': Active treatment arm behavior
+  // Fix 1: Override FILE: marker suppression when explicit review/analysis task detected
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (negative + positive case canaries)
+  get ANALYSIS_REVIEW_DETECTION() {
+    return readTriStateMode("POETIC_ANALYSIS_REVIEW_DETECTION", "on");
+  },
+  // Fix 2: Inject duplication ratio as pre-LLM factual signal into judge prompt
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (negative live path + unit tests)
+  // Highest residual risk — monitor for boilerplate false positives
+  get DUPLICATE_CONTENT_SIGNAL() {
+    return readTriStateMode("POETIC_DUPLICATE_CONTENT_SIGNAL", "on");
+  },
+  // R1: Add evidence anchor citation instructions to Hybrid/Multi-Lens prompts
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (38/38 valid EIDs, 0% invalid)
+  get EVIDENCE_ANCHOR_CITATIONS() {
+    return readTriStateMode("POETIC_EVIDENCE_ANCHOR_CITATIONS", "on");
+  },
+  // R2: Allow empty strengths/weaknesses arrays when no genuine items exist
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (no lazy arrays with R6/R7 counterbalance)
+  get RATIONALE_EMPTY_ARRAYS() {
+    return readTriStateMode("POETIC_RATIONALE_EMPTY_ARRAYS", "on");
+  },
+  // R3: Per-dimension weight differentiation in criteria-ledger instead of uniform
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (~1-2pt os drift, within tolerance)
+  get CRITERIA_DIMENSION_WEIGHTS() {
+    return readTriStateMode("POETIC_CRITERIA_DIMENSION_WEIGHTS", "on");
+  },
+  // R5: Observe no-output materialization (variant-health); never pre-exclude from judge prompt.
+  // Default shadow: record would-exclude impact without hiding variants from the judge.
+  get NO_OUTPUT_PREEVAL_GATE() {
+    return readTriStateMode("POETIC_NO_OUTPUT_PREEVAL_GATE", "shadow");
+  },
+  // R6+R7: Prompt instructions for unique observations and real weaknesses (dedup/contamination)
+  // Enabled 2026-02-25: Verified in Phase 1 rollout (distinct strengths, no fabrication)
+  get RATIONALE_DEDUP() {
+    return readTriStateMode("POETIC_RATIONALE_DEDUP", "on");
+  }
+};
+var ORCHESTRATOR_FEATURE_FLAGS = {
+  get CROSS_PROVIDER_PIVOT() {
+    return readTriStateMode("POETIC_CROSS_PROVIDER_PIVOT", "off");
+  },
+  /**
+   * Intent pipeline rollout gate (planning/decomposition front-door integration).
+   * - 'off': Keep legacy/manual front-door behavior
+   * - 'shadow': Run new path for comparison/telemetry, keep legacy output
+   * - 'on': Use intent pipeline output in production
+   */
+  get INTENT_PIPELINE() {
+    return readTriStateMode("POETIC_INTENT_PIPELINE", "on");
+  },
+  /**
+   * Task split strategy selector for planning task split commands.
+   * - 'auto' (default): Derive from INTENT_PIPELINE (off->rule, shadow->shadow, on->llm)
+   * - 'rule': Always use legacy rule-based splitter
+   * - 'shadow': Run both splitters and keep rule-based output
+   * - 'llm': Use LLM decomposition path with rule fallback on failures
+   */
+  get INTENT_TASK_SPLITTER_MODE() {
+    const raw = getRuntimeEnv("POETIC_INTENT_TASK_SPLITTER_MODE");
+    if (raw === "rule" || raw === "shadow" || raw === "llm" || raw === "auto") {
+      return raw;
+    }
+    return "auto";
+  },
+  /**
+   * Zero-flag compete: discover variants via the config resolver without explicit --variant flags.
+   * Opt-in via POETIC_FEATURE_COMPETE_ZERO_FLAG=1.
+   */
+  get COMPETE_ZERO_FLAG() {
+    return getRuntimeEnv("POETIC_FEATURE_COMPETE_ZERO_FLAG") === "1";
+  }
+};
+
+export {
+  JUDGE_FEATURE_FLAGS,
+  ORCHESTRATOR_FEATURE_FLAGS
+};
+//# sourceMappingURL=chunk-BSE4R6XD.js.map