@principles/core 1.284.17 → 1.284.19

package/dist/runtime-v2/internalization/context-manifests.js

@@ -1,323 +0,0 @@
-/**
- * Layer 1 — the built-in ContextManifests (design §6.6).
- *
- * Pure logic only (Core vs Plugin boundary). These are the single source of
- * truth for which manifest each peer runner uses.
- *
- * INV-MANIFEST-SCOPE: the frozen invariant is **4 manifest-owning runner
- * KINDS** — dreamer / scribe / artificer / evaluator, with evaluator carrying
- * a Stage 1 + Stage 2 variant. It is NOT a literal manifest-instance count: a
- * runner kind may own more than one manifest VARIANT when its context needs
- * genuinely differ (e.g. `artificer.repair`, which additionally needs replay /
- * repair evidence a normal artificer must never see). The three diagnostic
- * stages own NO manifest (design §4.7.1, requirement 2.14, guarded by the
- * scope-regression test from PR 1 task 3.21).
- *
- * Field-path naming convention (design §6.6):
- *   `<stage>.summary.<key>`        — read from an ArtifactSummary
- *   `<stage>.predecessorSummary.*` — read from a forwarded predecessor summary
- *   `<stage>.raw.<path>`           — read from tier2 full contentJson (Layer 2)
- *                                    or from a related-reference namespace
- *
- * `<stage>.raw.<path>` paths must be TRUTHFUL: `readRawField` resolves them
- * verbatim against the durable contentJson. Numeric segments address array
- * elements — e.g. `dreamer.raw.candidates.0.betterDecision`, because
- * DreamerOutput nests its 5 dimensions under `candidates[0]`.
- *
- * budgetTokens semantics (design §6.2.1 / §6.3): the budget covers ONLY these
- * manifest-declared injection fields. It does NOT include core grounding text
- * (grounding is injected unconditionally via the runners' `coreGrounding: true`
- * default — the former `internalization_core_grounding` flag was retired in
- * PRI-751 after PRI-752's audit confirmed it had no runtime readers), runner
- * is therefore an injection-field budget ceiling, NOT a prompt-total-length
- * hard cap. If prompt-total-length control is ever needed, a separate total
- * budget must be declared with an explicit priority relation to budgetTokens.
- */
-import { CONTEXT_MANIFEST_SCHEMA_VERSION } from './context-manifest.js';
-/**
- * Dreamer manifest. `pain.summary.*` / `diagnosis.summary.*` resolve to the
- * diagnostic-chain writer-side summaries forwarded via the diag_router →
- * dreamer `predecessorSummary` (PR 1, design §4.7.1). tier2 empty → dreamer
- * does not read raw large fields.
- */
-export const DREAMER_MANIFEST = {
-    manifestId: 'dreamer.v1',
-    schemaVersion: CONTEXT_MANIFEST_SCHEMA_VERSION,
-    runnerKind: 'dreamer',
-    tier0: ['pain.summary.headline', 'diagnosis.summary.headline'],
-    tier1: [
-        'pain.summary.category',
-        'pain.summary.severity',
-        'pain.summary.rootSymptom',
-        'diagnosis.summary.rootCause',
-        'diagnosis.summary.affectedComponents',
-    ],
-    tier2: [],
-    budgetTokens: 1500,
-    priority: [
-        'diagnosis.summary.rootCause',
-        'pain.summary.rootSymptom',
-        'pain.summary.category',
-        'pain.summary.severity',
-        'diagnosis.summary.affectedComponents',
-        'pain.summary.headline',
-        'diagnosis.summary.headline',
-    ],
-};
-/**
- * Scribe manifest. Reads the dreamer 5 dimensions through
- * `philosopher.predecessorSummary.*` (the value of PR 1's writer-side
- * forwarding — design §4.7 修正七). tier2 empty.
- */
-export const SCRIBE_MANIFEST = {
-    manifestId: 'scribe.v1',
-    schemaVersion: CONTEXT_MANIFEST_SCHEMA_VERSION,
-    runnerKind: 'scribe',
-    tier0: ['philosopher.summary.headline', 'philosopher.predecessorSummary.headline'],
-    tier1: [
-        'philosopher.summary.thesis',
-        'philosopher.summary.principleTitle',
-        'philosopher.summary.principleScope',
-        // dreamer 5 dims forwarded via philosopher writer (修正七's value)
-        'philosopher.predecessorSummary.badDecision',
-        'philosopher.predecessorSummary.betterDecision',
-        'philosopher.predecessorSummary.rationale',
-        'philosopher.predecessorSummary.riskLevel',
-        'philosopher.predecessorSummary.strategicPerspective',
-    ],
-    tier2: [],
-    budgetTokens: 1800,
-    priority: [
-        'philosopher.summary.principleTitle',
-        'philosopher.summary.thesis',
-        'philosopher.predecessorSummary.betterDecision',
-        'philosopher.predecessorSummary.riskLevel',
-        'philosopher.predecessorSummary.rationale',
-        'philosopher.summary.principleScope',
-        'philosopher.predecessorSummary.badDecision',
-        'philosopher.predecessorSummary.strategicPerspective',
-        'philosopher.summary.headline',
-        'philosopher.predecessorSummary.headline',
-    ],
-};
-/**
- * Artificer manifest. Under the one-level-redundancy rule, dreamer 5 dims are
- * NOT in scribe.predecessorSummary (that holds philosopher); so artificer's
- * dreamer context resolves as tier2 raw fields through CandidateLineage (PR B).
- *
- * The tier2 paths address `candidates[0]` explicitly because that is where the
- * durable DreamerOutput keeps the selected candidate's 5 dimensions — the same
- * element `resolveDreamerContext` (PRI-508, F2) reads on the flag-off path.
- * When `context_manifest_budget` is OFF, `resolveDreamerContext` stays the
- * injection channel and this manifest is not consulted (design §23).
- */
-export const ARTIFICER_MANIFEST = {
-    manifestId: 'artificer.v1',
-    schemaVersion: CONTEXT_MANIFEST_SCHEMA_VERSION,
-    runnerKind: 'artificer',
-    tier0: ['scribe.summary.headline', 'scribe.predecessorSummary.headline'],
-    tier1: [
-        'scribe.summary.principleText',
-        'scribe.summary.scope',
-        'scribe.summary.exceptions',
-        // PRI-703 Phase 1: intent-contract anchor fields (absent on pre-contract
-        // scribe artifacts → surfaced as absent degradation, never silent).
-        'scribe.summary.intentOwner',
-        'scribe.summary.intentForbidden',
-        'scribe.summary.intentValidation',
-    ],
-    tier2: [
-        'dreamer.raw.candidates.0.betterDecision',
-        'dreamer.raw.candidates.0.rationale',
-        'dreamer.raw.candidates.0.riskLevel',
-    ],
-    budgetTokens: 2000,
-    priority: [
-        'scribe.summary.principleText',
-        'scribe.summary.intentOwner',
-        'dreamer.raw.candidates.0.betterDecision',
-        'scribe.summary.scope',
-        'scribe.summary.intentForbidden',
-        'dreamer.raw.candidates.0.rationale',
-        'dreamer.raw.candidates.0.riskLevel',
-        'scribe.summary.exceptions',
-        'scribe.summary.intentValidation',
-        'scribe.summary.headline',
-        'scribe.predecessorSummary.headline',
-    ],
-};
-/**
- * Artificer REPAIR manifest variant (design §35).
- *
- * A repair round is a different context job than a first-write: it additionally
- * needs the concrete deterministic replay evidence and the evaluator's required
- * changes. Those fields do NOT belong on the normal ARTIFICER_MANIFEST — a
- * first-write artificer has no replay to read and would only be polluted by
- * repair-only namespaces.
- *
- * `replay.*` is a RELATED reference, not ancestry: the source Evaluator
- * artifact is referenced by `RepairPayload.sourceEvaluatorTaskId`, never pushed
- * into `lineageArtifactIds` (design §33 / INV-LINEAGE-SCOPE). The values come
- * from the PR-A `RepairReplayContext`, so the ≤16 bound
- * (MAX_REPLAY_FAILURES_IN_REPAIR) is inherited rather than re-expanded
- * (design §43).
- *
- * Flag-off behaviour is unchanged: when `context_manifest_budget` is false this
- * manifest is never consulted and PR A's `repairFeedback` string remains the
- * replay-evidence channel (PRI-634 invariant §26).
- */
-export const ARTIFICER_REPAIR_MANIFEST = {
-    manifestId: 'artificer.repair.v1',
-    schemaVersion: CONTEXT_MANIFEST_SCHEMA_VERSION,
-    runnerKind: 'artificer',
-    tier0: ['scribe.summary.principleText', 'replay.summary.passed', 'replay.summary.failedCaseCount'],
-    tier1: [
-        'repair.summary.requiredChanges',
-        'repair.summary.concerns',
-        'replay.summary.failureTypes',
-        // PRI-703 Phase 1: the repair round must carry the intent anchor — a
-        // required change contradicting it is the evaluator's problem to
-        // re-derive, not the rule's to blindly satisfy.
-        'scribe.summary.intentOwner',
-        'scribe.summary.intentForbidden',
-        'scribe.summary.intentValidation',
-    ],
-    tier2: ['replay.raw.traceFailures', 'replay.raw.systemFailures', 'replay.raw.globalViolations'],
-    budgetTokens: 2400,
-    priority: [
-        'scribe.summary.principleText',
-        'scribe.summary.intentOwner',
-        'replay.raw.traceFailures',
-        'repair.summary.requiredChanges',
-        'scribe.summary.intentForbidden',
-        'replay.raw.systemFailures',
-        'replay.raw.globalViolations',
-        'repair.summary.concerns',
-        'scribe.summary.intentValidation',
-        'replay.summary.passed',
-        'replay.summary.failedCaseCount',
-        'replay.summary.failureTypes',
-    ],
-};
-/**
- * Evaluator Stage 1 manifest — summary-level only (no tier2 raw fields).
- *
- * NAMESPACE CORRECTION (PR B, fresh-code verification): this manifest names
- * stages that are NOT the Evaluator's direct predecessor (its predecessor is
- * the Artificer; `scribe.*` / `dreamer.*` / `diagnostician.*` sit further up
- * the chain). Layer 1's `readSummaryField` strips the leading `<stage>.`
- * segment and reads only the single loaded predecessor, so those ancestor
- * namespaces are resolved by the PR-B ancestry channel (`resolveAncestryPaths`,
- * which matches a lineage node by producer taskKind) — not by Channel 1.
- *
- * `pain.*` becomes `diagnostician.*` and is resolved through
- * `SEMANTIC_STAGE_ALIASES` (diagnostician → {diagnostician, diag_router}):
- * `pain` is a LOGICAL Layer-1 namespace, never a lineage node; the durable
- * DiagnosticianOutputV1 is owned by the split pipeline's `diag_router`
- * sub-task on the DEFAULT chain (legacy monolith committed it under
- * `diagnostician`). Summary fields on this stage are served by the bounded
- * read-time projection when the writer had to skip the Layer-0 envelope
- * (the output itself owns a top-level `summary` string).
- *
- * If an ancestor summary is absent the path enters `absent` and surfaces as a
- * `summary_absent` degradation, never a silent empty.
- */
-export const EVALUATOR_STAGE1_MANIFEST = {
-    manifestId: 'evaluator.stage1.v1',
-    schemaVersion: CONTEXT_MANIFEST_SCHEMA_VERSION,
-    runnerKind: 'evaluator',
-    tier0: ['artificer.summary.headline', 'artificer.predecessorSummary.headline'],
-    tier1: [
-        'scribe.summary.principleText',
-        'scribe.summary.scope',
-        // PRI-703 Phase 1: intent anchor fields — intentConsistency judging and
-        // adversarial-case scoping ("test-scope" concern) read these.
-        'scribe.summary.intentOwner',
-        'scribe.summary.intentForbidden',
-        'scribe.summary.intentValidation',
-        'artificer.summary.changedFiles',
-        'artificer.summary.apiSurface',
-        'artificer.summary.risks',
-        'dreamer.summary.badDecision',
-        'dreamer.summary.betterDecision',
-        'dreamer.summary.rationale',
-        'dreamer.summary.riskLevel',
-        'diagnostician.summary.rootSymptom',
-        'diagnostician.summary.category',
-    ],
-    tier2: [],
-    budgetTokens: 3000,
-    priority: [
-        'scribe.summary.principleText',
-        'scribe.summary.intentOwner',
-        'dreamer.summary.betterDecision',
-        'diagnostician.summary.rootSymptom',
-        'artificer.summary.apiSurface',
-        'dreamer.summary.riskLevel',
-        'dreamer.summary.rationale',
-        'scribe.summary.scope',
-        'scribe.summary.intentForbidden',
-        'artificer.summary.risks',
-        'diagnostician.summary.category',
-        'scribe.summary.intentValidation',
-        'artificer.summary.changedFiles',
-        'dreamer.summary.badDecision',
-        'artificer.summary.headline',
-        'artificer.predecessorSummary.headline',
-    ],
-};
-/**
- * Evaluator Stage 2 manifest — Stage 1 plus tier2 raw fields for the
- * independent re-evaluation (design §6.5). budgetTokens is larger to
- * accommodate the raw fields.
- *
- * SPEC ASSUMPTION STALE (PR B Phase 0, fresh-code verification): the SPEC's
- * example path `pain.raw.evidence` assumed a `pain` stage node on the lineage.
- * `pain` is only a LOGICAL summary namespace — never a lineage node. The
- * ancestry namespace is `diagnostician` (mapped via SEMANTIC_STAGE_ALIASES to
- * the real producer taskKinds):
- *
- *   - DEFAULT split chain: the durable DiagnosticianOutputV1 is committed by
- *     the `diag_router` sub-task (SplitDiagnosticianRunner stage C) — the node
- *     the dreamer lineage actually depends on (candidate.taskId);
- *   - legacy monolith: the same contract was committed under taskKind
- *     `diagnostician`.
- *
- * So `diagnostician.raw.evidence` reads `DiagnosticianOutputV1.evidence`, and
- * `dreamer.raw.candidates` addresses `DreamerOutput.candidates` directly — the
- * whole array, exactly what the deep-evidence stage reviews.
- */
-export const EVALUATOR_STAGE2_MANIFEST = {
-    ...EVALUATOR_STAGE1_MANIFEST,
-    manifestId: 'evaluator.stage2.v1',
-    tier2: ['diagnostician.raw.evidence', 'dreamer.raw.candidates'],
-    budgetTokens: 4500,
-    priority: [...EVALUATOR_STAGE1_MANIFEST.priority, 'dreamer.raw.candidates', 'diagnostician.raw.evidence'],
-};
-/**
- * The built-in manifest registry (INV-MANIFEST-SCOPE): 4 manifest-owning
- * runner KINDS across 6 manifest INSTANCES — dreamer, scribe, artificer,
- * artificer.repair, evaluator.stage1, evaluator.stage2. No diagnostic stage
- * owns a manifest (design §4.7.1, requirement 2.14). The scope-regression test
- * guards the runner-kind set, not the instance count.
- *
- * Exposed for: well-formedness enumeration (CP-12), the CLI's manifest
- * resolution, and the architecture-regression assertion that no diag kind is a
- * manifest's runnerKind.
- */
-export const BUILTIN_MANIFESTS = [
-    DREAMER_MANIFEST,
-    SCRIBE_MANIFEST,
-    ARTIFICER_MANIFEST,
-    ARTIFICER_REPAIR_MANIFEST,
-    EVALUATOR_STAGE1_MANIFEST,
-    EVALUATOR_STAGE2_MANIFEST,
-];
-/**
- * The distinct runnerKinds that own a manifest. Always exactly 4 and always a
- * subset of {dreamer, scribe, artificer, evaluator} — never includes a
- * diagnostic kind. Adding a runner-kind VARIANT (not a new kind) leaves this
- * unchanged, which is the intended reading of INV-MANIFEST-SCOPE.
- */
-export const MANIFEST_RUNNER_KINDS = Array.from(new Set(BUILTIN_MANIFESTS.map((m) => m.runnerKind)));
-//# sourceMappingURL=context-manifests.js.map

package/dist/runtime-v2/internalization/context-manifests.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-manifests.js","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/context-manifests.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/internalization/context-resolution.d.ts

@@ -1,189 +0,0 @@
-/**
- * Shared Information Plane — context resolution composition (design §6.4/§6.6).
- *
- * Pure logic only: no I/O, no fs, no DB, no network (Core vs Plugin boundary,
- * AGENTS.md `antipattern-core-io`).
- *
- * This module is the seam that turns three independent fact-acquisition
- * channels into ONE `available` map consumed by `resolveInjection`:
- *
- *   1. predecessor summary envelope → `summary-field-reader` (pure, Layer 1)
- *   2. ancestry content             → `CandidateLineage` nodes (Layer 2; the
- *                                     traversal/I/O is owned by the caller).
- *                                     Serves BOTH `<stage>.raw.*` and
- *                                     `<stage>.summary.*` for any ancestor.
- *   3. related references           → explicit caller-provided sources
- *                                     (e.g. the PR-A replay evidence), which
- *                                     are causal references — NOT ancestry
- *
- * Why three channels stay separate at acquisition but merge at composition
- * (design §33 / INV-LINEAGE-SCOPE): `lineageArtifactIds` expresses *content
- * ancestry*; a repair's `sourceEvaluatorTaskId` expresses *causal reference*.
- * Collapsing them into one data structure would silently redefine what
- * "lineage" means. They are unified at read time, never at write time.
- *
- * rc-1/rc-5: every source `contentJson` stays `unknown`; all reads use
- * `Object.hasOwn` + typeof/Array.isArray guards — no `as` casts.
- */
-import type { TruncationRecord } from './prompt-budget-manager.js';
-/**
- * Context field path grammar (design §6.6, extended for tier2 + related refs):
- *   `<ns>.summary.<key>`            — ArtifactSummary / related summary table
- *   `<ns>.predecessorSummary.<key>` — forwarded predecessor summary
- *   `<ns>.raw.<dotted.path>`        — full contentJson (ancestry) or a related
- *                                     raw table (related refs)
- */
-export type ContextPathLayer = 'raw' | 'summary' | 'predecessorSummary';
-export interface ParsedContextPath {
-    readonly namespace: string;
-    readonly layer: ContextPathLayer;
-    /** Path segments after the layer marker. Empty is never valid. */
-    readonly rest: readonly string[];
-}
-/**
- * Split a manifest field path into namespace / layer / rest.
- * Returns null for paths that do not follow the grammar (e.g. malformed,
- * too short) so callers can skip them instead of throwing.
- */
-export declare function parseContextPath(fieldPath: string): ParsedContextPath | null;
-/**
- * Read a dotted path out of an untrusted contentJson (rc-1/rc-5).
- *
- * Supports array element addressing via numeric segments
- * (`candidates.0.betterDecision`) because several durable artifacts nest their
- * semantic payload under an array (DreamerOutput.candidates). No I/O, no
- * lineage traversal, no manifest knowledge — it only walks a path.
- *
- * Returns undefined for: non-object intermediates, missing own properties,
- * out-of-range or non-numeric array access, and forbidden keys.
- */
-export declare function readRawField(rawPath: readonly string[], contentJson: unknown): unknown | undefined;
-/**
- * A manifest NAMESPACE is a *semantic* stage; a lineage node's stage is the
- * *producer taskKind* (two-hop F1). Explicit fixed mapping — never fuzzy:
- *
- *   diagnostician → the manifest addresses the final diagnosis artifact
- *   (DiagnosticianOutputV1). Its canonical producer on the DEFAULT split
- *   pipeline is taskKind `diag_router` (SplitDiagnosticianRunner stage C);
- *   the legacy monolithic runner committed the identical output contract
- *   under taskKind `diagnostician`. Both must resolve the same namespace.
- *
- * Adding an alias here is a contract change — the resolver's nearest-match
- * then accepts the listed producer kinds for that namespace.
- */
-export declare const SEMANTIC_STAGE_ALIASES: Readonly<Record<string, readonly string[]>>;
-/**
- * One durable ancestry node exposed to the raw reader. Built by the caller
- * from `CandidateLineage` nodes — this module never performs the traversal.
- *
- * `stage` is the two-hop `sourceTaskId → task.taskKind` value (design §6.4,
- * F1), never `artifactKind`: every internalization artifact is `principle`,
- * so `artifactKind` carries no stage authority.
- */
-export interface RawStageSource {
-    readonly stage: string;
-    /** rc-1: stays `unknown`; narrowed only by `readRawField`. */
-    readonly contentJson: unknown;
-}
-/**
- * Convert CandidateLineage nodes into raw stage sources.
- *
- * Order is preserved, which is what makes stage selection deterministic:
- * `CandidateLineage.resolve` walks BFS from the start artifact, so the FIRST
- * node matching a stage is the NEAREST ancestor (design §20). Later duplicates
- * are ignored — never a positional/arbitrary pick.
- *
- * Nodes whose stage could not be determined (`taskKind === 'unknown'`) carry no
- * stage authority and are dropped.
- */
-export declare function toRawStageSources(nodes: readonly {
-    readonly taskKind: string;
-    readonly contentJson: unknown;
-}[]): readonly RawStageSource[];
-/**
- * Split a manifest's tier2 into (ancestry raw paths, related raw paths).
- *
- * Related namespaces are excluded from the ancestry walk explicitly: a related
- * reference is a causal pointer supplied by the caller, so it must never be
- * mistaken for an ancestor stage — even if a taskKind happened to share the
- * name. This is the executable form of INV-LINEAGE-SCOPE (design §33).
- */
-export declare function partitionTier2Paths(tier2Paths: readonly string[], relatedNamespaces: readonly string[]): {
-    readonly ancestry: readonly string[];
-    readonly related: readonly string[];
-};
-/**
- * Resolve ancestor-declared paths against ancestry sources — BOTH layers:
- *
- *   `<stage>.raw.<dotted.path>` — full contentJson walk (`readRawField`)
- *   `<stage>.summary.<key>`     — the ancestor's own Layer 0 envelope
- *                                 (`readSummaryField`)
- *
- * Why the summary layer needs the ancestry channel too (PR B, evidence-backed):
- * `readSummaryField` deliberately STRIPS the leading `<stage>.` namespace and
- * reads only its single `predecessorContentJson`. That convention is correct
- * for manifests whose stage namespace is the runner's direct predecessor
- * (dreamer/scribe/artificer), but a manifest that names an ancestor further up
- * the chain (the Evaluator's `scribe.*` / `dreamer.*` / `diagnostician.*`)
- * would otherwise have those paths structurally unreachable — they would land
- * in `absent` forever and force the information-floor fallback on every run.
- * The lineage walk already holds every ancestor's contentJson, so the same
- * traversal that serves `raw` also serves `summary`, with no extra store read.
- *
- * First (nearest) matching stage wins; unresolvable paths are omitted so the
- * caller's information-floor logic records them in `absent`.
- *
- * `predecessorSummary` is intentionally NOT answered here: it is the
- * direct-predecessor forwarding concept owned by Channel 1.
- *
- * Namespace → node matching honors `SEMANTIC_STAGE_ALIASES`: a manifest
- * namespace is the SEMANTIC stage, a node's stage is the producer taskKind.
- */
-export declare function resolveAncestryPaths(fieldPaths: readonly string[], sources: readonly RawStageSource[]): ReadonlyMap<string, unknown>;
-/**
- * A related — NOT ancestral — fact source, exposed under its own namespace.
- *
- * Deliberately narrow: a flat namespace with two flat lookup tables. It is not
- * a relation graph and cannot express arbitrary edges. Each source is supplied
- * explicitly by the caller, so nothing is discovered or inferred at read time.
- *
- * Values are already-bounded objects: this seam never re-expands a durable
- * artifact. For replay evidence the caller passes the PR-A
- * `RepairReplayContext`, whose ≤16 bound (MAX_REPLAY_FAILURES_IN_REPAIR) is
- * therefore preserved through the information plane (design §43).
- */
-export interface RelatedContextSource {
-    /** Manifest namespace this source answers, e.g. `replay`. */
-    readonly namespace: string;
-    readonly summary?: Readonly<Record<string, unknown>>;
-    readonly raw?: Readonly<Record<string, unknown>>;
-}
-/**
- * Resolve `<ns>.summary.<key>` / `<ns>.raw.<key>` against related sources.
- * Related refs expose flat keys only — a multi-segment rest path is not a
- * related reference and is skipped (it belongs to the ancestry reader).
- */
-export declare function resolveRelatedPaths(fieldPaths: readonly string[], sources: readonly RelatedContextSource[]): ReadonlyMap<string, unknown>;
-/**
- * Merge the channel maps into one `available` map. FIRST WRITER WINS: the
- * predecessor summary envelope is the highest-authority local source, then
- * ancestry raw, then related. Channel namespaces are disjoint by construction
- * (a path is either a summary path, an ancestry raw path, or a related path),
- * so the rule only matters defensively — but it keeps the result deterministic.
- */
-export declare function mergeContextFields(base: ReadonlyMap<string, unknown>, extras: readonly ReadonlyMap<string, unknown>[]): ReadonlyMap<string, unknown>;
-/**
- * Required paths that did NOT reach the prompt — either absent from the
- * available map or dropped/truncated by the budget.
- *
- * This is the regression guard for "Stage2 enabled + raw fields silently
- * absent": a required field that was truncated by `PromptBudgetManager` counts
- * as unresolved just like an absent one, because the runner's semantic
- * requirement was still not met.
- */
-export declare function findUnresolvedRequiredPaths(params: {
-    readonly required: readonly string[];
-    readonly absent: readonly string[];
-    readonly truncated: readonly TruncationRecord[];
-}): readonly string[];
-//# sourceMappingURL=context-resolution.d.ts.map

package/dist/runtime-v2/internalization/context-resolution.d.ts.map

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