@lmzhen/dsh-evolution-core 0.3.81 → 0.3.82

package/lib/types/drift-signals.d.ts

@@ -29,7 +29,7 @@ export interface DriftSkillSnapshot {
     catalogInvalid?: boolean | undefined;
 }
 /** verdict=over means "relatively positioned above the threshold", never a violation. */
-export type DriftVerdict = 'pass' | 'over' | 'unknown';
+type DriftVerdict = 'pass' | 'over' | 'unknown';
 export interface DriftSignal {
     id: string;
     verdict: DriftVerdict;
@@ -40,7 +40,7 @@ export interface DriftSignal {
     /** Extra evidence (matched shapes, line numbers, group members). */
     detail?: string | undefined;
 }
-export interface DriftSkillAssessment {
+interface DriftSkillAssessment {
     name: string;
     signals: ReadonlyArray<DriftSignal>;
     /** Passthrough from the snapshot (0.3.11): protection marker, catalog loadability. */
@@ -80,4 +80,5 @@ export declare function narrowNameMatches(name: string): string[];
 export declare function computeDriftSignals(snapshots: ReadonlyArray<DriftSkillSnapshot>): DriftReport;
 /** Convenience: fetch one signal from an assessment or library list. */
 export declare function findDriftSignal(signals: ReadonlyArray<DriftSignal>, id: string): DriftSignal | undefined;
+export {};
 //# sourceMappingURL=drift-signals.d.ts.map

package/lib/types/events.d.ts

@@ -73,7 +73,7 @@ export interface EvolutionSkillMutatedEvent {
 /** 0.3.18 (E-6): a turn-end review pipeline failure was caught (never an
  * unhandled rejection); this event lets operators/observability see it. The
  * reason is already logged by the emitter — the event is a timestamped signal. */
-export interface EvolutionReviewErrorEvent {
+interface EvolutionReviewErrorEvent {
     sessionId: string;
 }
 declare module '@deepseek-ai/cordis' {
@@ -89,4 +89,5 @@ declare module '@deepseek-ai/cordis' {
         'evolution/review-error'(event: EvolutionReviewErrorEvent): void;
     }
 }
+export {};
 //# sourceMappingURL=events.d.ts.map

package/lib/types/evolution-events.d.ts

@@ -75,7 +75,7 @@ export interface EvolutionEvent {
 /** The durable-write shape of one event: `feedback` REQUIRES a `target` —
  * the fold key the aggregate is keyed by (P2-10). The other tags keep every
  * field optional, exactly as the runtime payload gate treats them. */
-export type EvolutionEventInput = (Omit<EvolutionEvent, 'seq' | 'at' | 'target'> & {
+type EvolutionEventInput = (Omit<EvolutionEvent, 'seq' | 'at' | 'target'> & {
     type: 'feedback';
     target: string;
 }) | (Omit<EvolutionEvent, 'seq' | 'at'> & {
@@ -128,28 +128,37 @@ export declare function appendEvolutionEvent(io: EvolutionIoLike, path: string,
  * Best-effort per removal; exported for the retention test.
  */
 export declare function retainEventArchives(io: EvolutionIoLike, path: string): Promise<void>;
-export interface EventLogRead {
+interface EventLogRead {
     events: EvolutionEvent[];
-    /** True when the body is not valid JSON (syntax-level damage): refused on
-     * append, bytes untouched. Well-formed JSON with a damaged `events` field
-     * is REPLACEABLE garbage — reads as empty and is rewritten at the next
-     * append (rc.70 F-1: read and append agree on the same boundary). A READ
-     * error (EISDIR etc.) also flags malformed — the file is unusable either
-     * way and is never overwritten (the append read would fail identically). */
+    /** True when THIS read DROPPED events the file may hold, so the result must
+     * never be treated as the complete truth for that file. Three causes flag it:
+     * syntax-level damage and a READ error (EISDIR/EACCES) — both refused on
+     * append with their bytes untouched — and, since C-events-dispatch-1 (v43
+     * audit), a body whose `version` this reader cannot interpret: F-338 keeps
+     * such a body un-reshaped and never rewritten down, but its records ARE
+     * missing from the read. A well-formed body with a damaged `events` field
+     * stays UNflagged — REPLACEABLE garbage that reads as empty and is rewritten
+     * at the next append (rc.70 F-1: read and append agree on the same boundary). */
     malformed: boolean;
 }
-/** Read the event log; a missing/whitespace-only file reads as empty,
- * corrupt content is flagged (and refused on append). A well-formed future-
- * version body is v1-incompatible and reads as empty, NOT malformed (F-338:
- * the reader must never mis-shape a newer format; the append path refuses it
- * up front so the original bytes survive). */
+/** Read the event log; a missing/whitespace-only file reads as empty, corrupt
+ * content is flagged (and refused on append). A well-formed future-version body
+ * is v1-incompatible: it reads as EMPTY and is now flagged malformed as well
+ * (C-events-dispatch-1, v43). F-338's own guarantees are untouched — the reader
+ * never mis-shapes a newer format and the append path refuses it up front, so
+ * the original bytes survive — while the flag reports what the old reader hid:
+ * every record that body holds is dropped from this read. */
 export declare function readEvolutionEvents(io: EvolutionIoLike, path: string): Promise<EventLogRead>;
 /**
  * Read the full timeline (rc.71): active log + all archives, merged by seq
  * (active copy wins, duplicates only arise from the rotation crash window),
  * sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
- * malformed (or unreadable) ARCHIVE is skipped — it never bricks the boot and
- * it is still flagged.
+ * flagged ARCHIVE (unreadable, damaged, or a future-version body this reader
+ * cannot interpret) is SKIPPED — it never bricks the boot, the returned events
+ * simply LACK that seq band, and `malformed` is the only signal that they do
+ * (C-events-dispatch-1, v43: the flag is the consumer's contract; a truncated
+ * timeline must never be folded back as if it were complete).
  */
 export declare function readEvolutionTimeline(io: EvolutionIoLike, path: string, archives?: readonly string[]): Promise<EventLogRead>;
+export {};
 //# sourceMappingURL=evolution-events.d.ts.map

package/lib/types/frontmatter.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Frontmatter parsing, normalization and validation for skill Markdown files.
+ *
+ * Split out of skill-store.ts (S2-1): pure functions over file text, no store
+ * state. skill-store.ts re-exports the same names it exported before the split,
+ * so the package export surface is unchanged.
+ */
+import type { SkillLimits } from './limits.ts';
+export interface Frontmatter {
+    name?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export declare function frontmatterBlock(content: string): {
+    block: string;
+    lines: string[];
+    end: number;
+    nl: string;
+} | null;
+/**
+ * One frontmatter read (V27 G2.1): the values, the body, and every signal the
+ * strict-YAML platform catalog derives from the same block. Returned by
+ * {@link parseFrontmatter} so a caller never has to parse the block twice to
+ * reach a description and the catalog verdict.
+ */
+export interface FrontmatterRead {
+    frontmatter: Frontmatter;
+    body: string;
+    /** Raw entries whose UNQUOTED value the strict catalog cannot load as
+     * written. Quotes are included, so a value already normalized by the write
+     * path (`normalizeFrontmatter`) is never re-flagged. */
+    unsafeValues: Array<{
+        key: string;
+        value: string;
+    }>;
+    /** Whether the frontmatter is not valid AS WRITTEN for the strict platform
+     * catalog: the strict parser rejects the block, or an unquoted value would
+     * read as something other than its text (a dropped ` # ` comment, a
+     * number/bool shorthand the catalog refuses as a string field), or a
+     * platform string field carries a non-string value. The write path quotes
+     * such a value on its next edit. */
+    catalogInvalid: boolean;
+    /** Platform string fields (`name`/`description`/`whenToUse`) whose YAML value
+     * is not a string: the strict catalog reads such a field as ABSENT and, for an
+     * absent name/description, ignores the whole file (P2-9/v37). */
+    platformStringSplit: PlatformStringSplit[];
+}
+/** One `name`/`description`/`whenToUse` entry the strict catalog cannot read as
+ * a string, with the YAML kind the parser found. */
+export interface PlatformStringSplit {
+    key: string;
+    /** The YAML type read for this field. `scalar` covers number/boolean (the
+     * E-47 auto-quote repair handles those); `sequence`/`mapping` are the shapes
+     * no rewrite can repair without inventing text — see `validateFrontmatter`. */
+    kind: 'sequence' | 'mapping' | 'scalar' | 'null';
+}
+/**
+ * Parse a SKILL.md: its frontmatter values and body, or `null` when the file
+ * has no frontmatter block or no body. Every consumer of frontmatter values
+ * goes through here — the write path's validation, `list()`'s published
+ * description, `relatedSkillNames` and the audit — so all of them read the same
+ * bytes the same way.
+ *
+ * @param content - the SKILL.md text.
+ * @returns the read, or `null` when there is no block or no body.
+ */
+export declare function parseFrontmatter(content: string): FrontmatterRead | null;
+/**
+ * Whether this file's frontmatter is valid as written for the strict platform
+ * catalog (see `FrontmatterRead.catalogInvalid`). Body-independent (a body-less
+ * file is still judged), and derived from the same read as `parseFrontmatter` —
+ * so the audit's verdict and the values the family publishes for one file can
+ * never disagree (V27 G2.1).
+ *
+ * @param content - the SKILL.md text.
+ * @returns `true` when the strict parser rejects the block or an unquoted value would read as something else.
+ */
+export declare function frontmatterCatalogInvalid(content: string): boolean;
+/** YAML plain-scalar hazards that make an UNQUOTED frontmatter value
+ * unloadable to the platform catalog (strict YAML parser): `: ` (mapping
+ * separator), ` #` (comment start), a trailing `:` (a mapping marker),
+ * or a leading YAML indicator. The evolution `parseFrontmatter` is
+ * deliberately lenient, so violations silently split family-visibility from
+ * platform-visibility (0.3.11 inkos-harness case: the description carried
+ * "…: " and the catalog dropped the whole skill). Already-quoted values and
+ * well-formed flow collections (`[a, b]` / `{a: b}`) are considered safe.
+ * 0.3.16 (E-47): null/bool/number-shaped plain scalars are flagged too — they
+ * parse as booleans/numbers on the platform while the family keeps the string
+ * (a `description: true` split-brain).
+ * This rule is only the FAST PATH — the write path re-verifies every rewrite
+ * with the real YAML parser (see normalizeFrontmatter), so an incomplete
+ * approximation can never corrupt a multiline flow value (P3-4). */
+export declare function yamlPlainScalarNeedsQuotes(value: string): boolean;
+export interface FrontmatterNormalizeResult {
+    content: string;
+    changed: boolean;
+    /** Frontmatter keys whose values were auto-quoted. */
+    fields: string[];
+    /** Values that cannot be auto-quoted safely (control characters, or a
+     * rewrite that failed the real-parser verification — a multiline flow
+     * collection line etc. is left untouched and reported here, so the write
+     * path rejects instead of silently damaging a value; 0.3.14). */
+    issues: string[];
+}
+/**
+ * Normalize a SKILL.md frontmatter block into catalog-loadable YAML: values
+ * that YAML forbids unquoted get quotes — double quotes normally, single
+ * quotes (with `''` doubling) when the value contains `"` or `\` (both legal
+ * unescaped inside single-quoted YAML). Idempotent; only single-line
+ * `key: value` entries are touched; body text is never modified; line-ending
+ * style is preserved. **Every rewrite is re-verified with the real YAML
+ * parser** (js-yaml — the same parser the platform catalog uses): if the
+ * rewritten block no longer parses, or a rewritten value's parsed content
+ * differs from the original, the rewrite is rolled back and reported in
+ * `issues` (fail-loud, never a silent value corruption — P3-4).
+ *
+ * V10-02 (P2-3): the rewrite decision is PER LINE — each entry parses its own
+ * value, so a duplicated key can never route one entry's unsafe value into a
+ * different line's rewrite (the old key→Map lookup rewrote the FIRST (safe)
+ * line with the SECOND line's quoted value, and the last-wins YAML reader
+ * masked the damage). A duplicated key is itself invalid input and is
+ * reported in `issues` (the write path refuses) instead of being rewritten.
+ */
+export declare function normalizeFrontmatter(content: string): FrontmatterNormalizeResult;
+/**
+ * Skill names referenced by a SKILL.md's `related_skills` frontmatter
+ * (B-line G3, rc.44): the single parsing source for the quality references
+ * factor and the learning-graph edges. The DSH frontmatter parser keeps the
+ * YAML value as a string (`"[a, b]"`), so names are scanned out of it; each
+ * must satisfy the skill-name shape and the referencing skill itself is
+ * excluded. Pure and deduplicated.
+ */
+export declare function relatedSkillNames(content: string, exclude?: string): string[];
+/** Whether `content` would exceed `limit` once written. */
+export declare function exceedsContentLimit(content: string, limit: number): boolean;
+/** S1.2: the repair path — a write that makes an already-over-limit file smaller.
+ * Only a NET SHRINK is exempt; an equal or larger write stays refused. */
+export declare function shrinksOverLimit(next: string, current: string | null | undefined, limit: number): boolean;
+export declare function validateFrontmatter(content: string, expectedName?: string, limits?: SkillLimits, 
+/** On-disk bytes, so a NET SHRINK of an over-limit file is allowed (S1.2). */
+current?: string | null): string | null;
+/** Hermes authoring quality bar for descriptions — see constants.ts
+ * (0.3.16 T-4 moved the single source there; the public re-export sits behind
+ * the package root, which re-exports constants anyway). */
+export interface AuthoringFeedback {
+    /** Frontmatter description length in characters (0 when absent). */
+    descriptionChars: number;
+    /** Whether the description exceeds the authoring bar (60) while still passing the platform limit. */
+    over60: boolean;
+    /** Whether the description contains a colon (the standard requires double-quote wrapping). */
+    hasColon: boolean;
+    /** Advice lines appended to mutation success messages. */
+    lines: string[];
+}
+/**
+ * Advisory authoring feedback (P0): evaluate frontmatter against the
+ * authoring bar WITHOUT changing platform validation semantics. The bar is
+ * the quality target, `validateFrontmatter`'s limits are the compatibility
+ * floor, and this bridge layer tells the model when its text would be
+ * truncated or route-poor instead of silently shipping it.
+ */
+export declare function authoringFeedback(frontmatter: Frontmatter): AuthoringFeedback;
+/** A1-15 (v18) / P2-2 (v19): the io layer marks an error `committed: true` when
+ * the rename landed and only the directory fsync failed. Every single-file
+ * writer must treat that as "written, durability unconfirmed" — never as a
+ * plain failure (which a caller would retry, or a two-phase caller roll back).
+ * v28 G2.1 (EVO-IO-05): this is a delegation to the seam's own
+ * `isCommittedWarning` — the marker predicate has exactly one definition. */
+//# sourceMappingURL=frontmatter.d.ts.map

package/lib/types/fuzzy-match.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fuzzy string matching and replacement for patch/restructure edits of skill files.
+ *
+ * Split out of skill-store.ts (S2-1): pure text functions with no store state.
+ * The store imports the scan, the budgets and the replace entry points directly;
+ * none of them is re-exported, so the package export surface is unchanged.
+ */
+/** V6-17 (0.3.37): the fuzzy-patch scan is O(n·m) with no input bound; a
+ * non-exact anchor past these budgets would block the event loop (measured
+ * ~6s at 20k×20k). Exact matches go through the fast `includes` path and stay
+ * allowed regardless of size. */
+export declare const FUZZY_MAX_PATTERN_CHARS = 4096;
+export declare const FUZZY_MAX_WORK = 8000000;
+/** Trim leading whitespace of the first line and trailing whitespace of the last line. */
+export declare function trimPatternBoundaries(pattern: string): string;
+export declare function fuzzyPatch(content: string, oldString: string, newString: string, replaceAll?: boolean): string | null;
+/** Deterministic section-extraction plan facts; the caller owns the IO and the append semantics. */
+//# sourceMappingURL=fuzzy-match.d.ts.map

package/lib/types/gates.d.ts

@@ -11,8 +11,8 @@
  * filesystem and the write origin, not on a name list.
  * @module @lmzhen/dsh-evolution-core
  */
-export type GateReason = 'excluded' | 'referenced' | 'suppressed' | 'protected-builtin';
-export interface GateSetInputs {
+type GateReason = 'excluded' | 'referenced' | 'suppressed' | 'protected-builtin';
+interface GateSetInputs {
     exclude?: ReadonlySet<string> | undefined;
     referenced?: ReadonlySet<string> | undefined;
     suppressed?: ReadonlySet<string> | undefined;
@@ -35,4 +35,5 @@ export declare function createGateSet(config: {
     referencedSkillNames?: ReadonlySet<string>;
     suppressedNames?: ReadonlySet<string>;
 }): EvolutionGateSet;
+export {};
 //# sourceMappingURL=gates.d.ts.map

package/lib/types/instance-scope.d.ts

@@ -14,10 +14,27 @@
  * the sidecar directory, so two instances resolving different homes (an
  * isolated test fixture, a second DSH_HOME) do not contend, while two rows on
  * one profile do.
+ *
+ * ## Scope (v43 FLOW2-1) — this registry is PER PROCESS
+ *
+ * `claims` below is a module-scope Map: two ROWS over one home in ONE process
+ * contend, while the SAME home in another process gets its own Map and is
+ * granted the key. That is by construction, not a gap to close here — the
+ * cross-process half of the contract is the IO backend's write lock
+ * (`transactIo`, core/io.ts), which serializes a per-target read-modify-write.
+ * The FLOW2-1 finding was three call sites reading a GRANTED claim as "no other
+ * process can be doing this work", so the caller contract is stated here:
+ * - granted means "no other row OF THIS PROCESS owns the key";
+ * - `instanceHolder()` answers "who holds it HERE"; `undefined` also covers
+ *   "held by another process";
+ * - a foreign holder's LIVENESS cannot be decided from a claim at all (no pid
+ *   is recorded here): a consumer that needs that decision must carry a pid in
+ *   its own credential and probe it (`isProcessAlive`, core/io.ts), or state
+ *   that its action is destructive.
  * @module @lmzhen/dsh-evolution-core/src/instance-scope
  */
 /** Outcome of a claim. `holder` is the current owner either way. */
-export interface InstanceClaimResult {
+interface InstanceClaimResult {
     readonly granted: boolean;
     readonly key: string;
     readonly holder: string;
@@ -30,6 +47,8 @@ export declare function instanceClaimKey(home: string, key: string): string;
 export declare function claimInstance(home: string, key: string, owner: string): InstanceClaimResult;
 /** Release only the claim `owner` took — never another instance's. */
 export declare function releaseInstance(home: string, key: string, owner: string): void;
-/** The current holder of `key` at `home`, or undefined. */
+/** The current holder of `key` at `home`, IN THIS PROCESS, or undefined
+ * (which also covers "another process holds it" — v43 FLOW2-1). */
 export declare function instanceHolder(home: string, key: string): string | undefined;
+export {};
 //# sourceMappingURL=instance-scope.d.ts.map

package/lib/types/io.d.ts

@@ -68,6 +68,34 @@ export interface EvolutionIoLike {
  * node backend's V5-03 short-circuit).
  */
 export declare function transactIo(io: EvolutionIoLike, path: string, task: (current: string | null) => string | null | Promise<string | null>): Promise<void>;
+/**
+ * V43 F-4 (S0-6): the shared "the transaction really invoked the task" guard.
+ * A backend that implements `transact` but never calls `task` resolves
+ * cleanly, so every caller that reads the outcome out of the task itself (a
+ * result slot filled inside it, a `Promise<void>` save path) reported success
+ * for a write that never happened — the silent-lost-write family the inline
+ * C-01 (memory-store) and V6-19 (skill-store) guards cover one call site at a
+ * time. Wrap the task handed to `transactIo`/`io.transact` and probe after
+ * the call: `invoked()` for a path that owns a structured refusal, or
+ * `assertInvoked()` for a void-returning path with no result channel (the
+ * family's fail-loud discipline, same wording as skill-store's guard).
+ *
+ * The wrapper is an identity pass-through — neither the backend nor the task
+ * sees a difference — and a task that IS invoked but skips the write (a
+ * dedupe no-op) counts as invoked: the probe answers "did the write path get
+ * to decide", not "did bytes change".
+ * @param what - the write being attempted, named in the thrown message
+ */
+export interface TransactTaskGuard {
+    /** Wrap the task handed to the transact backend, marking its invocation. */
+    wrap<A, R>(task: (current: A) => R): (current: A) => R;
+    /** Did the backend invoke the wrapped task? */
+    invoked(): boolean;
+    /** Throw when the backend never invoked it (nothing was written). */
+    assertInvoked(): void;
+}
+/** Build a {@link TransactTaskGuard} for one write path. See its doc. */
+export declare function transactTaskGuard(what: string): TransactTaskGuard;
 /** Lazy adapter over an IO provider registry, shared by every evolution consumer. */
 export declare function evolutionIoAdapter(provider: () => EvolutionIoLike): EvolutionIoLike;
 /**
@@ -181,9 +209,9 @@ export declare const LOCK_TEAR_TAKEOVER_MS = 3600000;
  */
 export declare function isCommittedWarning(error: unknown): boolean;
 /** V27 G1.1: the takeover branches, as a value. */
-export type TakeoverDecision = 'none' | 'dead' | 'empty' | 'corrupt';
+type TakeoverDecision = 'none' | 'dead' | 'empty' | 'corrupt';
 /** V27 G1.1: one lock observation, plus the liveness probe for its pid. */
-export interface TakeoverProbe {
+interface TakeoverProbe {
     /** Raw lock body. An empty string means the file exists with no content. */
     body: string;
     /** Lock mtime in epoch ms. */
@@ -220,4 +248,5 @@ export declare function decideTakeover(probe: TakeoverProbe): TakeoverDecision;
  * exceed the default budget and fail loud.
  */
 export declare function nodeEvolutionIo(lockAttempts?: number): EvolutionIoLike;
+export {};
 //# sourceMappingURL=io.d.ts.map

package/lib/types/limits.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Skill content limits: the byte/char budgets every write path validates against.
+ *
+ * Split out of skill-store.ts (S2-1) so the frontmatter validators and the
+ * store share one declaration site. Re-exported by skill-store.ts: the package
+ * export surface is unchanged.
+ */
+export interface SkillLimits {
+    maxNameLength: number;
+    maxDescriptionLength: number;
+    maxSkillContentChars: number;
+    maxSkillFileBytes: number;
+}
+export declare const DEFAULT_SKILL_LIMITS: SkillLimits;
+//# sourceMappingURL=limits.d.ts.map

package/lib/types/opt-in.d.ts

@@ -21,9 +21,19 @@
  * `sessionScoped` is what a deployment declares: true means "act only on a
  * session that carries the family's model tools", which is the right question in
  * BOTH install forms — at profile root every session carries them, inside a
- * variant preset only the sessions that selected one do. The shipped bundles set
- * it; a bare library mount and the host-only infrastructure mode leave it false
- * and keep the historical "every session" behavior.
+ * variant preset only the sessions that selected one do. The shipped bundles all
+ * set it, evolution-host included (S0-4 / v43 G-1); a bare library mount leaves
+ * it false and keeps the historical "every session" behavior. The host-only
+ * install thus matches nothing unless the model tool packages are mounted some
+ * other way, because that bundle mounts no model tool row.
+ *
+ * S0-4 (v43 J-1 / G-1): the gate's false used to be SILENT, which left exactly
+ * those deployments — host-only, or an overlay that disables tool-memory /
+ * tool-skill-manage — indistinguishable from an ordinary per-session skip while
+ * review injection and skill-usage telemetry stayed off for every session. The
+ * witness below records what the gate saw, the first scoped miss with no match
+ * ever leaves ONE warn per process, and `scopedProbeReport()` is the read side
+ * `/evolution doctor` renders as `scoped rows × probe`.
  * @module
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -35,6 +45,25 @@ import type { Context } from '@deepseek-ai/cordis';
  * a family session. Two names, not one: a deployment may disable either row.
  */
 export declare const FAMILY_SESSION_TOOL_NAMES: readonly string[];
+/** What the session-scoped gate has seen in this process. */
+export interface ScopedProbeReport {
+    /** `hit` — at least one session carried the family tools; `never-hit` — the
+     * gate evaluated sessions and rejected every one; `idle` — it has not been
+     * asked yet (no session event reached a scoped consumer since startup). */
+    verdict: 'hit' | 'never-hit' | 'idle';
+    /** Scoped evaluations that resolved true. */
+    hits: number;
+    /** Scoped evaluations that resolved false. */
+    misses: number;
+}
+/**
+ * Read the witness for a diagnostic surface (`/evolution doctor`). Read-only: it
+ * neither evaluates the probe nor consumes the one-time warn, so a report run
+ * cannot change what the next miss would have logged.
+ * @returns the verdict with both counts, zeroed in a process where the gate has
+ * not run.
+ */
+export declare function scopedProbeReport(): ScopedProbeReport;
 /**
  * Does this session's scope see the family's model tools?
  *
@@ -56,7 +85,8 @@ export declare function sessionSeesFamilyTools(ctx: Context, sessionId: string):
  * @returns true when the consumer may act on this session. A deployment that did
  * not declare session scoping always answers true (the historical behavior);
  * a scoped one answers true only for a session that carries the family's model
- * tools.
+ * tools. Each scoped answer updates the process witness, and the first miss with
+ * no match ever leaves one warn (see {@link noteScopedProbeMiss}).
  */
 export declare function sessionAudited(ctx: Context, sessionId: string, sessionScoped: boolean | undefined): boolean;
 //# sourceMappingURL=opt-in.d.ts.map

package/lib/types/skill-health.d.ts

@@ -54,7 +54,7 @@ export type SkillHealthVerdict = 'healthy' | 'warn' | 'needs-restructure';
  * and `snapshotFromLibrary` feed `read()` verbatim. The field names predate
  * that convention; the thresholds are calibrated against the whole file, so a
  * caller must not strip frontmatter before measuring. */
-export interface SkillHealthSnapshot {
+interface SkillHealthSnapshot {
     skillName: string;
     bodyChars: number;
     bodyText?: string | undefined;
@@ -65,7 +65,7 @@ export interface SkillHealthSnapshot {
     /** Usage-side view count, when the caller has it (A2 churn dimension). */
     readCount?: number | undefined;
 }
-export interface SkillHealthDim {
+interface SkillHealthDim {
     bodyChars: number;
     stampDensityPerKb: number | null;
     supportGroups: number;
@@ -79,4 +79,5 @@ export interface SkillHealthAssessment {
     reasons: string[];
 }
 export declare function assessStructureHealth(snapshot: SkillHealthSnapshot, thresholds?: SkillHealthThresholds): SkillHealthAssessment;
+export {};
 //# sourceMappingURL=skill-health.d.ts.map