@principles/core 1.242.0 → 1.244.0

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

@@ -0,0 +1,117 @@
+/**
+ * Layer 1 — ContextManifest: declarative field/budget declaration (design §6.2).
+ *
+ * Pure logic only: no I/O, no fs, no DB, no network (Core vs Plugin boundary,
+ * AGENTS.md `antipattern-core-io`).
+ *
+ * A `ContextManifest` declares which field paths a runner (or an evaluator
+ * stage) needs, layered into tier0/tier1/tier2, plus a token budget and a
+ * priority ordering. Layer 1's `allocateContext` (prompt-budget-manager.ts)
+ * consumes it; Layer 3's CLI surfaces its resolution.
+ *
+ * rc-4: tier* and priority array elements are validated element-wise as
+ * strings before use. rc-5: object keys read via `Object.hasOwn`.
+ */
+import type { SummaryRunnerKind } from './artifact-summary.js';
+export declare const CONTEXT_MANIFEST_SCHEMA_VERSION: 1;
+/**
+ * A declarative context-injection manifest (design §6.2).
+ *
+ * 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
+ */
+export interface ContextManifest {
+    readonly manifestId: string;
+    readonly schemaVersion: typeof CONTEXT_MANIFEST_SCHEMA_VERSION;
+    readonly runnerKind: SummaryRunnerKind;
+    readonly tier0: readonly string[];
+    readonly tier1: readonly string[];
+    /** Non-empty tier2 means CandidateLineage (Layer 2) may be triggered. */
+    readonly tier2: readonly string[];
+    /** Cross-level injection field budget (design §6.2.1). */
+    readonly budgetTokens: number;
+    /** Full priority sequence. Fields not listed here sort last (see rankOf). */
+    readonly priority: readonly string[];
+}
+export type ManifestWellFormednessError = {
+    readonly kind: 'budget_not_positive';
+    readonly budgetTokens: number;
+} | {
+    readonly kind: 'non_string_element';
+    readonly array: 'tier0' | 'tier1' | 'tier2' | 'priority';
+    readonly index: number;
+    readonly value: unknown;
+} | {
+    readonly kind: 'priority_does_not_cover_fields';
+    readonly missing: readonly string[];
+} | {
+    readonly kind: 'manifest_criterion_misaligned';
+    readonly detail: string;
+};
+export type ManifestValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: ManifestWellFormednessError;
+};
+/**
+ * INV-MANIFEST-CRITERION (design §6.6.1): every non-excluded dreamer dimension
+ * that the fidelity criteria may adjudicate must have a corresponding injected
+ * path in the adjudicating manifest's tier0 ∪ tier1 ∪ tier2. The criteria must
+ * never ask the model to judge a dimension it cannot see.
+ *
+ * This is the direct regression guard for the Phase 0 root cause "criteria ask
+ * 5 dims, manifest injects 4" (design §12.1 conclusion 2 root cause 2). It only
+ * applies to manifests whose runnerKind is the adjudicator (evaluator); other
+ * stages are not fidelity-adjudicating and are skipped.
+ *
+ * NOTE: this checks that each non-excluded dimension's summary path
+ * (`dreamer.summary.<dim>`) is present. A future change promoting a dimension
+ * from `excluded` to `required`/`optional` in DIMENSION_COVERAGE_POLICY without
+ * adding its path to the evaluator manifest will fail this check.
+ *
+ * @param manifest the manifest to check
+ * @param isAdjudicator true only for evaluator-stage manifests (the ones whose
+ *   injected fields the fidelity criteria see). Callers pass false for
+ *   non-evaluator manifests so this invariant is scoped correctly.
+ */
+export declare function checkManifestCriterionAlignment(manifest: ContextManifest, isAdjudicator: boolean): ManifestWellFormednessError | null;
+/**
+ * Validate a manifest is well-formed (design §6.2, requirements 4.2–4.8, 4.12,
+ * 4.13, 4.15).
+ *
+ * Checks:
+ *   - budgetTokens > 0
+ *   - every tier* and priority element is a string (rc-4)
+ *   - priority covers every field in tier0 ∪ tier1 ∪ tier2 (with a documented
+ *     escape hatch: unlisted fields are allowed but sort last via rankOf; this
+ *     check is intentionally NOT enforced because rankOf defines their rank —
+ *     see the note below)
+ *   - INV-MANIFEST-CRITERION when the manifest is an adjudicator (§6.6.1)
+ *
+ * Note on `priority` coverage: design §6.2 requires "priority covers tier0 ∪
+ * tier1 ∪ tier2", but rankOf assigns unlisted fields a rank of
+ * `priority.length + declarationOrder` (sorting them last), which is the
+ * intended behaviour. The check here therefore only flags an empty priority
+ * when fields exist (a clear misconfiguration), rather than requiring every
+ * field be listed. The built-in manifests DO list every field.
+ */
+export declare function validateManifest(manifest: ContextManifest, opts?: {
+    readonly isAdjudicator?: boolean;
+}): ManifestValidationResult;
+/**
+ * The rank of a field path within a manifest (design §6.2 / requirement 4.6).
+ *
+ * Listed fields get their index in `priority` (0-based, ascending = higher
+ * priority). Unlisted fields get `priority.length + declarationOrder`, where
+ * declarationOrder is the field's position in dedupe(tier0 ++ tier1 ++ tier2)
+ * — so unlisted fields sort AFTER all listed fields, in a stable declaration
+ * order. This replaces the base proposal's `indexOf(...) `-1`` which sorted
+ * unlisted fields FIRST (opposite of intent).
+ */
+export declare function rankOf(fieldPath: string, manifest: ContextManifest): number;
+/** All declared field paths of a manifest, deduped, in tier order. */
+export declare function declaredFields(manifest: ContextManifest): string[];
+//# sourceMappingURL=context-manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-manifest.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/context-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAO/D,eAAO,MAAM,+BAA+B,EAAG,CAAU,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,+BAA+B,CAAC;IAC/D,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAID,MAAM,MAAM,2BAA2B,GACnC;IAAE,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GACvE;IAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAClJ;IAAE,QAAQ,CAAC,IAAI,EAAE,gCAAgC,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACxF;IAAE,QAAQ,CAAC,IAAI,EAAE,+BAA+B,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GACrB;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,2BAA2B,CAAA;CAAE,CAAC;AAyBxE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,eAAe,EACzB,aAAa,EAAE,OAAO,GACrB,2BAA2B,GAAG,IAAI,CAmBpC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,EACzB,IAAI,GAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9C,wBAAwB,CA6B1B;AAID;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,MAAM,CAc3E;AAID,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,EAAE,CAElE"}

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

@@ -0,0 +1,156 @@
+/**
+ * Layer 1 — ContextManifest: declarative field/budget declaration (design §6.2).
+ *
+ * Pure logic only: no I/O, no fs, no DB, no network (Core vs Plugin boundary,
+ * AGENTS.md `antipattern-core-io`).
+ *
+ * A `ContextManifest` declares which field paths a runner (or an evaluator
+ * stage) needs, layered into tier0/tier1/tier2, plus a token budget and a
+ * priority ordering. Layer 1's `allocateContext` (prompt-budget-manager.ts)
+ * consumes it; Layer 3's CLI surfaces its resolution.
+ *
+ * rc-4: tier* and priority array elements are validated element-wise as
+ * strings before use. rc-5: object keys read via `Object.hasOwn`.
+ */
+import { DIMENSION_COVERAGE_POLICY, ALL_DREAMER_DIMENSIONS, } from './dimension-coverage-policy.js';
+export const CONTEXT_MANIFEST_SCHEMA_VERSION = 1;
+/** Deduplicate a string array preserving first-seen order (deterministic). */
+function dedupe(arr) {
+    const seen = new Set();
+    const out = [];
+    for (const s of arr) {
+        if (!seen.has(s)) {
+            seen.add(s);
+            out.push(s);
+        }
+    }
+    return out;
+}
+/**
+ * The set of all dreamer dimension names that are NOT `excluded` — i.e. the
+ * ones the fidelity criteria may adjudicate (design §6.6.1 INV-MANIFEST-
+ * CRITERION). `strategicPerspective` is excluded and must never appear in an
+ * adjudicating manifest.
+ */
+const NON_EXCLUDED_DIMENSIONS = ALL_DREAMER_DIMENSIONS.filter((d) => DIMENSION_COVERAGE_POLICY[d] !== 'excluded');
+/**
+ * INV-MANIFEST-CRITERION (design §6.6.1): every non-excluded dreamer dimension
+ * that the fidelity criteria may adjudicate must have a corresponding injected
+ * path in the adjudicating manifest's tier0 ∪ tier1 ∪ tier2. The criteria must
+ * never ask the model to judge a dimension it cannot see.
+ *
+ * This is the direct regression guard for the Phase 0 root cause "criteria ask
+ * 5 dims, manifest injects 4" (design §12.1 conclusion 2 root cause 2). It only
+ * applies to manifests whose runnerKind is the adjudicator (evaluator); other
+ * stages are not fidelity-adjudicating and are skipped.
+ *
+ * NOTE: this checks that each non-excluded dimension's summary path
+ * (`dreamer.summary.<dim>`) is present. A future change promoting a dimension
+ * from `excluded` to `required`/`optional` in DIMENSION_COVERAGE_POLICY without
+ * adding its path to the evaluator manifest will fail this check.
+ *
+ * @param manifest the manifest to check
+ * @param isAdjudicator true only for evaluator-stage manifests (the ones whose
+ *   injected fields the fidelity criteria see). Callers pass false for
+ *   non-evaluator manifests so this invariant is scoped correctly.
+ */
+export function checkManifestCriterionAlignment(manifest, isAdjudicator) {
+    if (!isAdjudicator)
+        return null;
+    if (manifest.runnerKind !== 'evaluator')
+        return null;
+    const allPaths = new Set([...manifest.tier0, ...manifest.tier1, ...manifest.tier2]);
+    const missing = [];
+    for (const dim of NON_EXCLUDED_DIMENSIONS) {
+        const path = `dreamer.summary.${dim}`;
+        if (!allPaths.has(path)) {
+            missing.push(path);
+        }
+    }
+    if (missing.length > 0) {
+        return {
+            kind: 'manifest_criterion_misaligned',
+            detail: `Adjudicating manifest "${manifest.manifestId}" is missing dreamer summary paths for non-excluded dimensions: ${missing.join(', ')}. DIMENSION_COVERAGE_POLICY requires these to be injectable (INV-MANIFEST-CRITERION, design §6.6.1).`,
+        };
+    }
+    return null;
+}
+/**
+ * Validate a manifest is well-formed (design §6.2, requirements 4.2–4.8, 4.12,
+ * 4.13, 4.15).
+ *
+ * Checks:
+ *   - budgetTokens > 0
+ *   - every tier* and priority element is a string (rc-4)
+ *   - priority covers every field in tier0 ∪ tier1 ∪ tier2 (with a documented
+ *     escape hatch: unlisted fields are allowed but sort last via rankOf; this
+ *     check is intentionally NOT enforced because rankOf defines their rank —
+ *     see the note below)
+ *   - INV-MANIFEST-CRITERION when the manifest is an adjudicator (§6.6.1)
+ *
+ * Note on `priority` coverage: design §6.2 requires "priority covers tier0 ∪
+ * tier1 ∪ tier2", but rankOf assigns unlisted fields a rank of
+ * `priority.length + declarationOrder` (sorting them last), which is the
+ * intended behaviour. The check here therefore only flags an empty priority
+ * when fields exist (a clear misconfiguration), rather than requiring every
+ * field be listed. The built-in manifests DO list every field.
+ */
+export function validateManifest(manifest, opts = {}) {
+    // budgetTokens > 0
+    if (!(manifest.budgetTokens > 0)) {
+        return { ok: false, error: { kind: 'budget_not_positive', budgetTokens: manifest.budgetTokens } };
+    }
+    // element-wise string check (rc-4)
+    const arrays = [
+        ['tier0', manifest.tier0],
+        ['tier1', manifest.tier1],
+        ['tier2', manifest.tier2],
+        ['priority', manifest.priority],
+    ];
+    for (const [name, arr] of arrays) {
+        for (let i = 0; i < arr.length; i++) {
+            const el = arr[i];
+            if (typeof el !== 'string') {
+                return { ok: false, error: { kind: 'non_string_element', array: name, index: i, value: el } };
+            }
+        }
+    }
+    // INV-MANIFEST-CRITERION (only for adjudicators)
+    const alignmentError = checkManifestCriterionAlignment(manifest, opts.isAdjudicator === true);
+    if (alignmentError !== null) {
+        return { ok: false, error: alignmentError };
+    }
+    return { ok: true };
+}
+// ── Priority ranking ─────────────────────────────────────────────────────────
+/**
+ * The rank of a field path within a manifest (design §6.2 / requirement 4.6).
+ *
+ * Listed fields get their index in `priority` (0-based, ascending = higher
+ * priority). Unlisted fields get `priority.length + declarationOrder`, where
+ * declarationOrder is the field's position in dedupe(tier0 ++ tier1 ++ tier2)
+ * — so unlisted fields sort AFTER all listed fields, in a stable declaration
+ * order. This replaces the base proposal's `indexOf(...) `-1`` which sorted
+ * unlisted fields FIRST (opposite of intent).
+ */
+export function rankOf(fieldPath, manifest) {
+    const listedRank = manifest.priority.indexOf(fieldPath);
+    if (listedRank >= 0)
+        return listedRank;
+    const declarationOrder = dedupe([
+        ...manifest.tier0,
+        ...manifest.tier1,
+        ...manifest.tier2,
+    ]).indexOf(fieldPath);
+    // declarationOrder is >= 0 for any field actually in the manifest; use a
+    // large fallback for paths not in any tier (defensive — they shouldn't be
+    // ranked, but rankOf must never return a value that sorts them first).
+    const order = declarationOrder >= 0 ? declarationOrder : 0;
+    return manifest.priority.length + order;
+}
+// ── Helpers for consumers ─────────────────────────────────────────────────────
+/** All declared field paths of a manifest, deduped, in tier order. */
+export function declaredFields(manifest) {
+    return dedupe([...manifest.tier0, ...manifest.tier1, ...manifest.tier2]);
+}
+//# sourceMappingURL=context-manifest.js.map

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

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

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

@@ -0,0 +1,74 @@
+/**
+ * Layer 1 — the 4 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).
+ *
+ * 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)
+ *
+ * budgetTokens semantics (design §6.2.1 / §6.3): the budget covers ONLY these
+ * manifest-declared injection fields. It does NOT include core grounding text
+ * (the quiet but default-on `internalization_core_grounding` flag), runner
+ * base instructions, or output-schema descriptions. `usedTokens <= budgetTokens`
+ * 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 type { ContextManifest } 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 declare const DREAMER_MANIFEST: ContextManifest;
+/**
+ * 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 declare const SCRIBE_MANIFEST: ContextManifest;
+/**
+ * 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.
+ */
+export declare const ARTIFICER_MANIFEST: ContextManifest;
+/**
+ * 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.
+ */
+export declare const EVALUATOR_STAGE1_MANIFEST: ContextManifest;
+/**
+ * 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.
+ */
+export declare const EVALUATOR_STAGE2_MANIFEST: ContextManifest;
+/**
+ * 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.
+ *
+ * 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 declare const BUILTIN_MANIFESTS: readonly ContextManifest[];
+/**
+ * The distinct runnerKinds that own a manifest. Always a subset of
+ * {dreamer, scribe, artificer, evaluator} — never includes a diagnostic kind.
+ */
+export declare const MANIFEST_RUNNER_KINDS: readonly string[];
+//# sourceMappingURL=context-manifests.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-manifests.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/context-manifests.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAuB9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,eA8B7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAkBhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,eAmCvC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,eAMvC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,eAAe,EAMvD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAElD,CAAC"}

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

@@ -0,0 +1,192 @@
+/**
+ * Layer 1 — the 4 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).
+ *
+ * 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)
+ *
+ * budgetTokens semantics (design §6.2.1 / §6.3): the budget covers ONLY these
+ * manifest-declared injection fields. It does NOT include core grounding text
+ * (the quiet but default-on `internalization_core_grounding` flag), runner
+ * base instructions, or output-schema descriptions. `usedTokens <= budgetTokens`
+ * 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 continues to flow through PRI-508's `resolveDreamerContext`
+ * (F2) as tier2 raw fields.
+ */
+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'],
+    tier2: ['dreamer.raw.betterDecision', 'dreamer.raw.rationale', 'dreamer.raw.riskLevel'],
+    budgetTokens: 2000,
+    priority: [
+        'scribe.summary.principleText',
+        'dreamer.raw.betterDecision',
+        'scribe.summary.scope',
+        'dreamer.raw.rationale',
+        'dreamer.raw.riskLevel',
+        'scribe.summary.exceptions',
+        'scribe.summary.headline',
+        'scribe.predecessorSummary.headline',
+    ],
+};
+/**
+ * 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.
+ */
+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',
+        'artificer.summary.changedFiles',
+        'artificer.summary.apiSurface',
+        'artificer.summary.risks',
+        'dreamer.summary.badDecision',
+        'dreamer.summary.betterDecision',
+        'dreamer.summary.rationale',
+        'dreamer.summary.riskLevel',
+        'pain.summary.rootSymptom',
+        'pain.summary.category',
+    ],
+    tier2: [],
+    budgetTokens: 3000,
+    priority: [
+        'scribe.summary.principleText',
+        'dreamer.summary.betterDecision',
+        'pain.summary.rootSymptom',
+        'artificer.summary.apiSurface',
+        'dreamer.summary.riskLevel',
+        'dreamer.summary.rationale',
+        'scribe.summary.scope',
+        'artificer.summary.risks',
+        'pain.summary.category',
+        '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.
+ */
+export const EVALUATOR_STAGE2_MANIFEST = {
+    ...EVALUATOR_STAGE1_MANIFEST,
+    manifestId: 'evaluator.stage2.v1',
+    tier2: ['pain.raw.evidence', 'dreamer.raw.candidates'],
+    budgetTokens: 4500,
+    priority: [...EVALUATOR_STAGE1_MANIFEST.priority, 'pain.raw.evidence', 'dreamer.raw.candidates'],
+};
+/**
+ * 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.
+ *
+ * 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,
+    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.
+ */
+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

@@ -0,0 +1 @@
+{"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/dimension-coverage-policy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Dreamer dimension coverage policy (design §6.5.1).
+ *
+ * The **single source of truth** for how the dreamer's five decision
+ * dimensions map to fidelity-judgement coverage classes. Both Layer 1
+ * (context-manifest well-formedness, INV-MANIFEST-CRITERION) and Layer 2 / PR 4
+ * (the progressive evaluator's flagged criteria) read this table — neither
+ * inlines a dimension-name array.
+ *
+ * rc-5 / ERR-013: dimension lookups must NOT use plain object indexing on an
+ * untrusted string (`table['__proto__']` would hit `Object.prototype`). This
+ * module only ever looks up dimensions it defines itself, so a typed record is
+ * safe here — but consumers that look up an LLM-supplied string must guard with
+ * `Object.hasOwn` or a `Map`.
+ */
+/** The five dimensions a dreamer candidate carries (design §6.1 dreamer fields). */
+export type DreamerDimension = 'badDecision' | 'betterDecision' | 'rationale' | 'riskLevel' | 'strategicPerspective';
+/** How a dimension participates in compression-fidelity judgement. */
+export type DimensionCoverageClass = 'required' | 'optional' | 'excluded';
+/**
+ * The coverage policy table (design §6.5.1).
+ *
+ *  required   normative content: must have a semantically-equivalent
+ *             expression in the principle text; absence counts as a defect
+ *             and enters `missingDimensions` + the flag path.
+ *  optional   counted as covered when present in `antiPatterns`; absence is
+ *             NOT a defect, only recorded in `optionalUncovered` for diagnosis.
+ *             Never enters `missingDimensions` and never flags.
+ *  excluded   an evaluation-lens label, not normative content; the criteria
+ *             must NOT draw a conclusion about it, and it is never injected
+ *             into the adjudicating manifest (§6.6.1).
+ */
+export declare const DIMENSION_COVERAGE_POLICY: Readonly<Record<DreamerDimension, DimensionCoverageClass>>;
+/**
+ * The required dimensions, derived from the policy table (order stable for
+ * deterministic output). Consumers read this instead of inlining a string
+ * array.
+ */
+export declare const REQUIRED_FIDELITY_DIMENSIONS: readonly DreamerDimension[];
+/** All five dimension names (order stable). */
+export declare const ALL_DREAMER_DIMENSIONS: readonly DreamerDimension[];
+/**
+ * rc-5-safe policy lookup for an untrusted (LLM-supplied) string. Returns the
+ * class only when `dim` is genuinely one of the five declared dimensions;
+ * `undefined` otherwise (so callers can ignore unknown / optional / excluded
+ * values the model may have stuffed into `missingDimensions`).
+ */
+export declare function lookupDimensionPolicy(dim: string): DimensionCoverageClass | undefined;
+/**
+ * True iff `dim` is a required dimension (used by the flagged-criteria filter,
+ * §6.5.3). Accepts an untrusted string.
+ */
+export declare function isRequiredDimension(dim: string): boolean;
+//# sourceMappingURL=dimension-coverage-policy.d.ts.map

package/dist/runtime-v2/internalization/dimension-coverage-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension-coverage-policy.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/dimension-coverage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,oFAAoF;AACpF,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,gBAAgB,GAChB,WAAW,GACX,WAAW,GACX,sBAAsB,CAAC;AAE3B,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AAE1E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,CAAC,CAMvF,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,gBAAgB,EAI9C,CAAC;AAEvB,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,EAAE,SAAS,gBAAgB,EAM7D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAGrF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD"}