@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/skill-usage-C_pXm7lP.d.ts

@@ -0,0 +1,534 @@
+import { o as Severity } from "./multi-layer-verifier-BHY1gWAc.js";
+import { C as TraceEvent, _ as Span, f as Run, n as BudgetLedgerEntry, t as Artifact } from "./schema-BtVldJ3T.js";
+import "./index-BvnJuTGD.js";
+import { s as TraceStore } from "./store-CT9YIIve.js";
+import { c as CostLedgerHandle } from "./cost-ledger-Dye6jCgg.js";
+import { o as LlmClientOptions } from "./llm-client-B_nIBlYo.js";
+import { f as TraceAnalystSpan } from "./store-CxJry_cs.js";
+import { C as AnalystContext, S as Analyst, T as AnalystFinding, u as TraceAnalystKindSpec } from "./default-registry-CNPo-Vsb.js";
+import { AxAIArgs, AxAIService } from "@ax-llm/ax";
+import { z } from "zod";
+//#region src/run-score.d.ts
+interface RunScore {
+  success: number;
+  goalProgress: number;
+  repoGroundedness: number;
+  driftPenalty: number;
+  toolUseQuality: number;
+  patchQuality: number;
+  testReality: number;
+  finalGate: number;
+  reviewerBlockers: number;
+  costUsd: number;
+  wallSeconds: number;
+  notes?: string[];
+}
+interface RunScoreWeights {
+  success: number;
+  goalProgress: number;
+  repoGroundedness: number;
+  driftPenalty: number;
+  toolUseQuality: number;
+  patchQuality: number;
+  testReality: number;
+  finalGate: number;
+  reviewerBlockers: number;
+  costUsd: number;
+  wallSeconds: number;
+}
+declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
+declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
+declare function clamp01(value: number): number;
+//#endregion
+//#region src/run-critic.d.ts
+interface RunTrace {
+  run: Run;
+  spans: Span[];
+  events: TraceEvent[];
+  artifacts: Artifact[];
+  budget: BudgetLedgerEntry[];
+}
+interface RunCriticOptions {
+  weights?: Partial<RunScoreWeights>;
+  driftPatterns?: RegExp[];
+}
+declare class RunCritic {
+  private readonly weights?;
+  private readonly driftPatterns;
+  constructor(options?: RunCriticOptions);
+  score(store: TraceStore, runId: string): Promise<RunScore>;
+  scoreTrace(trace: RunTrace): RunScore;
+  rank(score: RunScore): number;
+  private isDrift;
+}
+//#endregion
+//#region src/semantic-concept-judge.d.ts
+/**
+ * Implementation complexity class for weighted scoring.
+ *
+ * - `render` (default): the concept is a UI surface that displays static
+ *   data — render a list, show a counter, lay out a button. Single-file
+ *   work, no external integration.
+ * - `integrate`: the concept requires wiring a real external system —
+ *   wallet connect (wagmi + RainbowKit + chain config), payment provider
+ *   (Stripe Elements + intent + webhook), an API client with auth.
+ *   Multi-file, library-knowledge, runtime correctness matters.
+ * - `compute`: the concept requires algorithmic work — solver, simulator,
+ *   constraint propagation, ML inference. Correctness > UI polish.
+ *
+ * Default weights (when applied via `weightConcepts: 'complexity'`):
+ *   render=1.0, integrate=2.0, compute=2.5
+ *
+ * Cross-vertical scoring without complexity weighting silently inflates
+ * the rate of UI-heavy verticals (healthcare, fintech dashboards) vs
+ * integration-heavy verticals (DeFi, wallets) — all concepts treated
+ * equally even though the agent does 2-3x the work for `integrate`.
+ */
+type ConceptComplexity = 'render' | 'integrate' | 'compute';
+interface ConceptSpec {
+  name: string;
+  /** Short hints that help the judge; not used for matching. */
+  keywords?: string[];
+  /** Optional explicit weight; default 1.0. Overrides complexity-derived weight. */
+  weight?: number;
+  /** Implementation complexity class. Default `render`. */
+  complexity?: ConceptComplexity;
+}
+interface ConceptFinding {
+  concept: string;
+  present: boolean;
+  /** 0..10. 10 = production-ready; 7 = functional thin; 4 = partial; 0 = absent. */
+  score: number;
+  evidence: string;
+  severity: Severity;
+}
+interface SemanticConceptJudgeInput {
+  /** Full natural-language prompt the agent was handed. */
+  userRequest: string;
+  /** Rendered HTML the preview returns (UI artifacts). Optional. */
+  servedHtml?: string;
+  /** Top-level source files from the agent's workdir. */
+  sourceFiles: Array<{
+    path: string;
+    content: string;
+  }>;
+  /** The expected concept list. */
+  expectedConcepts: ConceptSpec[];
+  /** Free-form metadata (id, difficulty) to inject into the prompt. */
+  artifactLabel?: string;
+  artifactDescription?: string;
+}
+interface SemanticConceptJudgeResult {
+  kind: 'semantic-concept';
+  version: string;
+  /** Normalized 0..1 score — mean of per-concept scores / 10. */
+  score: number;
+  presentCount: number;
+  totalCount: number;
+  findings: ConceptFinding[];
+  summary: string;
+  durationMs: number;
+  costUsd: number | null;
+  /** False on LLM/JSON error — treat as "skipped / unable to judge" in pipelines. */
+  available: boolean;
+  error?: string;
+}
+/**
+ * Score-aggregation strategy. `mean` averages 0-10 scores uniformly.
+ * `complexity` applies the default weight table (render=1, integrate=2,
+ * compute=2.5) unless a concept has an explicit `weight`. `explicit`
+ * honors only `weight` (defaulting to 1 for unspecified).
+ */
+type ConceptWeightStrategy = 'mean' | 'complexity' | 'explicit';
+declare const DEFAULT_COMPLEXITY_WEIGHTS: Record<ConceptComplexity, number>;
+interface SemanticConceptJudgeOptions {
+  /** Model id to call. Default 'claude-sonnet-4-6' via agent-eval defaults. */
+  model?: string;
+  /** Per-call timeout. Default 300s. */
+  timeoutMs?: number;
+  /** Provider-enforced output limit. Default 16000. */
+  maxTokens?: number;
+  /** Pipeline budget for the prompt (source blob truncation). Default 45000. */
+  maxSourceChars?: number;
+  /** Per-file cap before inclusion. Default 20000. */
+  maxPerFileChars?: number;
+  /** HTML cap. Default 30000. */
+  maxHtmlChars?: number;
+  /** LlmClient config (baseUrl, apiKey, authHeader, …). */
+  llm?: LlmClientOptions;
+  costLedger?: CostLedgerHandle;
+  costPhase?: string;
+  costTags?: Record<string, string>;
+  signal?: AbortSignal;
+  /**
+   * Score aggregation strategy. Default `mean` — uniform average across
+   * concepts. Cross-vertical comparisons should use `complexity` to
+   * neutralize the integrate-vs-render asymmetry.
+   */
+  weightConcepts?: ConceptWeightStrategy;
+  /** Override the default complexity → weight table. */
+  complexityWeights?: Partial<Record<ConceptComplexity, number>>;
+}
+declare const SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
+/**
+ * Run the semantic concept judge. Soft-fails to available=false on
+ * LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat
+ * that as "skip" rather than "fail."
+ */
+declare function runSemanticConceptJudge(input: SemanticConceptJudgeInput, options?: SemanticConceptJudgeOptions): Promise<SemanticConceptJudgeResult>;
+/**
+ * Factory: pin LLM options once, return a closure that accepts inputs.
+ * Convenient for pipelines that want to share a single LlmClient config.
+ */
+declare function createSemanticConceptJudge(options?: SemanticConceptJudgeOptions): (input: SemanticConceptJudgeInput) => Promise<SemanticConceptJudgeResult>;
+//#endregion
+//#region src/analyst/ax-service.d.ts
+interface CreateAnalystAiConfig {
+  /** OpenAI-compatible API key forwarded as `Authorization: Bearer`.
+   *  cli-bridge ignores the value on loopback but Ax requires a non-empty string. */
+  apiKey: string;
+  /** OpenAI-compatible base URL — e.g. `https://router.tangle.tools/v1` or a
+   *  cli-bridge loopback. */
+  baseUrl?: string;
+  /** Additional headers required by the gateway, such as tenant or execution policy. */
+  headers?: Record<string, string>;
+  /** Model id forwarded to analyst calls. */
+  model: string;
+  /** Ax provider name. Defaults to the OpenAI-compatible client. */
+  provider?: AxAIArgs<unknown>['name'];
+}
+/**
+ * Construct the `AxAIService` an analyst kind calls through
+ * (`createTraceAnalystKind({ ai })`).
+ *
+ * Ax's `ai()` pins `config.model` to the OpenAI catalog enum, but every
+ * OpenAI-compatible router an analyst points at (router.tangle.tools,
+ * cli-bridge) accepts arbitrary model ids (claude-code/sonnet, openai/gpt-5.4,
+ * …). Consumers were each re-rolling `ai({ name, apiKey, apiURL, config })`
+ * behind an `as (a: any) => any` cast to dodge the enum; this is the one
+ * canonical constructor so they don't have to — and don't take a direct
+ * `@ax-llm/ax` dependency for it.
+ */
+declare function createAnalystAi(config: CreateAnalystAiConfig): AxAIService;
+//#endregion
+//#region src/trace-analyst/behavioral-metrics.d.ts
+type SuboptimalCode = 'monotonic-input-growth' | 'output-length-decay' | 'single-tool-dependency' | 'no-self-verification';
+interface SuboptimalSignal {
+  code: SuboptimalCode;
+  severity: 'high' | 'medium' | 'low';
+  /** Human-readable claim, with the backing numbers inlined. */
+  detail: string;
+  /** The exact figures the detector fired on — auditable, no model in the loop. */
+  evidence: Record<string, number | string | boolean>;
+}
+interface BehavioralMetrics {
+  /** The only trace represented by these metrics; null when spans are empty. */
+  traceId: string | null;
+  llmCallCount: number;
+  /** Causally serial LLM timelines. Parallel branches are never joined. */
+  tokenSequences: BehavioralTokenSequence[];
+  /** Token values from the longest serial timeline, retained for convenience. */
+  inputTokenTrajectory: number[];
+  outputTokenTrajectory: number[];
+  toolHistogram: Record<string, number>;
+  totalToolCalls: number;
+  distinctTools: number;
+  /** distinct/total tool calls; 1.0 when there are no tool calls. */
+  toolDiversityRatio: number;
+  hasSelfVerification: boolean;
+  signals: SuboptimalSignal[];
+}
+interface BehavioralTokenSequence {
+  scopeId: string;
+  spanIds: string[];
+  inputTokenTrajectory: Array<number | null>;
+  outputTokenTrajectory: Array<number | null>;
+}
+/**
+ * Reduce a span list to behavioral metrics + fired suboptimality signals.
+ * Pure + deterministic: same spans → same output, on any machine, no model.
+ */
+declare function computeTraceMetrics(spans: readonly TraceAnalystSpan[]): BehavioralMetrics;
+//#endregion
+//#region src/analyst/finding-subject.d.ts
+/**
+ * Discriminated union of every locus the substrate can route findings to.
+ *
+ * Adapters narrow on `kind` and use the typed components (no string
+ * parsing). Adding a variant here REQUIRES updating the parser, the
+ * grammar prompt, and at least one adapter — by design.
+ */
+type FindingSubject = {
+  kind: 'knowledge.wiki';
+  slug: string;
+  heading?: string;
+} | {
+  kind: 'knowledge.claim';
+  topic: string;
+} | {
+  kind: 'knowledge.raw';
+  sourceId: string;
+} | {
+  kind: 'knowledge.stale';
+  slug: string;
+} | {
+  kind: 'system-prompt';
+  section: string;
+} | {
+  kind: 'skill';
+  name: string;
+} | {
+  kind: 'tool-doc';
+  tool: string;
+  aspect?: string;
+} | {
+  kind: 'new-tool';
+  name: string;
+} | {
+  kind: 'mcp';
+  server: string;
+  tool?: string;
+} | {
+  kind: 'hook';
+  name: string;
+} | {
+  kind: 'subagent';
+  name: string;
+} | {
+  kind: 'workflow';
+  name: string;
+} | {
+  kind: 'rollout-policy';
+  field: string;
+} | {
+  kind: 'agent-profile';
+  field: string;
+} | {
+  kind: 'code';
+  path: string;
+} | {
+  kind: 'rag';
+  corpus: string;
+  docId: string;
+} | {
+  kind: 'memory';
+  key: string;
+} | {
+  kind: 'scaffolding';
+  concern: string;
+} | {
+  kind: 'output-schema';
+  field: string;
+} | {
+  kind: 'websearch.outdated';
+  topic: string;
+} | {
+  kind: 'prior-run-summary';
+  topic: string;
+} | {
+  kind: 'cluster';
+  label: string;
+};
+type FindingSubjectKind = FindingSubject['kind'];
+declare const FINDING_SUBJECT_KINDS: ReadonlyArray<FindingSubjectKind>;
+/**
+ * Parse a raw subject string emitted by an analyst kind's actor.
+ *
+ * Returns the typed `FindingSubject` when `raw` matches the grammar,
+ * else `null`. Callers use the `null` return as a signal to either
+ * (a) reject the finding at parse time (kinds that emit typed loci —
+ * knowledge-gap, improvement, knowledge-poisoning) or (b) lift it as
+ * a cluster label (failure-mode).
+ *
+ * Slugs are constrained to `[a-z0-9-]+` (lowercase kebab) to keep file
+ * paths sane downstream. Topics / keys / sections allow any non-empty
+ * string (free-form for the LLM's voice) but get trimmed.
+ *
+ * Empty / whitespace-only inputs return `null`. `undefined` returns
+ * `null`. Both are surfaced by the caller as a rejected subject.
+ */
+declare function parseFindingSubject(raw: string | null | undefined): FindingSubject | null;
+/**
+ * Render the parsed subject back to its canonical string form. Inverse
+ * of `parseFindingSubject`; useful when the substrate constructs new
+ * findings programmatically (e.g. for tests, replays, or
+ * `id_basis` carry-forward).
+ */
+declare function renderFindingSubject(s: FindingSubject): string;
+/**
+ * The grammar text embedded into kind actor prompts. Kinds opt into
+ * the subset of variants they emit (e.g. `improvement` excludes the
+ * cluster variant; `failure-mode` includes ONLY the cluster variant).
+ *
+ * Drift between prompt and parser is impossible: every kind imports
+ * this constant + the matching `expects` set, and the unit tests below
+ * lock the table to the parser.
+ */
+declare const FINDING_SUBJECT_SYNTAX: Readonly<Record<FindingSubjectKind, string>>;
+declare const FINDING_SUBJECT_GRAMMAR_PROMPT: string;
+/**
+ * The variants each kind is allowed to emit. Used at the kind factory
+ * boundary so a knowledge-gap finding can't sneak in a `system-prompt:*`
+ * subject (the improvement-analyst's job) and vice versa.
+ *
+ * `failure-mode` is restricted to `cluster` — the only kind that emits
+ * a non-locus subject.
+ */
+declare const KIND_EXPECTED_SUBJECTS: Record<string, ReadonlyArray<FindingSubjectKind>>;
+/** Render only the subject forms one analyst kind is permitted to emit. */
+declare function findingSubjectGrammarPromptFor(kindId: string): string;
+/**
+ * Zod schema that validates a raw subject string and returns the parsed
+ * `FindingSubject`. Embedded in `RawAnalystFindingSchema` via
+ * `transform`, so `subject` arrives at the kind factory either as a
+ * typed locus or as a parse error attached to a single Zod issue.
+ *
+ * Optionality is preserved: subjects ARE optional on the wire (some
+ * findings are descriptive, not actionable). When present, they MUST
+ * parse — emitting a malformed subject is a contract violation, not a
+ * soft signal.
+ */
+declare const FindingSubjectStringSchema: z.ZodString;
+//#endregion
+//#region src/analyst/findings-store.d.ts
+/**
+ * One persisted row. We attach `run_id` on disk so a single file can
+ * hold multiple runs and the diff helper can query without re-walking
+ * separate files.
+ */
+interface PersistedFinding extends AnalystFinding {
+  run_id: string;
+}
+declare class FindingsStore {
+  readonly path: string;
+  private readonly appender;
+  constructor(path: string);
+  append(runId: string, findings: AnalystFinding[]): Promise<void>;
+  /** Load every persisted finding. Discards malformed trailing lines silently. */
+  loadAll(): PersistedFinding[];
+  /** Filter to a single run. */
+  loadRun(runId: string): PersistedFinding[];
+}
+interface FindingsDiff {
+  /** New finding ids in `current` that weren't in `previous`. */
+  appeared: PersistedFinding[];
+  /** Finding ids in `previous` that aren't in `current`. */
+  disappeared: PersistedFinding[];
+  /** Same finding id present in both runs and unchanged per the materiality test. */
+  persisted: PersistedFinding[];
+  /**
+   * Same finding id in both runs but at least one non-identity field
+   * shifted per `DiffPolicy.isMaterial`. Reported as [previous, current].
+   */
+  changed: Array<{
+    previous: PersistedFinding;
+    current: PersistedFinding;
+  }>;
+}
+interface DiffPolicy {
+  /**
+   * Predicate that decides whether two findings (same finding_id) count
+   * as a material change. Defaults to {@link defaultIsMaterial}: severity
+   * shift, confidence Δ > 0.05, or evidence count change. Compliance /
+   * perf consumers MAY supply a stricter predicate (e.g. rationale text
+   * diff, metric Δ thresholds).
+   */
+  isMaterial?: (previous: AnalystFinding, current: AnalystFinding) => boolean;
+}
+/**
+ * Default materiality test. Deliberately narrow so LLM-reword churn
+ * doesn't flood the diff. Stricter tests are opt-in via DiffPolicy.
+ */
+declare function defaultIsMaterial(a: AnalystFinding, b: AnalystFinding): boolean;
+/**
+ * Diff two findings sets by stable finding_id. Callers typically load
+ * the two run-id slices from the same store and pass them in.
+ */
+declare function diffFindings(previous: PersistedFinding[], current: PersistedFinding[], policy?: DiffPolicy): FindingsDiff;
+//#endregion
+//#region src/analyst/kinds/failure-mode.d.ts
+declare const FAILURE_MODE_KIND_SPEC: TraceAnalystKindSpec;
+//#endregion
+//#region src/analyst/kinds/improvement.d.ts
+declare const IMPROVEMENT_KIND_SPEC: TraceAnalystKindSpec;
+//#endregion
+//#region src/analyst/kinds/knowledge-gap.d.ts
+declare const KNOWLEDGE_GAP_KIND_SPEC: TraceAnalystKindSpec;
+//#endregion
+//#region src/analyst/kinds/knowledge-poisoning.d.ts
+declare const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystKindSpec;
+//#endregion
+//#region src/analyst/kinds/index.d.ts
+/**
+ * The default kind suite. Order is the run order operators should
+ * use: failure-mode first (no upstream deps), gap + poisoning next
+ * (both depend on failures), improvement last (chains all three).
+ */
+declare const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystKindSpec[];
+//#endregion
+//#region src/analyst/kinds/skill-usage.d.ts
+type SkillKind = 'public' | 'private';
+/** One skill's multi-signal usage + structure. All counts are deterministic. */
+interface SkillUsageRecord {
+  name: string;
+  kind: SkillKind;
+  /** Absolute path to the skill's SKILL.md. */
+  path: string;
+  lines: number;
+  /** `"skill":"<name>"` Skill-tool invocations across the trace corpus. */
+  directInvocations: number;
+  /** `<command-name>/<name>` slash invocations across the trace corpus. */
+  slashInvocations: number;
+  /** Sibling skills whose SKILL.md dispatches to this one (`/<name>`). Proxy
+   *  for orchestrated sub-dispatch the per-skill counter cannot see. */
+  inboundRefs: number;
+  /** On-disk artifacts attributable to the skill (e.g. `.evolve/<name>/**`). */
+  artifactCount: number;
+  /** Tangle-private reference count in the body (leak signal for public skills). */
+  tanglePrivateRefs: number;
+  hasReferencesDir: boolean;
+  hasEvalsDir: boolean;
+  /** Body mentions `skill-runs.jsonl` (visible to /reflect + /governor). */
+  logsRuns: boolean;
+  /** Description carries an explicit `Triggers:` clause / trigger phrases. */
+  hasTriggerPhrases: boolean;
+}
+interface SkillUsageReport {
+  generatedFromTraces: number;
+  records: SkillUsageRecord[];
+}
+interface SkillUsageScanConfig {
+  /** Dirs holding `*.jsonl` transcripts (Claude `~/.claude/projects`, Codex sessions). */
+  transcriptDirs: string[];
+  /** Skill roots to scan; each dir directly under `root` with a `SKILL.md` is a skill. */
+  skillRoots: {
+    root: string;
+    kind: SkillKind;
+  }[];
+  /** Roots scanned for `<root>/.evolve/<skill>` artifact dirs. */
+  artifactRoots?: string[];
+  /** Token-prefixed mappings: skill name → extra artifact subpaths under an artifactRoot
+   *  (e.g. reflect → `.evolve/reflections`). Catches non-eponymous artifact dirs. */
+  artifactAliases?: Record<string, string[]>;
+  /** Cap files read per transcript dir (bounds a huge corpus); 0 = unbounded. */
+  maxTranscriptsPerDir?: number;
+}
+/** Scan the corpus + skill roots into a {@link SkillUsageReport}. Deterministic. */
+declare function buildSkillUsageReport(config: SkillUsageScanConfig): SkillUsageReport;
+/** Pure rule pass over a report → findings. Exported for direct/unit use. */
+declare function emitSkillUsageFindings(report: SkillUsageReport, producedAt: string): AnalystFinding[];
+declare class SkillUsageAnalyst implements Analyst<SkillUsageReport> {
+  readonly id = "skill-usage";
+  readonly description = "Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.";
+  readonly inputKind: 'custom';
+  readonly cost: {
+    kind: 'deterministic';
+    est_usd_per_run: number;
+  };
+  readonly version = "1.0.0";
+  analyze(input: SkillUsageReport, ctx: AnalystContext): Promise<AnalystFinding[]>;
+}
+declare const SKILL_USAGE_ANALYST: SkillUsageAnalyst;
+//#endregion
+export { aggregateRunScore as $, BehavioralTokenSequence as A, DEFAULT_COMPLEXITY_WEIGHTS as B, FindingSubjectKind as C, parseFindingSubject as D, findingSubjectGrammarPromptFor as E, createAnalystAi as F, createSemanticConceptJudge as G, SemanticConceptJudgeInput as H, ConceptComplexity as I, RunCriticOptions as J, runSemanticConceptJudge as K, ConceptFinding as L, SuboptimalSignal as M, computeTraceMetrics as N, renderFindingSubject as O, CreateAnalystAiConfig as P, RunScoreWeights as Q, ConceptSpec as R, FindingSubject as S, KIND_EXPECTED_SUBJECTS as T, SemanticConceptJudgeOptions as U, SEMANTIC_CONCEPT_JUDGE_VERSION as V, SemanticConceptJudgeResult as W, DEFAULT_RUN_SCORE_WEIGHTS as X, RunTrace as Y, RunScore as Z, defaultIsMaterial as _, SkillUsageScanConfig as a, FINDING_SUBJECT_KINDS as b, DEFAULT_TRACE_ANALYST_KINDS as c, IMPROVEMENT_KIND_SPEC as d, clamp01 as et, FAILURE_MODE_KIND_SPEC as f, PersistedFinding as g, FindingsStore as h, SkillUsageReport as i, SuboptimalCode as j, BehavioralMetrics as k, KNOWLEDGE_POISONING_KIND_SPEC as l, FindingsDiff as m, SkillUsageAnalyst as n, buildSkillUsageReport as o, DiffPolicy as p, RunCritic as q, SkillUsageRecord as r, emitSkillUsageFindings as s, SKILL_USAGE_ANALYST as t, KNOWLEDGE_GAP_KIND_SPEC as u, diffFindings as v, FindingSubjectStringSchema as w, FINDING_SUBJECT_SYNTAX as x, FINDING_SUBJECT_GRAMMAR_PROMPT as y, ConceptWeightStrategy as z };
+//# sourceMappingURL=skill-usage-C_pXm7lP.d.ts.map

package/dist/skill-usage-C_pXm7lP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-usage-C_pXm7lP.d.ts","names":[],"sources":["../src/run-score.ts","../src/run-critic.ts","../src/semantic-concept-judge.ts","../src/analyst/ax-service.ts","../src/trace-analyst/behavioral-metrics.ts","../src/analyst/finding-subject.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts","../src/analyst/kinds/skill-usage.ts"],"mappings":"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"}