@descryy/ir 0.1.0

package/dist/hypothesis.js

@@ -0,0 +1,116 @@
+/**
+ * The hypothesis state machine — `descry-ai-layer.md` §12, P19 of
+ * `ai-layer-plan.md` §11 (Phase 4).
+ *
+ * Six states, four transitions, all evaluated outside the model: *"Every
+ * transition is a deterministic rule evaluated outside the model. The model
+ * proposes; a rule disposes."* (`ai-layer-plan.md` §6). Same posture as
+ * G1–G4 (`../governance/*.ts`, `./finding.ts`) — a pure function over
+ * caller-supplied facts, never a prompt instruction.
+ *
+ * ## This is not a report category
+ *
+ * §12's own ruling, 2026-08-24 (Option B, `ai-governance-spec.md` §9): these
+ * six are *machine states*. `supported`/`confirmed` are not §19's
+ * `strongly supported`/`confirmed` report categories — only G4
+ * ({@link "./finding.ts".reportCategory}) assigns those, and it reads
+ * different inputs (resolution, name-level-ness, humanAsserted) that this
+ * module does not see at all. Do not compare a `HypothesisState` against a
+ * `ReportCategory` anywhere upstream of G4.
+ *
+ * ## What this module does not compute
+ *
+ * Three of the five inputs below are facts only the caller (the investigation
+ * loop, stage 12, P20) can supply, and are deliberately *not* derived here:
+ *
+ * - **`contradicted`** — whether evidence directly contradicts the
+ *   hypothesis. Detecting a contradiction is §10's own machinery (graph vs.
+ *   runtime disagreement, P21) — a larger, separate mechanism this module
+ *   does not reimplement.
+ * - **`roundLimitReached`** — whether this hypothesis has exhausted its
+ *   per-hypothesis tool-call budget. That accounting is `../governance/budget.ts`
+ *   (P18)'s job; this module only reacts to the boolean it produces.
+ * - **`toolCallsIssued`** — the raw count of tool calls issued so far.
+ *   `candidate → investigating` fires the instant the first call is issued,
+ *   before any result — even an empty or refused one — comes back, so this
+ *   cannot be derived from the evidence array's shape.
+ */
+import { directMechanismEvidence } from "./finding.js";
+/** §12's six states, in the order the architecture lists them. */
+export const HYPOTHESIS_STATES = [
+    "candidate",
+    "investigating",
+    "supported",
+    "confirmed",
+    "rejected",
+    "unconfirmed",
+];
+/** States §12 marks terminal outright — the loop stops touching this hypothesis. */
+export const TERMINAL_HYPOTHESIS_STATES = ["confirmed", "rejected", "unconfirmed"];
+export function isTerminalHypothesisState(state) {
+    return TERMINAL_HYPOTHESIS_STATES.includes(state);
+}
+/**
+ * Why an `unconfirmed` result was reached. `ai-layer-plan.md` §6 point 4 names
+ * three: `round-limit` is the one transition §12 actually defines
+ * (`any state → unconfirmed`, the round limit reached before `confirmed` or
+ * `rejected`); `superseded` and `unreachable` are named by the plan as
+ * additional reasons but have no defined trigger here — **disclosed, not
+ * modeled**, same as every other gap this project leaves rather than guesses
+ * a rule for.
+ */
+export const UNCONFIRMED_REASONS = ["round-limit"];
+/**
+ * How many independent evidence sources name this hypothesis — a graph fact
+ * counts as one, and each of the six {@link RuntimeSignalType} channels
+ * counts once however many records carry it (the same dedup-by-channel
+ * discipline `independentSignalTypes` uses for G4's `E`, applied to a wider
+ * source set).
+ *
+ * **Not `E`.** G4's `E` is a closed count over exactly the six runtime
+ * channels (`ai-governance-spec.md` §5.2) and a graph fact is not one of
+ * them by design — conflating the two is exactly the "machine state leaking
+ * into report vocabulary" failure §12's own ruling exists to prevent. This
+ * function answers a different question — *how many independent sources
+ * back this hypothesis, for the state machine's own `supported` transition*
+ * — and must never be passed anywhere G4 reads.
+ */
+export function independentEvidenceSources(runtimeEvidence, hasGraphFact) {
+    const channels = new Set(runtimeEvidence
+        .map((item) => item.signal)
+        .filter((signal) => signal !== null));
+    return channels.size + (hasGraphFact ? 1 : 0);
+}
+/**
+ * Derive this hypothesis's current state from its accumulated evidence.
+ * Never throws — this is a check, not an execution of the thing it is
+ * checking.
+ *
+ * Precedence, most decisive first: a caller-flagged contradiction always
+ * rejects, ahead of mechanism evidence — a sane caller never sets both, but
+ * rejection winning is the conservative reading. Direct mechanism evidence
+ * confirms next, regardless of round limit — §12's `confirmed` transition
+ * names no round bound. Only after both are checked does the round limit
+ * force `unconfirmed`. Below that, two or more independent sources reach
+ * `supported`; otherwise the hypothesis is still `investigating` once at
+ * least one call has been issued, or `candidate` before the first.
+ */
+export function deriveHypothesisState(input) {
+    if (input.toolCallsIssued === 0) {
+        return { state: "candidate" };
+    }
+    if (input.contradicted) {
+        return { state: "rejected" };
+    }
+    if (directMechanismEvidence(input.runtimeEvidence, input.failurePoint)) {
+        return { state: "confirmed" };
+    }
+    if (input.roundLimitReached) {
+        return { state: "unconfirmed", unconfirmedReason: "round-limit" };
+    }
+    if (independentEvidenceSources(input.runtimeEvidence, input.hasGraphFact) >= 2) {
+        return { state: "supported" };
+    }
+    return { state: "investigating" };
+}
+//# sourceMappingURL=hypothesis.js.map

package/dist/hypothesis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypothesis.js","sourceRoot":"","sources":["../src/hypothesis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEvD,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,WAAW;IACX,eAAe;IACf,WAAW;IACX,WAAW;IACX,UAAU;IACV,aAAa;CACL,CAAC;AAIX,oFAAoF;AACpF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,aAAa,CAAU,CAAC;AAE5F,MAAM,UAAU,yBAAyB,CAAC,KAAsB;IAC9D,OAAQ,0BAAyD,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACpF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,aAAa,CAAU,CAAC;AAgD5D;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,0BAA0B,CACxC,eAA2C,EAC3C,YAAqB;IAErB,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,eAAe;SACZ,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;SAC1B,MAAM,CAAC,CAAC,MAAM,EAA+B,EAAE,CAAC,MAAM,KAAK,IAAI,CAAC,CACpE,CAAC;IACF,OAAO,QAAQ,CAAC,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAA2B;IAC/D,IAAI,KAAK,CAAC,eAAe,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAChC,CAAC;IAED,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;QACvB,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,uBAAuB,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC;QACvE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAChC,CAAC;IAED,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;QAC5B,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,CAAC;IACpE,CAAC;IAED,IAAI,0BAA0B,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/E,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAChC,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC;AACpC,CAAC"}

package/dist/identity.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Node and edge identity.
+ *
+ * The single most consequential property here is that a node ID survives a file
+ * move or rename. Incident links, `CHANGES_WITH` weights and every compounding
+ * asset in the product are keyed to node identity — path-derived IDs churn on
+ * rename and reset all of it silently, with nothing in the output to reveal that
+ * it happened.
+ *
+ * A node ID is `hash(scopeOf(kind), language, kind, qualifiedSymbolPath)`.
+ *
+ * Neither of the first two fields is decoration. **Scope** is per node type, so a
+ * caller in one repository and a route in another land on one `API_ENDPOINT`
+ * instead of two that never meet. **Language** keeps `models.Order` in two
+ * languages apart, which module-qualified paths alone do not — that is the
+ * ordinary layout of a polyglot monorepo, and a collision there merges two
+ * unrelated symbols and pools their edges without a word in the output.
+ *
+ * See DEC-054 (scope and language), DEC-004 (exclude file path) and DEC-011 (the
+ * per-type qualified symbol path table, and the schema tag).
+ */
+import { type NodeType } from "./vocabulary.ts";
+/**
+ * Schema tag on every node ID. Costs three bytes and gives IR schema migration
+ * (§32 item 14 / DEC-017) a handle: a stored graph whose IDs carry a different
+ * tag is recognisably from a different identity scheme rather than silently
+ * mismatching.
+ *
+ * `n1:`/`e1:` were `hash(repo, kind, qsp)`. DEC-054 moved them to `n2:`/`e2:`,
+ * and that bump is the first real exercise of the mechanism — performed while
+ * there are zero stored graphs, because the alternative is discovering its bugs
+ * against half a million nodes and earned data that cannot be rebuilt.
+ */
+export declare const NODE_ID_PREFIX = "n2:";
+export declare const EDGE_ID_PREFIX = "e2:";
+/**
+ * Where a node's identity lives.
+ *
+ * `workspace` is the set of repositories that talk to each other — the contract
+ * boundary. It is **not** a GitHub organisation: an organisation is an ownership
+ * boundary, and the two overlap by accident and diverge by design. A workspace is
+ * always a deliberate configuration.
+ *
+ * It defaults to `repo`, so a single-repo user never learns the concept exists
+ * and local mode needs no configuration at all.
+ */
+export interface IdentityScope {
+    readonly repo: string;
+    readonly workspace?: string | undefined;
+}
+/**
+ * The DEC-054 scope table.
+ *
+ * The rule it encodes, which should be derivable from the table without reading
+ * the decision: **a source artefact belongs to a repository, a contract belongs
+ * to a system, and earned knowledge belongs to whoever earned it.**
+ *
+ * `API_ROUTE` is repo-scoped and `API_ENDPOINT` is workspace-scoped, and that
+ * asymmetry is the entire contract mechanism:
+ *
+ *     API_ROUTE ──SERVES_API──▶ API_ENDPOINT ◀──USES_API── caller
+ *     (repo)                    (workspace)
+ *
+ * Widening `API_ROUTE` to match would collapse two services' handlers for one
+ * path into a single node and destroy the only question worth asking — *which
+ * service serves it* — while leaving the join count unchanged, so nothing in the
+ * output would reveal the loss.
+ *
+ * `MODEL` and `DTO` stay repo-scoped deliberately. Widening them would join a
+ * `Company` in one language to a `Company` in another on the strength of a
+ * shared word; §13.2's mechanism is shape comparison at R3, not identifiers. An
+ * endpoint template is safe to key on because both sides literally transmit it.
+ *
+ * `INCIDENT` and `FIX_PATTERN` are workspace *provisionally*. Global is the
+ * attractive answer and may yet be right, but they are the two types DEC-017
+ * says must survive a rebuild — so they are the only two where widening later is
+ * lossy, because the earned facts on a merged node cannot be re-derived apart.
+ * Widening is the safe direction to defer; un-merging is not a direction.
+ */
+export declare const NODE_SCOPE: {
+    readonly FILE: "repo";
+    readonly FUNCTION: "repo";
+    readonly CLASS: "repo";
+    readonly MODULE: "repo";
+    readonly API_ROUTE: "repo";
+    readonly MODEL: "repo";
+    readonly DTO: "repo";
+    readonly COMPONENT: "repo";
+    readonly PAGE: "repo";
+    readonly TEST_CASE: "repo";
+    readonly API_ENDPOINT: "workspace";
+    readonly DATABASE_TABLE: "workspace";
+    readonly DATABASE_COLUMN: "workspace";
+    readonly INCIDENT: "workspace";
+    readonly FIX_PATTERN: "workspace";
+};
+export type ScopeKind = (typeof NODE_SCOPE)[NodeType];
+/** Node types whose identity crosses a repository boundary. */
+export declare const WORKSPACE_SCOPED_NODE_TYPES: readonly NodeType[];
+/**
+ * The scope string that actually enters the hash, per DEC-054's table.
+ *
+ * The value must be **byte-identical** across every repository in a workspace.
+ * `billing-platform` in one config and `billing_platform` in another yields a
+ * graph that is structurally perfect, internally consistent, and joins nothing —
+ * zero joins, zero errors, zero warnings. That is why the workspace id is
+ * declared once and validated at the boundary rather than restated per repo.
+ */
+export declare function scopeOf(kind: NodeType, scope: IdentityScope): string;
+/**
+ * Deterministic JSON: object keys sorted, arrays order-preserving.
+ *
+ * Two structurally equal values must serialise byte-identically regardless of
+ * key insertion order, or identity depends on the order an adapter happened to
+ * build its objects in.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * `n2:` + hash(scopeOf(kind), language, kind, qualified symbol path).
+ *
+ * Note what is absent: file path, line number, and `attrs`. A function that moves
+ * between files is the same function; a node whose attributes change is the same
+ * node.
+ *
+ * `language` is required rather than defaulted. Defaulting it to `null` would let
+ * a forgotten argument produce an id that quietly fails to match the one the
+ * adapter computes — a missing join with nothing to see. An identity change is
+ * exactly the moment every call site should have to be looked at.
+ *
+ * **`language` is now part of identity, which makes it a vocabulary rather than a
+ * free string.** Two producers describing the same artefact as `typescript` and
+ * `tsx` emit different nodes for the same symbol and never merge. Before DEC-054
+ * the field was descriptive; it is load-bearing now.
+ */
+export declare function nodeId(scope: IdentityScope, kind: NodeType, qualifiedSymbolPath: string, language: string | null): string;
+/**
+ * `e2:` + hash(from, to, type). See DEC-012.
+ *
+ * Deliberately excludes `resolution`, `confidence` and `producedBy`: two adapters
+ * finding the same relationship produce the same edge, which is what makes the
+ * merge policy possible. In prior-art graphs 30% of edges were exact duplicates,
+ * so this is load-bearing rather than tidy.
+ */
+export declare function edgeId(from: string, to: string, type: string): string;
+/**
+ * A stable identifier for one model-slot prompt's exact rendered text.
+ *
+ * `recording/writer.ts`'s `StartRunOptions.promptVersion` exists to carry
+ * this — `ai-layer-plan.md` §9 layer 4/layer 7's "invalidated by a prompt
+ * change" and "a golden that silently triples in cost after a prompt change
+ * is a regression" both need a real value here — and until now nothing
+ * computed one; that field's own doc reads *"No model layer exists yet, so
+ * always null today."* P25 (§11 Phase 5).
+ *
+ * Same hashing convention as {@link nodeId}/{@link edgeId} — first 128 bits
+ * of SHA-256, prefixed so a stored value is recognisably a prompt version
+ * rather than a node or edge id that happened to land in the same column.
+ * Hashes the **whole rendered prompt text**, not a caller-chosen label: a
+ * label is something a person remembers to update, a hash cannot be
+ * forgotten to change, and any difference — including whitespace — produces
+ * a different version, which is exactly the precision a looser comparison
+ * (trimmed, or blind to template placeholders) would miss.
+ *
+ * **Disclosed gap, same shape as every gate function before it in this
+ * plan:** `descry-desktop/packages/pipeline`'s model slots
+ * (`root-cause-analysis.ts`'s `NAME_LEVEL_SYSTEM_PROMPT` and its siblings)
+ * are this function's intended caller. None calls it yet — wiring it in, and
+ * republishing `@descryy/ir` so that repository can consume it, is
+ * follow-up work, not built here.
+ */
+export declare function promptVersion(promptText: string): string;
+/**
+ * A stable identity for one *shape* of finding — the key a dismissal ledger
+ * stores, so dismissing a finding suppresses the same claim on a later run
+ * without suppressing a different one that merely reads similarly.
+ *
+ * Architecture §20.1's funnel has always had an `F2` filter — *"known false
+ * positives from the feedback store"* — and §21.3 calls that store *"the real
+ * learning loop, not a cosmetic feature."* Neither had an implementation, and
+ * neither could until a finding had an identity that survives a re-run. This
+ * is that identity.
+ *
+ * **What it is over, and why each part earns its place:**
+ *
+ * - `finding`, `scope` — the claim, and what was being checked.
+ * - `affectedComponents` — node ids, which are `hash(repo, kind, qualified
+ *   symbol path)` and carry no file path, so a dismissal survives a rename.
+ *   The identity rule doing exactly the work it exists for.
+ * - the graph path's edges — the structural route the claim rests on. Same
+ *   words about the same component via a different path is a different claim.
+ * - **`resolutionLevel`, per §21.3 explicitly**: corrections are stored *"with
+ *   the resolution level at which the finding was produced… A false positive
+ *   generated at R1 and one generated at R3 have different causes and should
+ *   not suppress each other blindly."*
+ *
+ * **Deliberately excluded:** `recommendedAction`, `evidence`,
+ * `verificationStatus` — prose and per-run detail. A model rewording its own
+ * advice must not resurrect a finding the developer already dismissed.
+ *
+ * Lives here rather than in the funnel that consumes it for the reason
+ * `DEC-NEXT-edge-id-prefix-split` was filed: an identity gets one
+ * implementation, in the module named for identity, or it drifts.
+ */
+export declare function findingFingerprint(finding: {
+    readonly finding: string;
+    readonly scope: string;
+    readonly affectedComponents: readonly string[];
+    readonly graphPath: readonly {
+        readonly from: string;
+        readonly to: string;
+        readonly edgeType: string;
+    }[];
+    readonly resolutionLevel: unknown;
+}): string;
+/**
+ * Erase every parameter segment to the literal token `{param}`.
+ *
+ * `/orders/:id`, `/orders/{order_id}`, `/orders/<int:id>` and `/orders/[id]` all
+ * normalise to `/orders/{param}`. This is what makes one `API_ENDPOINT` node out
+ * of two adapters that never share a line of code — the cross-language join.
+ *
+ * Position is preserved by path structure, so distinct routes cannot collide:
+ * `/orders/{param}/items/{param}` stays distinct from `/orders/{param}`.
+ *
+ * See DEC-013. Base paths, router mounts and gateway rewrites remain open
+ * (architecture §32 item 16) — this handles the segment shape only.
+ *
+ * ## The query string is not part of the identity, and leaving it in broke joins
+ *
+ * **Found on real code, by a lane whose own gates could not see it.** A caller
+ * writes `GET /api/invoices?company_id={param}`; the route producer writes
+ * `GET /api/invoices`, because no routing framework declares a query in its
+ * path. With the query left in, the two hash to different endpoints and the
+ * join returns **nothing** — no error, no rejection, no ledger row. Five such
+ * calls ship today across two repositories.
+ *
+ * The defect survived a 100/100 precision draw with a 0/100 control on both
+ * sides, because the adjudicator compares an edge against the source text and
+ * the source really does write `?company_id=`. Every instrument was asking *did
+ * you read this call correctly* and none was asking *can this identity ever
+ * join* — the same shape as DEC-112, one layer down: the reader and its grader
+ * shared an assumption, so no amount of grading escaped it.
+ *
+ * **A query string cannot distinguish two endpoints here**, because only
+ * consumers write one. Two callers differing only by query are reaching the
+ * same route, so collapsing them is the correct merge rather than a lossy one.
+ * The residual limit is real and disclosed rather than modelled: an API that
+ * *routes* on a query parameter — `?action=create` dispatching separately from
+ * `?action=delete` — collapses to one endpoint here. No producer in this
+ * project emits such a route, and inventing identity for one nobody declares
+ * would be the guess this rule exists to prevent.
+ */
+export declare function normaliseEndpointPath(path: string): string;
+/**
+ * Qualified symbol path for an `API_ENDPOINT`: `METHOD /normalised/path`.
+ * This value IS the endpoint's identity, which is why normalisation must be
+ * applied before hashing rather than after.
+ */
+export declare function endpointQsp(method: string, path: string): string;
+/** Qualified symbol path for a `DATABASE_TABLE` or `DATABASE_COLUMN`. */
+export declare function tableQsp(schema: string, table: string, column?: string): string;
+/**
+ * Qualified symbol path for a `TEST_CASE`: `pkg::suite::case`.
+ *
+ * **The package root is part of it, exactly as it is for a code symbol.**
+ * `symbolQsp` has carried it since DEC-047, and this did not — so a test's
+ * qualifier was its module path *relative to its own package anchor*, with the
+ * anchor thrown away. Five Strapi packages each ship
+ * `admin/src/translations/tests/plural.test.ts` with the same titles, and all
+ * five hashed to one node: 42 cross-file collisions dropping 86 test cases on
+ * one repository, and 0 on either repository this was built against.
+ *
+ * `occurrence` distinguishes two cases a runner would report identically. Two
+ * `it("…")` calls with the same title in one describe block are legal and
+ * common — 57 pairs on Rocket.Chat, 30 on Strapi — and they are two different
+ * tests. Merging them loses one; numbering them keeps both. Only the second and
+ * later carry a suffix, so the common case is unchanged.
+ */
+export declare function testCaseQsp(pkg: string, suite: readonly string[], caseName: string, occurrence?: number): string;
+/**
+ * Qualified symbol path for a code symbol: `pkg::Namespace.Symbol`.
+ * `pkg` is the module/package root, not a file path.
+ */
+export declare function symbolQsp(pkg: string, symbolPath: readonly string[]): string;
+/**
+ * Qualified symbol path for a `FILE`: the repo-relative path.
+ *
+ * This is the documented path-fallback in DEC-004. It is unavoidable — a file's
+ * only stable name IS its path — and it has a real consequence: `CHANGES_WITH`
+ * weights are file-to-file, so they churn on rename unless the rename-detection
+ * pass rewrites them. DEC-004's guarantee is total for symbols and partial for
+ * files, and that asymmetry is deliberate rather than overlooked.
+ */
+export declare function fileQsp(repoRelativePath: string): string;
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"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"}