@principles/core 1.275.1 → 1.276.0

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

@@ -1,17 +1,28 @@
 /**
- * Layer 1 — the 4 built-in ContextManifests (design §6.6).
+ * 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; the manifest count is
- * exactly 4 (dreamer / scribe / artificer / evaluator, with evaluator carrying
- * a Stage 1 + Stage 2 variant). 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).
+ * 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
@@ -91,8 +102,13 @@ export const SCRIBE_MANIFEST = {
 /**
  * Artificer manifest. Under the one-level-redundancy rule, dreamer 5 dims are
  * NOT in scribe.predecessorSummary (that holds philosopher); so artificer's
- * dreamer context continues to flow through PRI-508's `resolveDreamerContext`
- * (F2) as tier2 raw fields.
+ * 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',
@@ -100,24 +116,85 @@ export const ARTIFICER_MANIFEST = {
     runnerKind: 'artificer',
     tier0: ['scribe.summary.headline', 'scribe.predecessorSummary.headline'],
     tier1: ['scribe.summary.principleText', 'scribe.summary.scope', 'scribe.summary.exceptions'],
-    tier2: ['dreamer.raw.betterDecision', 'dreamer.raw.rationale', 'dreamer.raw.riskLevel'],
+    tier2: [
+        'dreamer.raw.candidates.0.betterDecision',
+        'dreamer.raw.candidates.0.rationale',
+        'dreamer.raw.candidates.0.riskLevel',
+    ],
     budgetTokens: 2000,
     priority: [
         'scribe.summary.principleText',
-        'dreamer.raw.betterDecision',
+        'dreamer.raw.candidates.0.betterDecision',
         'scribe.summary.scope',
-        'dreamer.raw.rationale',
-        'dreamer.raw.riskLevel',
+        'dreamer.raw.candidates.0.rationale',
+        'dreamer.raw.candidates.0.riskLevel',
         'scribe.summary.exceptions',
         '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'],
+    tier2: ['replay.raw.traceFailures', 'replay.raw.systemFailures', 'replay.raw.globalViolations'],
+    budgetTokens: 2400,
+    priority: [
+        'scribe.summary.principleText',
+        'replay.raw.traceFailures',
+        'repair.summary.requiredChanges',
+        'replay.raw.systemFailures',
+        'replay.raw.globalViolations',
+        'repair.summary.concerns',
+        'replay.summary.passed',
+        'replay.summary.failedCaseCount',
+        'replay.summary.failureTypes',
+    ],
+};
 /**
  * Evaluator Stage 1 manifest — summary-level only (no tier2 raw fields).
- * Stage 1's `dreamer.summary.*` / `pain.summary.*` are read at the summary
- * level via CandidateLineage (Layer 2); if a summary is absent the path enters
- * `absent` and surfaces as a `summary_absent` degradation, never a silent empty.
+ *
+ * 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',
@@ -134,21 +211,21 @@ export const EVALUATOR_STAGE1_MANIFEST = {
         'dreamer.summary.betterDecision',
         'dreamer.summary.rationale',
         'dreamer.summary.riskLevel',
-        'pain.summary.rootSymptom',
-        'pain.summary.category',
+        'diagnostician.summary.rootSymptom',
+        'diagnostician.summary.category',
     ],
     tier2: [],
     budgetTokens: 3000,
     priority: [
         'scribe.summary.principleText',
         'dreamer.summary.betterDecision',
-        'pain.summary.rootSymptom',
+        'diagnostician.summary.rootSymptom',
         'artificer.summary.apiSurface',
         'dreamer.summary.riskLevel',
         'dreamer.summary.rationale',
         'scribe.summary.scope',
         'artificer.summary.risks',
-        'pain.summary.category',
+        'diagnostician.summary.category',
         'artificer.summary.changedFiles',
         'dreamer.summary.badDecision',
         'artificer.summary.headline',
@@ -159,19 +236,36 @@ export const EVALUATOR_STAGE1_MANIFEST = {
  * 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: ['pain.raw.evidence', 'dreamer.raw.candidates'],
+    tier2: ['diagnostician.raw.evidence', 'dreamer.raw.candidates'],
     budgetTokens: 4500,
-    priority: [...EVALUATOR_STAGE1_MANIFEST.priority, 'pain.raw.evidence', 'dreamer.raw.candidates'],
+    priority: [...EVALUATOR_STAGE1_MANIFEST.priority, 'dreamer.raw.candidates', 'diagnostician.raw.evidence'],
 };
 /**
- * The built-in manifest registry. **Always exactly 4** manifests (dreamer /
- * scribe / artificer / evaluator-with-two-variants). The three diagnostic
- * stages own NO manifest (design §4.7.1, requirement 2.14). The scope-
- * regression test (PR 1 task 3.21) guards this count.
+ * 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
@@ -181,12 +275,15 @@ 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 a subset of
- * {dreamer, scribe, artificer, evaluator} — never includes a diagnostic kind.
+ * 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 +1 @@
-{"version":3,"file":"context-manifests.js","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/context-manifests.ts"],"names":[],"mappings":"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"}
+{"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

@@ -0,0 +1,189 @@
+/**
+ * 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

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