@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/chunk-OIWU3NYV.js

@@ -0,0 +1,199 @@
+import {
+  DEFAULT_DECAY_RATE,
+  decay
+} from "./chunk-QMBYUVRL.js";
+
+// src/utils/harness/defaults.ts
+var QUEUE_NAMES = [
+  "auto-fix",
+  "needs-decision",
+  "investigation",
+  "backlog"
+];
+var DEFAULT_QUEUE_CONFIGS = {
+  "auto-fix": { gated: false },
+  "needs-decision": { gated: true },
+  investigation: { gated: true },
+  // `startOpen` intentionally omitted — backlog is not gated, so the flag
+  // would be meaningless. Dropped in Unit 15 G trim pass.
+  backlog: { gated: false }
+};
+var DEFAULT_SEVERITY_WEIGHTS = {
+  critical: 100,
+  high: 70,
+  medium: 40,
+  low: 10
+};
+function strategyKey(presetId, rootCause, intervention) {
+  return `${presetId}|${rootCause}\u2192${intervention}`;
+}
+var SELF_CORRECTABLE_RE = /\b(parse|json|config|validation|syntax)\b/i;
+var defaultErrorClassifier = (result) => SELF_CORRECTABLE_RE.test(result.detail) ? "self-correctable" : "structural";
+var DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
+
+Given an intake item, classify it and output JSON:
+{
+  "rootCause": "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown",
+  "intervention": "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate",
+  "route": "auto-fix" | "needs-decision" | "investigation" | "backlog",
+  "priority": <number 0-100>,
+  "triageReasoning": "<one sentence>"
+}
+
+Strategy model (past effectiveness):
+{{strategy}}
+
+Intake item:
+{{item}}`;
+var DEFAULT_EXECUTE_PROMPT = `You are an implementation agent.
+
+Given a triaged issue with root cause and intervention type, produce a fix.
+
+Issue:
+{{item}}
+
+Output JSON:
+{
+  "outcome": "success" | "failure" | "partial",
+  "detail": "<description of what was done or what failed>"
+}`;
+var DEFAULT_VERIFY_PROMPT = `You are a QA reviewer.
+
+Given an execution result, verify whether the fix is correct.
+
+Execution:
+{{execution}}
+
+Original issue:
+{{item}}
+
+Output JSON:
+{
+  "verified": true/false,
+  "findings": ["<finding1>", ...],
+  "errorClass": "self-correctable" | "structural"  // only if verified=false
+}`;
+function resolvePromptFn(raw, fallbackTemplate, substitute) {
+  if (typeof raw === "function") return raw;
+  const template = raw ?? fallbackTemplate;
+  return (input) => substitute(template, input);
+}
+
+// src/utils/harness/types.ts
+var DEFAULT_PRESET_ID = "default";
+
+// src/utils/harness/strategy.ts
+import { monotonicNs, node } from "@graphrefly/pure-ts/core";
+
+// src/utils/orchestration/audited-success-tracker.ts
+import { keepalive, reactiveMap } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+var AuditedSuccessTrackerGraph = class extends Graph {
+  /** Reactive entries — `Node<ReadonlyMap<TKey, TEntry>>`, fresh map per mutation. */
+  entries;
+  _map;
+  constructor(opts) {
+    super(opts?.name ?? "audited-success-tracker", opts?.graph);
+    this._map = reactiveMap({ name: "entries" });
+    this.entries = this._map.entries;
+    this.add(this.entries, { name: "entries" });
+    this.addDisposer(keepalive(this.entries));
+    this.addDisposer(() => this._map.dispose());
+  }
+  /**
+   * Record a completed attempt. `extra` fields are merged into the stored
+   * entry — use for domain-specific decoration (e.g. `{ rootCause,
+   * intervention }` on the strategy-model collapse path).
+   *
+   * **Caller contract for typed `TEntry`.** When `TEntry` extends
+   * {@link AuditedSuccessEntry} with required fields beyond
+   * `key`/`attempts`/`successes`/`successRate`, the caller must supply
+   * those required fields in `extra` on the **first** `record(key, ...)`
+   * for that key. The internal `as TEntry` cast trusts this. Subsequent
+   * `record(key, ...)` calls inherit the prior entry's fields, so `extra`
+   * may be omitted or partial. Forgetting required fields on the first
+   * record produces an entry whose typed-required fields are `undefined`
+   * at runtime — TS won't catch it. Strategy callers always pass
+   * `{ rootCause, intervention }`, so the StrategyEntry case is safe.
+   */
+  record(key, success, extra) {
+    const existing = this._map.get(key);
+    const attempts = (existing?.attempts ?? 0) + 1;
+    const successes = (existing?.successes ?? 0) + (success ? 1 : 0);
+    this._map.set(key, {
+      ...existing ?? {},
+      ...extra ?? {},
+      key,
+      attempts,
+      successes,
+      successRate: successes / attempts
+    });
+  }
+  /**
+   * Look up the entry for a key.
+   *
+   * Pure read: this tracker doesn't configure a TTL on the underlying
+   * `reactiveMap`, so `_map.get(key)` never triggers TTL-expiry pruning
+   * (which would otherwise be an observable side effect emitting a fresh
+   * `entries` snapshot). If `AuditedSuccessTrackerOptions` ever gains a
+   * `mapOptions` carve-out exposing TTL, revisit this contract.
+   */
+  lookup(key) {
+    return this._map.get(key);
+  }
+};
+function auditedSuccessTracker(opts) {
+  return new AuditedSuccessTrackerGraph(opts);
+}
+
+// src/utils/harness/strategy.ts
+function strategyModel() {
+  return auditedSuccessTracker({ name: "strategy" });
+}
+function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
+  const severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };
+  const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE;
+  const effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;
+  const effectivenessBoost = signals?.effectivenessBoost ?? 15;
+  const deps = [item, strategy, lastInteractionNs];
+  if (urgency) deps.push(urgency);
+  return node(
+    deps,
+    (batchData, actions, ctx) => {
+      const values = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      const itm = values[0];
+      const strat = values[1];
+      const lastNs = values[2];
+      const urg = urgency ? values[3] : 0;
+      const baseWeight = severityWeights[itm.severity ?? "medium"];
+      const ageSeconds = (monotonicNs() - lastNs) / 1e9;
+      let score = decay(baseWeight, ageSeconds, decayRate, 0);
+      const key = strategyKey(DEFAULT_PRESET_ID, itm.rootCause, itm.intervention);
+      const entry = strat.get(key);
+      if (entry && entry.successRate >= effectivenessThreshold) {
+        score += effectivenessBoost;
+      }
+      score += urg * 20;
+      actions.emit(score);
+    },
+    { name: "priority-score", describeKind: "derived" }
+  );
+}
+
+export {
+  QUEUE_NAMES,
+  DEFAULT_QUEUE_CONFIGS,
+  DEFAULT_SEVERITY_WEIGHTS,
+  strategyKey,
+  defaultErrorClassifier,
+  DEFAULT_TRIAGE_PROMPT,
+  DEFAULT_EXECUTE_PROMPT,
+  DEFAULT_VERIFY_PROMPT,
+  resolvePromptFn,
+  DEFAULT_PRESET_ID,
+  strategyModel,
+  priorityScore
+};
+//# sourceMappingURL=chunk-OIWU3NYV.js.map

package/dist/chunk-OIWU3NYV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/harness/defaults.ts","../src/utils/harness/types.ts","../src/utils/harness/strategy.ts","../src/utils/orchestration/audited-success-tracker.ts"],"sourcesContent":["/**\n * Harness runtime defaults (roadmap §9.0).\n *\n * Split out from `types.ts` in Wave B Unit 15 G so the type file holds\n * only type declarations and plug-in contracts. Runtime constants and\n * helpers live here; the harness barrel (`index.ts`) re-exports both so\n * external consumers see a single surface.\n *\n * @module\n */\n\nimport type {\n\tErrorClass,\n\tErrorClassifier,\n\tExecutionResult,\n\tIntervention,\n\tPresetId,\n\tQueueConfig,\n\tQueueRoute,\n\tRootCause,\n\tSeverity,\n\tStrategyKey,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Route / queue\n// ---------------------------------------------------------------------------\n\n/** Ordered queue route names for iteration. */\nexport const QUEUE_NAMES: readonly QueueRoute[] = [\n\t\"auto-fix\",\n\t\"needs-decision\",\n\t\"investigation\",\n\t\"backlog\",\n];\n\n/** Default queue configurations. */\nexport const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig> = {\n\t\"auto-fix\": { gated: false },\n\t\"needs-decision\": { gated: true },\n\tinvestigation: { gated: true },\n\t// `startOpen` intentionally omitted — backlog is not gated, so the flag\n\t// would be meaningless. Dropped in Unit 15 G trim pass.\n\tbacklog: { gated: false },\n};\n\n// ---------------------------------------------------------------------------\n// Priority scoring\n// ---------------------------------------------------------------------------\n\n/** Default severity weights. */\nexport const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number> = {\n\tcritical: 100,\n\thigh: 70,\n\tmedium: 40,\n\tlow: 10,\n};\n\n/** Default decay rate: ~7-day half-life. Re-exported from `base/utils/decay.ts`. */\nexport { DEFAULT_DECAY_RATE } from \"../../base/utils/decay.js\";\n\n// ---------------------------------------------------------------------------\n// Strategy model\n// ---------------------------------------------------------------------------\n\n/**\n * Canonical 3-axis composite-key factory: `${presetId}|${rootCause}→${intervention}`.\n *\n * **Phase 13.I axis extension (DS-13.I, 2026-05-01).** Pre-multi-agent\n * callers without a preset registry pass {@link DEFAULT_PRESET_ID}\n * (`\"default\"`) for the first arg. Pre-1.0 breaking signature change;\n * persisted strategy-model snapshots from before this date are NOT portable.\n */\nexport function strategyKey(\n\tpresetId: PresetId,\n\trootCause: RootCause,\n\tintervention: Intervention,\n): StrategyKey {\n\treturn `${presetId}|${rootCause}→${intervention}`;\n}\n\n// ---------------------------------------------------------------------------\n// Error classifier\n// ---------------------------------------------------------------------------\n\n/**\n * Regex-word-boundary match over a closed keyword set. Callers needing\n * domain-specific failure modes should supply a custom\n * {@link ErrorClassifier}; this default exists so zero-config harness runs\n * still distinguish parse-class failures (fast-retry) from everything\n * else (full loop via reingestion).\n */\nconst SELF_CORRECTABLE_RE = /\\b(parse|json|config|validation|syntax)\\b/i;\n\n/** Default error classifier: parse/config errors are self-correctable. */\nexport const defaultErrorClassifier: ErrorClassifier = (result: ExecutionResult): ErrorClass =>\n\tSELF_CORRECTABLE_RE.test(result.detail) ? \"self-correctable\" : \"structural\";\n\n// ---------------------------------------------------------------------------\n// Default stage prompts\n// ---------------------------------------------------------------------------\n\n/** Default TRIAGE prompt — LLM classifies intake items into root-cause + intervention + route + priority. */\nexport const DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.\n\nGiven an intake item, classify it and output JSON:\n{\n  \"rootCause\": \"composition\" | \"missing-fn\" | \"bad-docs\" | \"schema-gap\" | \"regression\" | \"unknown\",\n  \"intervention\": \"template\" | \"catalog-fn\" | \"docs\" | \"wrapper\" | \"schema-change\" | \"investigate\",\n  \"route\": \"auto-fix\" | \"needs-decision\" | \"investigation\" | \"backlog\",\n  \"priority\": <number 0-100>,\n  \"triageReasoning\": \"<one sentence>\"\n}\n\nStrategy model (past effectiveness):\n{{strategy}}\n\nIntake item:\n{{item}}`;\n\n/** Default EXECUTE prompt — LLM produces a fix given a triaged issue. */\nexport const DEFAULT_EXECUTE_PROMPT = `You are an implementation agent.\n\nGiven a triaged issue with root cause and intervention type, produce a fix.\n\nIssue:\n{{item}}\n\nOutput JSON:\n{\n  \"outcome\": \"success\" | \"failure\" | \"partial\",\n  \"detail\": \"<description of what was done or what failed>\"\n}`;\n\n/** Default VERIFY prompt — LLM reviews an execution result against the original issue. */\nexport const DEFAULT_VERIFY_PROMPT = `You are a QA reviewer.\n\nGiven an execution result, verify whether the fix is correct.\n\nExecution:\n{{execution}}\n\nOriginal issue:\n{{item}}\n\nOutput JSON:\n{\n  \"verified\": true/false,\n  \"findings\": [\"<finding1>\", ...],\n  \"errorClass\": \"self-correctable\" | \"structural\"  // only if verified=false\n}`;\n\n// ---------------------------------------------------------------------------\n// Prompt resolver helper\n// ---------------------------------------------------------------------------\n\n/**\n * Collapse the `string | ((input: In) => string) | undefined` prompt-template\n * pattern into a single `(input: In) => string`. A function `raw` is used as-is\n * (the caller opted into full control). Otherwise `raw ?? fallbackTemplate`\n * is fed through `substitute`, which does the placeholder replacement.\n *\n * Used by the three harness stages (TRIAGE / EXECUTE / VERIFY), which each\n * accept a `string | function` config but use different placeholder schemes\n * (`{{item}}`, `{{execution}}`, `{{strategy}}`). The helper absorbs only the\n * branch logic; the per-stage placeholder substitution lives at the call site.\n */\nexport function resolvePromptFn<In>(\n\traw: string | ((input: In) => string) | undefined,\n\tfallbackTemplate: string,\n\tsubstitute: (template: string, input: In) => string,\n): (input: In) => string {\n\tif (typeof raw === \"function\") return raw;\n\tconst template = raw ?? fallbackTemplate;\n\treturn (input) => substitute(template, input);\n}\n","/**\n * Harness wiring types (roadmap §9.0).\n *\n * Shared types for the reactive collaboration loop: intake, triage, queue,\n * gate, execute, verify, reflect. These types are intentionally domain-agnostic\n * — the harness loop is not specific to eval workflows.\n *\n * Runtime constants and helpers live in `./defaults.ts`. The harness barrel\n * (`./index.ts`) re-exports both so external consumers see a single surface.\n *\n * @module\n */\n\nimport type { Node } from \"@graphrefly/pure-ts/core\";\nimport type { NodeInput } from \"@graphrefly/pure-ts/extra\";\n// Type-only import avoids a runtime cycle with `patterns/ai`.\nimport type { LLMAdapter } from \"../ai/index.js\";\nimport type { JobEnvelope } from \"../job-queue/index.js\";\n\n// ---------------------------------------------------------------------------\n// Intake\n// ---------------------------------------------------------------------------\n\n/** Known intake source tags. */\nexport type KnownIntakeSource = \"eval\" | \"test\" | \"human\" | \"code-change\" | \"hypothesis\" | \"parity\";\n\n/**\n * Sources that can produce intake items. Open union — the known tags\n * retain IDE autocomplete while user-supplied strings (e.g. `\"schema\"`,\n * `\"slack\"`) pass through without a type change.\n */\nexport type IntakeSource = KnownIntakeSource | (string & {});\n\n/** Severity levels for intake items. */\nexport type Severity = \"critical\" | \"high\" | \"medium\" | \"low\";\n\n/** Root cause categories for triage classification. */\nexport type RootCause =\n\t| \"composition\"\n\t| \"missing-fn\"\n\t| \"bad-docs\"\n\t| \"schema-gap\"\n\t| \"regression\"\n\t| \"unknown\";\n\n/** Intervention types that address root causes. */\nexport type Intervention =\n\t| \"template\"\n\t| \"catalog-fn\"\n\t| \"docs\"\n\t| \"wrapper\"\n\t| \"schema-change\"\n\t| \"investigate\";\n\n/** Routing destinations after triage. Closed union — iterated via `QUEUE_NAMES`. */\nexport type QueueRoute = \"auto-fix\" | \"needs-decision\" | \"investigation\" | \"backlog\";\n\n/**\n * An item entering the harness loop via the INTAKE stage.\n *\n * All intake sources produce this uniform shape — the intake topic\n * doesn't care where items came from.\n *\n * `$`-prefix keys (`$reingestions`, `$retries` on {@link TriagedItem}) are\n * framework-only — an LLM round-tripping the serialized item is far less\n * likely to echo back a `$`-prefixed key than an `_`-prefixed one, which\n * neutralizes the field-collision class that surfaced earlier in the\n * router's spread order.\n */\nexport interface IntakeItem {\n\tsource: IntakeSource;\n\tsummary: string;\n\tevidence: string;\n\taffectsAreas: string[];\n\taffectsEvalTasks?: string[];\n\tseverity?: Severity;\n\t/**\n\t * Identity-preservation key for retried / reingested items.\n\t *\n\t * `relatedTo[0]` MUST carry the original tracking key for retry /\n\t * reingest items so the harness's `routeJobIds` map preserves\n\t * identity across decorated retry summaries (per qa D1, 2026-04-29).\n\t * First-time publishes leave this `undefined`; the tracking key\n\t * falls back to `summary` via {@link trackingKey}.\n\t *\n\t * **Collision contract (DS-13.5.D.3, locked 2026-05-01).** Items\n\t * lacking `relatedTo[0]` and producing colliding `trackingKey()`\n\t * derivations overwrite the prior `routeJobIds` entry —\n\t * **last-write-wins**. Framework-enforced uniqueness was rejected\n\t * because it would break legitimate retry / reingest patterns where\n\t * an explicit `relatedTo[0]` carries the original key forward.\n\t *\n\t * **Single-threaded contract.** Ack runs before reingest publishes\n\t * (harness flow invariant) — under the standard single-threaded JS\n\t * pump this collapses the only practical race window. Multi-publisher\n\t * concurrency or batched intake of two first-time items with identical\n\t * `summary` can still race at boundaries; callers carrying their own\n\t * stable id should set `relatedTo[0]`.\n\t *\n\t * See {@link trackingKey} JSDoc in `patterns/_internal/index.ts` for\n\t * the uniqueness caller contract.\n\t *\n\t * Spec: docs/implementation-plan.md DS-13.5.D.3\n\t */\n\trelatedTo?: string[];\n\t/** Item-carried reingestion count. Incremented on each full-loop reingestion. */\n\t$reingestions?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Triage output\n// ---------------------------------------------------------------------------\n\n/** Output of the TRIAGE stage — enriched intake item with classification. */\nexport interface TriagedItem extends IntakeItem {\n\trootCause: RootCause;\n\tintervention: Intervention;\n\troute: QueueRoute;\n\tpriority: number;\n\ttriageReasoning?: string;\n\t/** Item-carried retry count. Incremented on each fast-retry pass. */\n\t$retries?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Strategy model\n// ---------------------------------------------------------------------------\n\n/**\n * Preset / persona / skill identifier. Open string set; conventionally\n * matches keys used in {@link presetRegistry} (Phase 13.H). Use\n * {@link DEFAULT_PRESET_ID} (\"default\") when no preset registry is wired.\n */\nexport type PresetId = string;\n\n/** Default presetId used when no preset registry is wired (back-compat for 2-axis callers). */\nexport const DEFAULT_PRESET_ID: PresetId = \"default\";\n\n/**\n * Key format: `${presetId}|${rootCause}→${intervention}`.\n *\n * **Phase 13.I axis extension (DS-13.I, 2026-05-01).** Widened from the\n * pre-multi-agent 2-axis `${rootCause}→${intervention}` to a 3-axis key\n * carrying the presetId of the agent that ran. Pre-1.0 breaking change;\n * existing callsites pass {@link DEFAULT_PRESET_ID} for the new axis when\n * they don't have a preset registry wired. The strategy-model storage\n * (`auditedSuccessTracker<StrategyKey, StrategyEntry>`) is unchanged\n * structurally — the key shape change cascades through the existing\n * tracker without surface refactor.\n */\nexport type StrategyKey = `${PresetId}|${RootCause}→${Intervention}`;\n\n/**\n * Effectiveness record for a `(presetId, rootCause, intervention)` triple.\n * Stored under `auditedSuccessTracker<StrategyKey, StrategyEntry>` (Class B\n * audit Alt E collapse, 2026-04-30; presetId axis added Phase 13.I,\n * 2026-05-01) — `key` is the composite `strategyKey(presetId, rc, intv)`\n * computed at the call site; `presetId` / `rootCause` / `intervention` are\n * decoration carried via `record(...)` so consumers can read them without\n * re-parsing the key.\n */\nexport interface StrategyEntry {\n\tkey: StrategyKey;\n\tpresetId: PresetId;\n\trootCause: RootCause;\n\tintervention: Intervention;\n\tattempts: number;\n\tsuccesses: number;\n\tsuccessRate: number;\n}\n\n// ---------------------------------------------------------------------------\n// Execution & verification\n// ---------------------------------------------------------------------------\n\n/**\n * LLM output shape from the EXECUTE stage (partial — lacks `item`).\n *\n * Generic over the artifact type `A` so typed executors like\n * `refineExecutor<T>` can flow `T` through to an `evalVerifier<T>` without\n * the caller casting `artifact` at the boundary. Defaults to `unknown`\n * for escape-hatch executors that carry opaque state.\n */\nexport type ExecuteOutput<A = unknown> = {\n\t/**\n\t * Execution outcome classification:\n\t *\n\t * - `\"success\"`: execution completed cleanly and the artifact (if any) is\n\t *   ready for verification. The verifier should proceed with a full\n\t *   evaluation pass.\n\t * - `\"failure\"`: execution did not produce a usable artifact — the actuator\n\t *   threw, a prompt parse failed, or `shouldApply` skipped the item. The\n\t *   verifier should treat this as a non-result and route accordingly.\n\t * - `\"partial\"`: execution produced a candidate that converged but did not\n\t *   fully meet verification criteria. Used by `refineExecutor` when the\n\t *   iteration cap is reached without full convergence; the artifact holds\n\t *   the best candidate achieved.\n\t */\n\toutcome: \"success\" | \"failure\" | \"partial\";\n\tdetail: string;\n\t/**\n\t * Optional opaque artifact that a custom executor (e.g. `refineExecutor`)\n\t * may attach so downstream verifiers can re-run evaluation against the\n\t * thing that was produced. LLM-backed default executors never populate\n\t * this — it's an escape hatch for reactive executors carrying structured\n\t * output (a refined prompt, a patched spec, a generated template, ...).\n\t */\n\tartifact?: A;\n};\n\n/** Full execution result assembled downstream (LLM output + context). */\nexport interface ExecutionResult<A = unknown> {\n\titem: TriagedItem;\n\t/**\n\t * Execution outcome classification. Same semantics as\n\t * {@link ExecuteOutput.outcome}:\n\t *\n\t * - `\"success\"`: execution completed cleanly; artifact is ready for\n\t *   verification.\n\t * - `\"failure\"`: no usable artifact was produced.\n\t * - `\"partial\"`: best candidate produced but convergence criteria not met\n\t *   (iteration cap reached in `refineExecutor`).\n\t */\n\toutcome: \"success\" | \"failure\" | \"partial\";\n\tdetail: string;\n\t/**\n\t * Passthrough of {@link ExecuteOutput.artifact} when the executor emitted\n\t * one. Reactive executors like `refineExecutor` populate this; LLM-backed\n\t * default executors leave it undefined.\n\t */\n\tartifact?: A;\n}\n\n/** Whether an error is self-correctable (fast-retry) or structural (full loop). */\nexport type ErrorClass = \"self-correctable\" | \"structural\";\n\n/** Classifier for fast-retry path. */\nexport type ErrorClassifier = (result: ExecutionResult) => ErrorClass;\n\n// ---------------------------------------------------------------------------\n// Verification output\n// ---------------------------------------------------------------------------\n\n/** Result of the VERIFY stage. */\nexport interface VerifyResult<A = unknown> {\n\titem: TriagedItem;\n\texecution: ExecutionResult<A>;\n\tverified: boolean;\n\tfindings: string[];\n\terrorClass?: ErrorClass;\n}\n\n/**\n * Verifier output shape — what a custom verifier emits. The harness\n * assembles this into the full {@link VerifyResult} using the triaged\n * item + execute output sampled from `executeContextNode`.\n */\nexport interface VerifyOutput {\n\tverified: boolean;\n\tfindings: string[];\n\terrorClass?: ErrorClass;\n}\n\n// ---------------------------------------------------------------------------\n// Priority scoring\n// ---------------------------------------------------------------------------\n\n/** Configurable signals for priority scoring. */\nexport interface PrioritySignals {\n\t/** Per-severity base weight (default: critical=100, high=70, medium=40, low=10). */\n\tseverityWeights?: Partial<Record<Severity, number>>;\n\t/** Decay rate per second for attention decay (default ~1.15e-6 ≈ 7-day half-life). */\n\tdecayRate?: number;\n\t/** Strategy model effectiveness boost threshold (default 0.7). */\n\teffectivenessThreshold?: number;\n\t/** Strategy model effectiveness boost amount (default 15). */\n\teffectivenessBoost?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Harness loop configuration\n// ---------------------------------------------------------------------------\n\nimport type { StrategySnapshot } from \"./strategy.js\";\n\n/** Per-queue configuration in the harness loop. */\nexport interface QueueConfig {\n\t/** Whether this queue is gated (requires human approval). */\n\tgated: boolean;\n\t/** Maximum pending items in the gate (default Infinity). */\n\tmaxPending?: number;\n\t/** Start the gate in open (auto-approve) mode? Only meaningful when `gated: true`. */\n\tstartOpen?: boolean;\n}\n\n/**\n * Accumulating per-job payload threaded through the harness's\n * `executeFlow` ({@link harnessLoop} Tier 6.5 C2 lock). Each stage's work fn\n * receives the prior payload and returns a new one with its own field\n * filled in:\n *\n * - The `enqueueEffect` seeds with `{ item }` only.\n * - The execute work fn fills `execution`.\n * - The verify work fn fills `verify`.\n *\n * The post-completed dispatch effect reads `verify.verified` /\n * `verify.errorClass` to route the item to `verifyResults` /\n * `retryTopic.publish(...)` / `intake.publish(...)` (3-way verdict).\n *\n * Carrying `item` through stage payloads (rather than re-pairing via a\n * separate `withLatestFrom` node) is the C2 deviation from today's\n * `executeContextNode` design: each `JobEnvelope` is self-contained, so the\n * verify pump can run multiple in-flight jobs in parallel without an\n * external pairing node.\n */\nexport interface HarnessJobPayload<A = unknown> {\n\t/** The triaged item flowing through execute → verify → dispatch. */\n\titem: TriagedItem;\n\t/** Filled by the execute work fn. Verify reads this; dispatch routes. */\n\texecution?: ExecutionResult<A>;\n\t/** Filled by the verify work fn. Dispatch reads `verified` / `errorClass`. */\n\tverify?: VerifyOutput;\n}\n\n/**\n * Pluggable EXECUTE work fn — receives a {@link JobEnvelope} carrying a\n * {@link HarnessJobPayload} (with `item` set, `execution` / `verify`\n * unset), returns a {@link NodeInput} that emits the same payload with\n * `execution` filled.\n *\n * **C2 contract (Tier 6.5 lock, 2026-04-28):**\n * 1. Emit DATA exactly once per claimed job. The JobFlow pump subscribes\n *    once, takes the first DATA, then unsubscribes. Subsequent emissions\n *    are ignored.\n * 2. Errors must be caught and surfaced as a `failure` outcome inside the\n *    payload — never throw / return ERROR. A pump nack would drop the\n *    item from JobFlow before the dispatch effect could route it.\n * 3. The work fn runs once per claim — no internal `switchMap` needed.\n *    Per-item subgraphs (e.g. a fresh `refineLoop` per claim) are\n *    instantiated inside the work fn body.\n *\n * `defaultLlmExecutor` (in `defaults.ts`) is a thin `adapter.invoke()`\n * wrapper. `refineExecutor` builds a per-claim `refineLoop`.\n * `actuatorExecutor` runs a side-effecting `apply(item, signal)`.\n */\nexport type HarnessExecutor<A = unknown> = (\n\tjob: JobEnvelope<HarnessJobPayload<A>>,\n\topts?: { signal: AbortSignal },\n) => NodeInput<HarnessJobPayload<A>>;\n\n/**\n * Pluggable VERIFY work fn — receives a {@link JobEnvelope} whose payload\n * has `item` + `execution` populated, returns a {@link NodeInput} that\n * emits the same payload with `verify` filled.\n *\n * Same C2 contract rules 1–3 as {@link HarnessExecutor}. The dispatch\n * effect downstream reads `verify.verified` (success → ack +\n * verifyResults publish), `verify.errorClass === \"self-correctable\"`\n * (retry → republish to retry topic with `$retries` bumped), or anything\n * else (structural → reingest to intake if budget remains).\n *\n * Verify-LLM-call failures (parse error, adapter throw, timeout) MUST be\n * caught and surfaced as a structural-failure `verify` payload (`{\n * verified: false, findings: [...], errorClass: \"structural\" }`) so the\n * dispatch effect can route the item rather than silently drop it.\n */\nexport type HarnessVerifier<A = unknown> = (\n\tjob: JobEnvelope<HarnessJobPayload<A>>,\n\topts?: { signal: AbortSignal },\n) => NodeInput<HarnessJobPayload<A>>;\n\n/** Triage prompt callable shape — pair of `[intake item, strategy snapshot]`. */\nexport type TriagePromptFn = (pair: readonly [IntakeItem, StrategySnapshot]) => string;\n/** Execute prompt callable shape. */\nexport type ExecutePromptFn = (item: TriagedItem) => string;\n/** Verify prompt callable shape — pair of `[execute output, triaged item]`. */\nexport type VerifyPromptFn<A = unknown> = (\n\tpair: readonly [ExecuteOutput<A> | null, TriagedItem | null],\n) => string;\n\n/** Options for {@link harnessLoop}. */\nexport interface HarnessLoopOptions<A = unknown> {\n\t/** LLM adapter for promptNode-based stages (triage + any default executor/verifier). */\n\tadapter: LLMAdapter;\n\n\t/** Custom triage prompt (receives IntakeItem + strategy snapshot as a tuple). */\n\ttriagePrompt?: string | TriagePromptFn;\n\n\t/**\n\t * Execute prompt — sugar over the default LLM executor. Ignored when\n\t * `executor` is set.\n\t */\n\texecutePrompt?: string | ExecutePromptFn;\n\n\t/**\n\t * Verify prompt — sugar over the default LLM verifier. Ignored when\n\t * `verifier` is set.\n\t */\n\tverifyPrompt?: string | VerifyPromptFn<A>;\n\n\t/**\n\t * Pluggable EXECUTE slot. When omitted, the harness uses a `promptNode`\n\t * driven by `adapter` + `executePrompt`. Replace to plug in a\n\t * `refineExecutor`, tool-using agent, or any reactive execution pipeline.\n\t */\n\texecutor?: HarnessExecutor<A>;\n\n\t/**\n\t * Pluggable VERIFY slot. When omitted, the harness uses a `promptNode`\n\t * driven by `adapter` + `verifyPrompt`. Replace to plug in an\n\t * `evalVerifier` that re-runs affected eval tasks.\n\t */\n\tverifier?: HarnessVerifier<A>;\n\n\t/** Per-queue configuration overrides. */\n\tqueues?: Partial<Record<QueueRoute, QueueConfig>>;\n\n\t/** Priority scoring signals. */\n\tpriority?: PrioritySignals;\n\n\t/**\n\t * Reactive last-human-interaction timestamp (monotonic ns). Drives the\n\t * priority score age-decay term for `HarnessGraph.priorityScores`.\n\t *\n\t * **Required when `opts.priority` is set.** Priority score nodes only\n\t * re-derive when `topic.latest`, `strategy.snapshot`, or this tick settles —\n\t * an idle queue would freeze its age at construction time if we\n\t * auto-defaulted. Typical sources:\n\t *  - `fromTimer(60_000)` — steady tick, uniform decay.\n\t *  - `state(monotonicNs())` — bumped from a human-interaction handler.\n\t *  - A reactive view over a DB column / external metrics source.\n\t */\n\tlastInteractionNs?: Node<number>;\n\n\t/** Error classifier for fast-retry path. */\n\terrorClassifier?: ErrorClassifier;\n\n\t/** Max fast-retries per item before routing to full intake (default 2). */\n\tmaxRetries?: number;\n\n\t/** Global retry cap across all items — circuit breaker (default maxRetries × 10). */\n\tmaxTotalRetries?: number;\n\n\t/** Max re-ingestions from verify→intake before giving up (default 1). */\n\tmaxReingestions?: number;\n\n\t/** Global reingestion cap across all items — circuit breaker (default maxReingestions × 10). */\n\tmaxTotalReingestions?: number;\n\n\t/** Retained limit for topic logs (default 1000). */\n\tretainedLimit?: number;\n\n\t/**\n\t * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's `execute`\n\t * stage (Tier 6.5 C2). Default `Number.MAX_SAFE_INTEGER` — every pending\n\t * claim is processed in one tick (matches today's unbounded `merge()`\n\t * parallelism). Lower this to bound LLM cost spikes on bursty intake.\n\t *\n\t * **Caveat.** This caps **claims per pump tick**, not total concurrent\n\t * inflight. Bounded-inflight is a separate primitive concern — see\n\t * `docs/optimizations.md` \"Tier 6.5 follow-up — bounded concurrent inflight\n\t * on JobFlow stages\".\n\t */\n\texecuteMaxPerPump?: number;\n\n\t/**\n\t * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's\n\t * `verify` stage. Default `Number.MAX_SAFE_INTEGER`. Same caveat as\n\t * {@link HarnessLoopOptions.executeMaxPerPump}. Honored independently\n\t * of the execute cap via `StageDef.maxPerPump` (Tier 6.5 D1).\n\t */\n\tverifyMaxPerPump?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Barrel re-exports from defaults.ts — preserves the pre-split import\n// surface (`import { QUEUE_NAMES, defaultErrorClassifier } from \".../types\"`).\n// ---------------------------------------------------------------------------\n\nexport {\n\tDEFAULT_DECAY_RATE,\n\tDEFAULT_QUEUE_CONFIGS,\n\tDEFAULT_SEVERITY_WEIGHTS,\n\tdefaultErrorClassifier,\n\tQUEUE_NAMES,\n\tstrategyKey,\n} from \"./defaults.js\";\n","/**\n * Strategy model and priority scoring (roadmap §9.0).\n *\n * `strategyModel` returns a typed alias of {@link AuditedSuccessTrackerGraph}\n * keyed by `StrategyKey` (the composite `rootCause→intervention` string).\n * The shared substrate (Class B audit Alt E collapse, 2026-04-30) replaces\n * the prior bespoke bundle shape; composite-key callers use {@link strategyKey}\n * to compute the key and pass `{ rootCause, intervention }` as record decoration.\n *\n * @module\n */\n\nimport { monotonicNs, type Node, node } from \"@graphrefly/pure-ts/core\";\nimport { decay } from \"../../base/utils/decay.js\";\nimport {\n\ttype AuditedSuccessTrackerGraph,\n\tauditedSuccessTracker,\n} from \"../orchestration/audited-success-tracker.js\";\n\nimport {\n\tDEFAULT_DECAY_RATE,\n\tDEFAULT_PRESET_ID,\n\tDEFAULT_SEVERITY_WEIGHTS,\n\ttype PrioritySignals,\n\ttype StrategyEntry,\n\ttype StrategyKey,\n\tstrategyKey,\n\ttype TriagedItem,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Strategy model\n// ---------------------------------------------------------------------------\n\n/** Snapshot shape for the strategy-model `entries` node. */\nexport type StrategySnapshot = ReadonlyMap<StrategyKey, StrategyEntry>;\n\n/** Strategy-model graph: a typed alias of {@link AuditedSuccessTrackerGraph}. */\nexport type StrategyModelGraph = AuditedSuccessTrackerGraph<StrategyKey, StrategyEntry>;\n\n/**\n * Create a strategy model that tracks\n * `presetId × rootCause × intervention → successRate` over completed\n * issues (presetId axis added in Phase 13.I, 2026-05-01). Returns an\n * {@link AuditedSuccessTrackerGraph} keyed by {@link StrategyKey}.\n *\n * The reactive `entries` field is a `Node<StrategySnapshot>` suitable for\n * `describe()` / `withLatestFrom` composition.\n *\n * Composite-key conversion happens at the call site:\n * ```ts\n * const strategy = strategyModel();\n * strategy.record(strategyKey(presetId, rootCause, intervention), success, {\n *   presetId,\n *   rootCause,\n *   intervention,\n * });\n * strategy.lookup(strategyKey(presetId, rootCause, intervention));\n * ```\n *\n * Pass {@link DEFAULT_PRESET_ID} (`\"default\"`) for the presetId axis when\n * no preset registry is wired (single-agent harness).\n *\n * The model feeds back into TRIAGE for routing hints.\n */\nexport function strategyModel(): StrategyModelGraph {\n\treturn auditedSuccessTracker<StrategyKey, StrategyEntry>({ name: \"strategy\" });\n}\n\n// ---------------------------------------------------------------------------\n// Priority scoring\n// ---------------------------------------------------------------------------\n\n/**\n * Create a priority scoring derived node for a single triaged item.\n *\n * Combines severity weight, attention decay, strategy model effectiveness,\n * and an optional external urgency signal.\n *\n * **Age sampling caveat.** The `ageSeconds` term is computed as\n * `monotonicNs() - lastInteractionNs.cache` at *each reactive update*. If\n * nothing upstream settles, the score node does not recompute — so a\n * long-idle queue may show a stale score. Pass a `fromTimer(...)`-driven\n * node as a dep (or re-emit on `lastInteractionNs`) when live age decay\n * matters.\n *\n * **Not the same as `TriagedItem.priority`.** The LLM-emitted\n * `priority: 0..100` field on each triaged item is decorative today — the\n * queue consumption order ignores it (tracked in `docs/optimizations.md`\n * as a priority-ordered queue enhancement). This function computes an\n * orthogonal reactive score; it does NOT override the LLM's per-item\n * priority, nor does it drive queue ordering. Wire it to\n * `HarnessGraph.priorityScores` to surface per-route pressure.\n *\n * @param item - Node holding the triaged item.\n * @param strategy - Strategy model node.\n * @param lastInteractionNs - Node holding the monotonic timestamp (ns) of last human interaction.\n * @param urgency - Optional external urgency signal node (0–1 scale).\n * @param signals - Configurable scoring parameters.\n */\nexport function priorityScore(\n\titem: Node<TriagedItem>,\n\tstrategy: Node<StrategySnapshot>,\n\tlastInteractionNs: Node<number>,\n\turgency?: Node<number>,\n\tsignals?: PrioritySignals,\n): Node<number> {\n\tconst severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };\n\tconst decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE;\n\tconst effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;\n\tconst effectivenessBoost = signals?.effectivenessBoost ?? 15;\n\n\tconst deps: Node<unknown>[] = [item, strategy, lastInteractionNs];\n\tif (urgency) deps.push(urgency);\n\n\treturn node<number>(\n\t\tdeps,\n\t\t(batchData, actions, ctx) => {\n\t\t\tconst values = batchData.map((batch, i) =>\n\t\t\t\tbatch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i],\n\t\t\t);\n\t\t\tconst itm = values[0] as TriagedItem;\n\t\t\tconst strat = values[1] as StrategySnapshot;\n\t\t\tconst lastNs = values[2] as number;\n\t\t\tconst urg = urgency ? (values[3] as number) : 0;\n\n\t\t\t// Base score from severity\n\t\t\tconst baseWeight = severityWeights[itm.severity ?? \"medium\"];\n\t\t\tconst ageSeconds = (monotonicNs() - lastNs) / 1e9;\n\t\t\tlet score = decay(baseWeight, ageSeconds, decayRate, 0);\n\n\t\t\t// Strategy model boost\n\t\t\tconst key = strategyKey(DEFAULT_PRESET_ID, itm.rootCause, itm.intervention);\n\t\t\tconst entry = strat.get(key);\n\t\t\tif (entry && entry.successRate >= effectivenessThreshold) {\n\t\t\t\tscore += effectivenessBoost;\n\t\t\t}\n\n\t\t\t// External urgency boost (0–1 scale → 0–20 points)\n\t\t\tscore += urg * 20;\n\n\t\t\tactions.emit(score);\n\t\t},\n\t\t{ name: \"priority-score\", describeKind: \"derived\" },\n\t);\n}\n","/**\n * `auditedSuccessTracker` — domain-agnostic per-key success-rate tracker.\n *\n * Reactive `key → { attempts, successes, successRate }` map mounted as a\n * Graph subclass. Reusable substrate for any domain that needs to track\n * outcomes per identifier (routing strategy effectiveness, A/B-test arms,\n * cache-policy tuning, retry-strategy selection, etc.).\n *\n * Replaces the prior `effectivenessTracker` and `strategyModel` factories\n * (Class B audit Alt E collapse, 2026-04-30). Composite-key callers (e.g.\n * `rootCause × intervention`) convert to a string key at the call site.\n *\n * @module\n */\n\nimport type { Node } from \"@graphrefly/pure-ts/core\";\nimport { keepalive, type ReactiveMapBundle, reactiveMap } from \"@graphrefly/pure-ts/extra\";\nimport { Graph, type GraphOptions } from \"@graphrefly/pure-ts/graph\";\n\n/** A single success-rate record for one key. */\nexport interface AuditedSuccessEntry<TKey extends string = string> {\n\treadonly key: TKey;\n\treadonly attempts: number;\n\treadonly successes: number;\n\treadonly successRate: number;\n}\n\n/** Snapshot shape — fresh `ReadonlyMap` on every mutation. */\nexport type AuditedSuccessSnapshot<\n\tTKey extends string = string,\n\tTEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,\n> = ReadonlyMap<TKey, TEntry>;\n\n/** Options for {@link auditedSuccessTracker}. */\nexport interface AuditedSuccessTrackerOptions {\n\t/** Optional graph identity (passed to the underlying Graph constructor). */\n\tgraph?: GraphOptions;\n\t/** Name of the tracker subgraph. Default `\"audited-success-tracker\"`. */\n\tname?: string;\n}\n\n/**\n * Reactive success-rate tracker mounted as a Graph subclass.\n *\n * `key → AuditedSuccessEntry` with `record(key, success, extra?)` /\n * `lookup(key)` methods. The {@link entries} field is a\n * `Node<ReadonlyMap<TKey, TEntry>>` suitable for graph composition —\n * exposed under name `\"entries\"` for `describe()` / `explain()`.\n *\n * Backed by the {@link reactiveMap} substrate; each successful `record(...)`\n * fires a DATA emission carrying the post-mutation map.\n *\n * **Field name.** This Graph subclass uses `entries` (not `snapshot`) for\n * the public-face Node because `Graph.prototype.snapshot()` is the\n * built-in persistence-snapshot method on the parent class — using\n * `snapshot` here would shadow it and break DTS generation.\n *\n * @typeParam TKey - String-typed key shape. Composite-key domains (e.g.\n *   `rootCause × intervention`) convert to a string at the call site.\n * @typeParam TEntry - Entry shape; defaults to {@link AuditedSuccessEntry}.\n *   Domains that need extra fields (e.g. `rootCause`/`intervention`) extend\n *   this interface and pass the extra fields via `record(...)`'s `extra` arg.\n */\nexport class AuditedSuccessTrackerGraph<\n\tTKey extends string = string,\n\tTEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,\n> extends Graph {\n\t/** Reactive entries — `Node<ReadonlyMap<TKey, TEntry>>`, fresh map per mutation. */\n\treadonly entries: Node<AuditedSuccessSnapshot<TKey, TEntry>>;\n\n\tprivate readonly _map: ReactiveMapBundle<TKey, TEntry>;\n\n\tconstructor(opts?: AuditedSuccessTrackerOptions) {\n\t\tsuper(opts?.name ?? \"audited-success-tracker\", opts?.graph);\n\t\tthis._map = reactiveMap<TKey, TEntry>({ name: \"entries\" });\n\t\tthis.entries = this._map.entries;\n\t\tthis.add(this.entries, { name: \"entries\" });\n\n\t\t// Keep the entries node activated without external subscribers so\n\t\t// `tracker.entries.cache` is readable from sync code paths and\n\t\t// `lookup()` callers don't have to manage subscriptions. Released on\n\t\t// Graph dispose along with the underlying reactiveMap.\n\t\tthis.addDisposer(keepalive(this.entries));\n\t\tthis.addDisposer(() => this._map.dispose());\n\t}\n\n\t/**\n\t * Record a completed attempt. `extra` fields are merged into the stored\n\t * entry — use for domain-specific decoration (e.g. `{ rootCause,\n\t * intervention }` on the strategy-model collapse path).\n\t *\n\t * **Caller contract for typed `TEntry`.** When `TEntry` extends\n\t * {@link AuditedSuccessEntry} with required fields beyond\n\t * `key`/`attempts`/`successes`/`successRate`, the caller must supply\n\t * those required fields in `extra` on the **first** `record(key, ...)`\n\t * for that key. The internal `as TEntry` cast trusts this. Subsequent\n\t * `record(key, ...)` calls inherit the prior entry's fields, so `extra`\n\t * may be omitted or partial. Forgetting required fields on the first\n\t * record produces an entry whose typed-required fields are `undefined`\n\t * at runtime — TS won't catch it. Strategy callers always pass\n\t * `{ rootCause, intervention }`, so the StrategyEntry case is safe.\n\t */\n\trecord(\n\t\tkey: TKey,\n\t\tsuccess: boolean,\n\t\textra?: Partial<Omit<TEntry, \"key\" | \"attempts\" | \"successes\" | \"successRate\">>,\n\t): void {\n\t\tconst existing = this._map.get(key);\n\t\tconst attempts = (existing?.attempts ?? 0) + 1;\n\t\tconst successes = (existing?.successes ?? 0) + (success ? 1 : 0);\n\t\tthis._map.set(key, {\n\t\t\t...(existing ?? {}),\n\t\t\t...(extra ?? {}),\n\t\t\tkey,\n\t\t\tattempts,\n\t\t\tsuccesses,\n\t\t\tsuccessRate: successes / attempts,\n\t\t} as TEntry);\n\t}\n\n\t/**\n\t * Look up the entry for a key.\n\t *\n\t * Pure read: this tracker doesn't configure a TTL on the underlying\n\t * `reactiveMap`, so `_map.get(key)` never triggers TTL-expiry pruning\n\t * (which would otherwise be an observable side effect emitting a fresh\n\t * `entries` snapshot). If `AuditedSuccessTrackerOptions` ever gains a\n\t * `mapOptions` carve-out exposing TTL, revisit this contract.\n\t */\n\tlookup(key: TKey): TEntry | undefined {\n\t\treturn this._map.get(key);\n\t}\n}\n\n/**\n * Construct an {@link AuditedSuccessTrackerGraph}. Replaces the prior\n * `effectivenessTracker()` and `strategyModel()` factories.\n *\n * @example\n * ```ts\n * // Generic per-action tracker\n * const tracker = auditedSuccessTracker({ name: \"ab-test\" });\n * tracker.record(\"variant-a\", true);\n * tracker.record(\"variant-b\", false);\n * tracker.entries.subscribe(snap => console.log(snap.get(\"variant-a\")));\n *\n * // Composite-key (rootCause × intervention) tracker — caller computes the key\n * type StrategyEntry = AuditedSuccessEntry<StrategyKey> & {\n *   rootCause: RootCause;\n *   intervention: Intervention;\n * };\n * const strategy = auditedSuccessTracker<StrategyKey, StrategyEntry>({\n *   name: \"strategy\",\n * });\n * strategy.record(\n *   strategyKey(rootCause, intervention),\n *   true,\n *   { rootCause, intervention },\n * );\n * ```\n *\n * @category extra\n */\nexport function auditedSuccessTracker<\n\tTKey extends string = string,\n\tTEntry extends AuditedSuccessEntry<TKey> = AuditedSuccessEntry<TKey>,\n>(opts?: AuditedSuccessTrackerOptions): AuditedSuccessTrackerGraph<TKey, TEntry> {\n\treturn new AuditedSuccessTrackerGraph<TKey, TEntry>(opts);\n}\n"],"mappings":"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","names":[]}