@descryy/runtime-contracts 0.2.0 → 0.3.1

package/dist/evidence.d.ts

@@ -1,21 +1,11 @@
 /**
- * Evidence contract.
+ * Evidence contract, per §13 (evidence model), plus `evidenceId` (the
+ * ID-reference pattern Execution uses) and `stackTrace`. `confidence` is
+ * the resolution-honesty axis (§9), never conflated with environment
+ * fidelity (lives on Execution/Capability). Redaction per §25.
  *
- * Field list is verbatim from `documents/descry-runtime-plan.md` §13
- * (Evidence model), plus `evidenceId` (needed for the ID-reference pattern
- * Execution uses) and `stackTrace` (structured detail for the plan's
- * STACK_TRACE event type, per Agent 3's stack-fidelity finding below). Also
- * grounded in the architecture doc's §18.2 (evidence bundling —
- * screenshot/console/network/backend log, "none of these individually
- * would have been enough"), §17.2 (the observe stream), §9 (the three
- * confidence axes — this file's `confidence` field is the resolution-
- * honesty axis, never conflated with environment fidelity, which lives on
- * Execution/Capability instead) and §25 (redaction before storage).
- *
- * Static facts and runtime observations stay separate. Evidence never
- * embeds a graph node's data — `graphNodeId` is a reference into
- * @descryy/ir's identity scheme, resolved by whoever reads it. This file
- * does not, and must not, redefine graph identity or storage.
+ * Evidence never embeds a graph node's data — `graphNodeId` is a reference
+ * into @descryy/ir's identity scheme, resolved by whoever reads it.
  */
 import type { RuntimeEventType } from "./runtime-event.ts";
 export declare const EVIDENCE_SOURCES: readonly ["browser-dom", "browser-console", "browser-network", "backend-log", "backend-process", "process-exit", "http-response-payload", "test-runner", "harness", "dependency-check", "environment-check"];
@@ -23,89 +13,58 @@ export type EvidenceSource = (typeof EVIDENCE_SOURCES)[number];
 export declare const REDACTION_STATUSES: readonly ["not-required", "redacted", "pending-redaction"];
 export type RedactionStatus = (typeof REDACTION_STATUSES)[number];
 /**
- * Source-location reliability is not one axis with a probabilistic middle —
- * it is three structurally different classes (Agent 3's finding), and
- * conflating them into a single confidence number loses exactly the
+ * Three structurally different classes, not one axis with a probabilistic
+ * middle — collapsing them into a confidence number would lose the
  * information a reader needs to judge a location claim:
  *
- * - self-contained: the location came from the process's own captured
- *   state (a Python traceback, a Ruby backtrace, a Go `recover()` frame).
- *   Accurate when captured; the risk is *capture completeness*, not
+ * - self-contained: from the process's own captured state (Python/Ruby
+ *   traceback, Go `recover()` frame). Risk is capture completeness, not
  *   correctness.
  * - debug-info-present / debug-info-stripped: a binary's own line-number
- *   table (Java/Kotlin). A binary outcome — there is no partial case.
- * - side-artifact-resolved / side-artifact-stale / side-artifact-missing:
- *   resolution went through a separate file that can drift or vanish
- *   (a Node source map, a C# PDB, a Swift dSYM). "We mapped it and it's
- *   right" and "we mapped it through an artifact that may be stale" are
- *   different confidence claims, and this type is what lets Evidence say
- *   which one it is instead of reporting both identically.
- * - self-contained-eval-line: same mechanism as self-contained — the
- *   process's own captured backtrace, nothing translated through a side
- *   artifact — but the *line* does not index the named file. Ruby's
- *   `instance_eval`/`eval` frames print a synthetic path,
- *   `(eval at file.rb:12):1`, where `12` is where `eval` was called from
- *   but `1` counts lines within the evaluated string, not within
- *   `file.rb`. Opening `file.rb` at line `1` shows unrelated code, so this
- *   is not a plain self-contained claim; it is not a side-artifact claim
- *   either, since nothing was resolved through a separate file. See
- *   `packages/adapter-ruby/src/ruby-source-location-resolver.ts` for the
- *   one producer of this value.
+ *   table (Java/Kotlin) — binary outcome, no partial case.
+ * - side-artifact-resolved / -stale / -missing: resolved through a
+ *   separate file that can drift or vanish (source map, PDB, dSYM) —
+ *   "mapped and right" vs. "mapped through something that may be stale"
+ *   are different claims.
+ * - self-contained-eval-line: same mechanism as self-contained, but the
+ *   line doesn't index the named file. Ruby's `eval` frames print
+ *   `(eval at file.rb:12):1` — `12` is the eval call site, `1` counts
+ *   lines in the evaluated string, not in `file.rb`. Neither plain
+ *   self-contained nor side-artifact. See
+ *   `packages/adapter-ruby/src/ruby-source-location-resolver.ts`.
  */
 export declare const SOURCE_LOCATION_RELIABILITIES: readonly ["self-contained", "debug-info-present", "debug-info-stripped", "side-artifact-resolved", "side-artifact-stale", "side-artifact-missing", "self-contained-eval-line"];
 export type SourceLocationReliability = (typeof SOURCE_LOCATION_RELIABILITIES)[number];
 export interface SourceLocation {
     /**
-     * **Null when the runtime named no source file**, for the same reason
-     * `line` can be null and discovered by the same adapter.
-     *
-     * A stripped JVM frame is `at com.example.Thrower.handler(Unknown Source)`
-     * and a native one is `(Native Method)`: neither carries a filename. The
-     * method name is still real evidence and still resolves against the graph
-     * by symbol, so dropping such frames would delete an entire stack for a
-     * release build.
+     * Null when the runtime named no source file — a stripped JVM frame
+     * (`Unknown Source`) or native frame carry no filename, but the method
+     * name still resolves against the graph by symbol, so such frames
+     * aren't dropped.
      *
-     * The filename is **not** derived from the class name, though the JVM
-     * convention makes that look safe. Kotlin breaks it outright — a class
-     * `Foo` may be declared in `Bar.kt` — and this parser serves both
-     * languages, so the derivation would be right for one and wrong for the
-     * other. Null is the honest answer.
+     * Not derived from the class name: Kotlin breaks that convention (class
+     * `Foo` may live in `Bar.kt`), so null is the honest answer.
      */
     readonly file: string | null;
     /**
-     * **Null when the runtime genuinely captured no line**, which is a real
-     * state rather than a failure to look — and one this type could not
-     * express until a JVM adapter existed to need it.
-     *
-     * A JVM class compiled without a `LineNumberTable` (`javac -g:none`, and
-     * the default for many release builds) prints
-     * `at com.example.Thrower.handler(Unknown Source)`: the class is real,
-     * the method is real, and there is no line. So is a `(Native Method)`
-     * frame. `reliability: "debug-info-stripped"` describes exactly that
-     * situation — meaning that while this field was required, that enum value
-     * could only ever be attached to a **fabricated** number. The type and
-     * the enum contradicted each other, and the type was wrong.
-     *
-     * A frame with no line is still real evidence: the symbol name alone
-     * resolves against the graph. Dropping such frames would discard an
-     * entire stack for a stripped build, which is the "we could not read it"
-     * case that must degrade honestly rather than vanish.
+     * Null when the runtime genuinely captured no line — a real state, not
+     * a failure to look. A JVM class compiled without a `LineNumberTable`
+     * (`javac -g:none`) prints `Unknown Source`: real class, real method, no
+     * line. `reliability: "debug-info-stripped"` names exactly this case —
+     * making `line` optional here rather than fabricating a number.
      */
     readonly line: number | null;
     readonly column: number | null;
     readonly functionName: string | null;
     readonly reliability: SourceLocationReliability;
-    /** Set only for the side-artifact-* reliabilities — names the specific map/PDB/dSYM, so a stale-artifact finding is traceable to the file that drifted. Null otherwise. */
+    /** Set only for side-artifact-* reliabilities — names the map/PDB/dSYM, so a stale finding traces to the file that drifted. */
     readonly resolvedVia: string | null;
 }
 /**
- * Whether a captured stack reflects the actual logical call chain is a
- * third, orthogonal axis (Agent 3's finding): concurrency models
- * (coroutines, goroutines, async/await, tokio tasks) can capture a stack
- * successfully while structurally breaking the "reflects the logical
- * caller" guarantee. That is not a low-confidence stack — it is a
- * different kind of evidence, and gets its own field rather than a lower
- * number folded into `confidence`.
+ * Orthogonal to `confidence`: concurrency models (coroutines, goroutines,
+ * async/await, tokio tasks) can capture a stack successfully while
+ * structurally breaking the "reflects the logical caller" guarantee. Not
+ * a low-confidence stack — a different kind of evidence, own field.
  */
 export declare const STACK_FIDELITIES: readonly ["synchronous", "concurrency-fragmented", "unavailable"];
 export type StackFidelity = (typeof STACK_FIDELITIES)[number];
@@ -117,81 +76,44 @@ export interface StackFrame {
 export interface StackTrace {
     readonly fidelity: StackFidelity;
     /**
-     * **Most-recent call first**, always — `frames[0]` is the innermost frame,
-     * the one where execution actually was. Every parser normalises to this;
-     * callers may rely on it.
-     *
-     * This was unstated while TypeScript was the only language, because V8
-     * emits this order natively and nothing had to convert. It is not a
-     * universal convention: a CPython traceback prints **oldest call first**,
-     * with the failing frame last, and so does a Java `printStackTrace` cause
-     * chain read naively. An adapter for such a runtime reverses during
-     * parsing — the ordering decision belongs in the language adapter, which
-     * knows its own runtime's convention, never in a consumer that would have
-     * to ask which language produced the trace to know which end to read.
-     *
-     * Getting this wrong is quiet rather than loud: the trace still has the
-     * right frames and the right count, and root-cause traversal simply
-     * points at whichever end of the call chain happens to be first —
-     * typically the process entry point instead of the failing line.
+     * Most-recent call first, always — `frames[0]` is the innermost frame.
+     * Every parser normalises to this; callers may rely on it.
+     *
+     * Not universal: V8 emits this order natively, but a CPython traceback
+     * prints oldest-call-first, failing frame last. The adapter for such a
+     * runtime reverses during parsing — the ordering decision belongs there,
+     * never in a consumer that would have to ask which language produced
+     * the trace. Getting this wrong is quiet: right frames, right count,
+     * but root-cause traversal points at the wrong end of the call chain
+     * (typically the entry point instead of the failing line).
      */
     readonly frames: readonly StackFrame[];
     /**
-     * Which frame is the **failure site** — the one a developer should be sent
-     * to. Usually `0`; not always, and the exceptions are not exotic.
+     * Which frame is the failure site — the one a developer should be sent
+     * to. Usually `0`, not always: on several runtimes the innermost frame
+     * is the runtime's own, above the application's. Measured on live
+     * servers (RT-120/121):
      *
-     * ## Why an index and not `frames[0]`
-     *
-     * `frames[0]` is reliably the *innermost* frame. On several runtimes the
-     * innermost frame is the runtime's own, sitting above the application's,
-     * and is therefore innermost and useless. Measured on live still-running
-     * servers (Lane C, RT-120/121):
-     *
-     * | runtime | `frames[0]` | the failure site |
+     * | runtime | `frames[0]` | failure site |
      * | --- | --- | --- |
-     * | Go, recovered `net/http` handler panic | `net/http.(*conn).serve.func1` at `server.go:1897` | several frames down |
-     * | Rust, threaded server | `__rustc::rust_begin_unwind` at `panicking.rs:698` | after five `std`/`core` frames |
-     *
-     * The JVM's `Caused by:` chains, C#'s `--- End of stack trace from previous
-     * location ---` and Kotlin's coroutine frames are the same shape.
-     *
-     * ## Why this is not a heuristic
-     *
-     * **Each runtime marks the boundary itself**, which is the entire reason
-     * this is expressible as an index rather than as a filter:
-     *
-     * - Go prints a `panic(` frame **only** when the stack was walked through a
-     *   recover — an unrecovered panic has none. Measured both ways.
-     * - Rust's header names the panic site with line *and column*, and exactly
-     *   one frame matches it.
+     * | Go, recovered `net/http` panic | `net/http.(*conn).serve.func1` @ `server.go:1897` | several frames down |
+     * | Rust, threaded server | `__rustc::rust_begin_unwind` @ `panicking.rs:698` | after five std/core frames |
      *
-     * So the adapter that knows its runtime reads that runtime's own marker.
-     * Nothing above the IR boundary names a language, and nothing anywhere
-     * denylists a stdlib path — a path-shaped filter is the thing this field
-     * exists to make unnecessary, and it would break on any application that
-     * legitimately fails inside a library frame.
+     * JVM `Caused by:` chains, C# and Kotlin coroutine frames are the same
+     * shape.
      *
-     * ## Nothing is dropped
+     * Not a heuristic: each runtime marks the boundary itself (Go's `panic(`
+     * frame only appears when walked through recover; Rust's header names
+     * the panic site by line/column), so the adapter reads that marker
+     * directly rather than denylisting stdlib paths.
      *
-     * Every frame stays in `frames`, including the unwinding frames above the
-     * failure site. This is a **view**, not a filter, which is what keeps
-     * `adapter-rust`'s standing decision intact — *"std/core frames are kept;
-     * filtering them would be a readability judgment applied to evidence"* —
-     * rather than superseding it. `payload.raw` keeps the verbatim block as
-     * well, as always.
+     * Nothing is dropped — all frames stay in `frames` (a view, not a
+     * filter; `adapter-rust`'s "std/core frames are kept" stands).
      *
-     * ## Required, deliberately
-     *
-     * Not optional, for the reason RT-056 records about `processLifecycle`:
-     * **an optional field is one every existing adapter may silently omit**, and
-     * an adapter that never considered the question would keep today's behaviour
-     * with no signal that it never considered it. Where the innermost frame
-     * genuinely is the failure site the answer is `0` — but stated, not
-     * defaulted.
-     *
-     * Consumers must treat an out-of-range value as a fault rather than
-     * clamping to `0`: a silent fallback would reintroduce exactly the defect
-     * this field removes, through the error path instead of the happy one.
+     * Required, not optional (same reasoning as `processLifecycle`,
+     * RT-056): an optional field is one an adapter can silently omit.
+     * Consumers must treat an out-of-range value as a fault, not clamp to
+     * `0` — a silent fallback would reintroduce the defect this removes.
      */
     readonly primaryFrameIndex: number;
 }
@@ -200,7 +122,7 @@ export interface Evidence {
     readonly executionId: string;
     readonly timestamp: string;
     readonly source: EvidenceSource;
-    /** Which owned system this came from (§16.7) — null when not applicable. */
+    /** Which owned system this came from (§16.7), null when not applicable. */
     readonly service: string | null;
     /** ProcessHandle.processId, when this evidence is attributable to one process. */
     readonly process: string | null;
@@ -219,78 +141,62 @@ export interface Evidence {
     readonly confidence: number;
     readonly redactionStatus: RedactionStatus;
     /**
-     * The `version` field of the `package.json` that owns the collector which
-     * produced this row (e.g. `@descryhq-wq/runtime-browser`'s own version for
-     * browser-sourced evidence) — read from the package at module load, never
-     * hand-duplicated into a second string that can drift from what actually
-     * shipped. Same idea as `nodeVersion` elsewhere in this repo (`process.version`,
-     * always known, never probed) and as `@descryy/ir`'s `producedBy` (`adapterId@version`,
-     * "drives graph invalidation on adapter upgrade") applied to evidence instead of
-     * IR nodes — see RUNTIME-CHECKLIST.md §3/§19/§23: without this, evidence "cannot
-     * be invalidated by collector version the way IR nodes can."
+     * The `version` from the `package.json` owning the collector that
+     * produced this row, read at module load, never hand-duplicated. Same
+     * idea as `@descryy/ir`'s `producedBy` (drives graph invalidation on
+     * adapter upgrade), applied to evidence — without it, evidence can't be
+     * invalidated by collector version the way IR nodes can.
      *
-     * Required, not optional, for the same reason `primaryFrameIndex` above is
-     * required: an optional field is one an existing collector can silently omit,
-     * with no signal that it never considered the question.
+     * Required, not optional, same reasoning as `primaryFrameIndex`.
      */
     readonly collectorVersion: string;
+    /**
+     * True when this evidence originates from content that already existed in
+     * the observed source BEFORE this run began watching it — e.g. lines an
+     * attach-mode target had already written to its log file at the moment
+     * `attachToRunningProcess`/`attachManagedProcess` attached (RT-N3). Real,
+     * useful evidence, never discarded and never hidden from a reader — this
+     * only records that the runtime did not observe it happen.
+     *
+     * **Gates R4 promotion, not visibility.** `resolveObservedCrossServiceCall`
+     * (`@descryy/runtime-graph-correlator`) refuses to mint or confirm an
+     * `observedByRun` graph edge from evidence carrying this flag: R4 means
+     * "observed by THIS run," and content written before the run started
+     * watching was not, even though it is genuinely real and worth showing.
+     *
+     * Optional and true-only, same convention as `ProcessHandle.attached`: a
+     * collector with no attach/observation boundary to report (an ordinary
+     * spawned process, a browser page, a test runner) never sets this at all.
+     * Absent means "no boundary applies here" — never read as `false`.
+     */
+    readonly preExisting?: boolean;
 }
 /**
- * Which `SourceLocation` an `Evidence` carries for a given stack — one rule,
- * in one place, for every collector that turns a trace into evidence.
- *
- * ## Why it lives in the contract rather than in each collector
- *
- * It was written twice. `backend-observation`'s collector was moved onto
- * `primaryFrameIndex` (RT-083); `browser`'s console collector kept its own
- * `frames[0]` copy and nothing failed, because V8 reports
- * `primaryFrameIndex: 0` and the two rules agree there **by coincidence**.
- * A copied rule is a rule that will hold in one of them, and this one held
- * in one of them for exactly as long as one runtime was involved.
+ * Which `SourceLocation` an `Evidence` carries for a stack — one rule, one
+ * place, for every collector (was written twice and only agreed by
+ * coincidence, RT-083, since V8 always reports index 0).
  *
- * ## The empty location, which is the part that is not obvious
+ * `StackFrame.location` isn't nullable, so an unresolved frame still
+ * carries a `SourceLocation` with everything null. Returning it as-is
+ * would make `evidence-package.ts`'s `sourceLocation !== null` census
+ * count an unsymbolicated crash as located (measured, RT-126: a Swift CI
+ * crash with an address-only backtrace).
  *
- * `StackFrame.location` is not nullable, so a frame that resolved nothing
- * still carries a `SourceLocation` — one whose `file`, `line` and
- * `functionName` are all null. Returning it would set
- * `Evidence.sourceLocation` to a non-null object naming nothing, and
- * `evidence-package.ts` censuses located evidence with `sourceLocation !==
- * null`. An unsymbolicated crash would be counted as *located* in the very
- * artifact handed to a model — RT-124's shape (a thing reported as the thing
- * it failed to be), one field over.
+ * Discriminator is `functionName`, not `file`: a stripped JVM frame and a
+ * Rust release frame both have null file but a real symbol, resolvable
+ * against the graph by name — keying on `file` would delete the location
+ * for every stripped build.
  *
- * Measured rather than imagined (Lane C, RT-126): on a CI runner a real
- * Swift crash produced a real three-thread backtrace in which every frame is
- * address-only — no symbol, no `at file:line`.
- *
- * ## The discriminator is `functionName`, not `file`
- *
- * A stripped JVM frame (`at com.example.Thrower.handler(Unknown Source)`)
- * and a Rust release frame both have a null file **and a real symbol**,
- * which `SourceLocation.file`'s own doc calls real evidence that still
- * resolves against the graph by name. `adapter-jvm` and `adapter-rust` each
- * assert exactly that. Keying emptiness on a null file would delete the
- * location for every stripped build in both languages — the case this type
- * was widened to express.
- *
- * ## Nothing is lost by returning null
- *
- * The frames stay on `Evidence.stackTrace` with their raw text and their
- * `reliability`. "There was no stack" and "there was a stack that could name
- * nothing" therefore remain distinguishable **on the same record**, because
- * `stackTrace` separates them. That recoverability is the test for whether
- * nulling a field is honest degradation or information loss; here it is the
- * first.
+ * Nothing is lost by returning null: frames stay on `Evidence.stackTrace`
+ * with raw text and reliability, so "no stack" and "a stack naming
+ * nothing" stay distinguishable on the same record.
  */
 export declare function primaryFrameLocation(stackTrace: StackTrace | null): SourceLocation | null;
 /**
- * True when a location identifies no place in any source.
- *
- * `column` is deliberately not consulted: a column is an offset into a line,
- * so with no line it names no position and cannot make an otherwise-empty
- * location informative. `reliability` and `resolvedVia` are not consulted
- * either — they record *why* nothing resolved, which describes the failure
- * rather than a place.
+ * True when a location identifies no place in any source. `column` isn't
+ * consulted — an offset into a null line names no position. `reliability`
+ * and `resolvedVia` aren't either — they record why nothing resolved, not
+ * a place.
  */
 export declare function locationNamesNothing(location: SourceLocation): boolean;
 //# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

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