@principles/host-runtime 0.10.4 → 0.11.0

package/dist/active-principle-prompt.d.ts

@@ -1,4 +1,4 @@
-import { type ActivatedPrinciple, type PromptSelectionPolicy } from '@principles/core/runtime-v2';
+import { type ActivatedPrinciple, type PromptBudgetResolution, type PromptSelectionPolicy } from '@principles/core/runtime-v2';
 /** PRI-904 SPEC §10: bounded diagnostic id lists (mirrors the core selector's cap of 16). */
 export declare const MAX_SHARED_DIAGNOSTIC_IDS = 16;
 export interface ActivePrinciplePromptResult {
@@ -23,6 +23,20 @@ export interface ActivePrinciplePromptResult {
     droppedActivationIds?: string[];
     /** PRI-904 (bounded, max 16): activation ids that cannot fit even in an empty payload. */
     oversizedActivationIds?: string[];
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: provenance of the `budget` this
+     * selection ran under (capacity source/status + the resolved context
+     * window). Present on every result; `legacy_fallback` + `unknown` means
+     * no model capacity could be confirmed and the fixed budget was used.
+     */
+    budgetCapacitySource?: PromptBudgetResolution['capacitySource'];
+    budgetCapacityStatus?: PromptBudgetResolution['capacityStatus'];
+    budgetContextWindowTokens?: number | null;
+    budgetPolicyVersion?: PromptBudgetResolution['policyVersion'];
+    /** SPEC §7 v0.2: bounded fallback reason code; present only on legacy_fallback. */
+    budgetFallbackReason?: PromptBudgetResolution['fallbackReason'];
+    /** Non-sensitive log context (provider/model ids); never emitted to events. */
+    budgetFallbackDetail?: string;
 }
 export interface PromptActivationCandidates {
     principles: ActivatedPrinciple[];
@@ -52,4 +66,12 @@ export declare function buildActivePrinciplePromptContext(input: {
      * characterization baseline).
      */
     roundKey?: number;
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.1: the budget resolution for
+     * THIS request, resolved once by the entry point that holds the model
+     * facts. Absent → the resolver's no-facts default (legacy fixed 2000,
+     * capacityStatus unknown) — the historical behavior, used by callers with
+     * no model context (console projections, WorkBuddy without model facts).
+     */
+    promptBudget?: PromptBudgetResolution;
 }): Promise<ActivePrinciplePromptResult>;

package/dist/active-principle-prompt.js

@@ -1,4 +1,4 @@
-import { RUNTIME_V2_PRINCIPLE_BUDGET, SqliteActivationStateStore, SqliteConnection, SqlitePIArtifactStore, computeFeatureFlagsFromConfig, filterPromptActivations, renderPrinciplesToDirectives, resolvePrincipleFromArtifact, } from '@principles/core/runtime-v2';
+import { SqliteActivationStateStore, SqliteConnection, SqlitePIArtifactStore, computeFeatureFlagsFromConfig, filterPromptActivations, renderPrinciplesToDirectives, resolvePrincipleFromArtifact, resolvePromptBudget, } from '@principles/core/runtime-v2';
 import fs from 'node:fs';
 import path from 'node:path';
 import { escapeXml } from '@principles/core/prompt-builder';
@@ -81,13 +81,23 @@ export async function readPromptActivationCandidates(input) {
     return { principles, excludedPrincipleIds, warnings, aborted: false, selfReportEnabled, abstractionLayerEnabled };
 }
 export async function buildActivePrinciplePromptContext(input) {
+    // One resolution per request (SPEC §6.1): the caller's pre-resolved budget
+    // or the fixed-fallback default — never a per-line constant read.
+    const promptBudget = input.promptBudget ?? resolvePromptBudget();
+    const { budgetChars } = promptBudget;
     const { principles, excludedPrincipleIds, warnings, aborted, selfReportEnabled } = await readPromptActivationCandidates(input);
     if (aborted) {
         return {
             additionalContext: '', principleIds: [], activationIds: [], artifactIds: [], warnings,
-            budget: RUNTIME_V2_PRINCIPLE_BUDGET, truncated: false, excludedPrincipleIds,
+            budget: budgetChars, truncated: false, excludedPrincipleIds,
             excludedCount: excludedPrincipleIds.length, allValidatedPrinciplesExcluded: false,
             selectionPolicy: 'legacy_fifo_prefix_v1', eligibleCount: 0,
+            budgetCapacitySource: promptBudget.capacitySource,
+            budgetCapacityStatus: promptBudget.capacityStatus,
+            budgetContextWindowTokens: promptBudget.contextWindowTokens,
+            budgetPolicyVersion: promptBudget.policyVersion,
+            ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
+            ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
         };
     }
     const included = [];
@@ -109,14 +119,14 @@ export async function buildActivePrinciplePromptContext(input) {
     const droppedActivationIds = [];
     const oversizedActivationIds = [];
     const standaloneFits = (principle) => renderPrinciplesToDirectives([principle], new Set([principle.principleId]), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled }).length
-        <= RUNTIME_V2_PRINCIPLE_BUDGET;
+        <= budgetChars;
     const scanOrder = rotationStartIndex === undefined
         ? principles
         : principles.slice(rotationStartIndex).concat(principles.slice(0, rotationStartIndex));
     for (const principle of scanOrder) {
         const candidate = [...included, principle];
         const candidateContext = renderPrinciplesToDirectives(candidate, new Set(candidate.map((entry) => entry.principleId)), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled });
-        if (candidateContext.length > RUNTIME_V2_PRINCIPLE_BUDGET) {
+        if (candidateContext.length > budgetChars) {
             if (standaloneFits(principle)) {
                 // Fits alone but not now — normal budget truncation.
                 truncated = true;
@@ -144,7 +154,7 @@ export async function buildActivePrinciplePromptContext(input) {
         activationIds: included.map((principle) => principle.activationId),
         artifactIds: included.map((principle) => principle.artifactId),
         warnings,
-        budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+        budget: budgetChars,
         truncated,
         excludedPrincipleIds,
         excludedCount: excludedPrincipleIds.length,
@@ -155,5 +165,11 @@ export async function buildActivePrinciplePromptContext(input) {
         ...(rotationStartIndex !== undefined ? { rotationStartIndex } : {}),
         ...(droppedActivationIds.length > 0 ? { droppedActivationIds } : {}),
         ...(oversizedActivationIds.length > 0 ? { oversizedActivationIds } : {}),
+        budgetCapacitySource: promptBudget.capacitySource,
+        budgetCapacityStatus: promptBudget.capacityStatus,
+        budgetContextWindowTokens: promptBudget.contextWindowTokens,
+        budgetPolicyVersion: promptBudget.policyVersion,
+        ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
+        ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
     };
 }

package/dist/index.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isHostEvent, isHostEventResult, } from '@principles/core/host';
-import { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
+import { getPromptModelCatalog, resolvePromptBudget } from '@principles/core/runtime-v2';
 import { buildActivePrinciplePromptContext } from './active-principle-prompt.js';
 import { createProductionRuleHostGate } from './production-rulehost-gate.js';
 import { createProductionPainEvidenceHandler } from './production-pain-evidence.js';
@@ -211,6 +211,26 @@ export function createProductionHostRuntime(options = {}) {
             const prompt = await buildActivePrinciplePromptContext({
                 workspaceDir: event.context.workspaceDir,
                 excludePrincipleIds: options.promptExcludePrincipleIds?.(event),
+                promptBudget: resolvePromptBudget({
+                    // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: resolve ONCE per request
+                    // from the host's own hook facts (OpenClaw effective window /
+                    // Codex+WorkBuddy model id) against the installed local Pi AI
+                    // catalog — no network, no LLM call. Missing/untrusted facts
+                    // resolve to the legacy fixed budget with an observable reason.
+                    hostCapacity: event.context.modelContext === undefined
+                        ? undefined
+                        : {
+                            contextTokenBudget: event.context.modelContext.contextTokenBudget,
+                            contextWindowSource: event.context.modelContext.contextWindowSource,
+                        },
+                    modelIdentity: event.context.modelContext === undefined
+                        ? undefined
+                        : {
+                            providerId: event.context.modelContext.modelProviderId,
+                            modelId: event.context.modelContext.modelId,
+                        },
+                    catalog: getPromptModelCatalog(),
+                }),
             });
             // PRI-750: record the injection event on the shared path with the host
             // turn id (Codex turn_id → runId) so receipt events carry a turn-level
@@ -231,11 +251,22 @@ export function createProductionHostRuntime(options = {}) {
                     injectedCount: prompt.principleIds.length,
                     skippedWarnings: prompt.warnings,
                     injectedCharCount: prompt.additionalContext.length,
-                    budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+                    budget: prompt.budget,
                     ...(options.hostKind === 'openclaw' || options.hostKind === 'codex' || options.hostKind === 'workbuddy' ? { hostKind: options.hostKind } : {}),
                     eventId: randomUUID(),
                     ...(prompt.truncated !== undefined ? { v2Truncated: prompt.truncated } : {}),
                     ...(event.context.turnId !== undefined ? { runId: event.context.turnId } : {}),
+                    // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: budget provenance — the
+                    // recorded budget is the one THIS injection actually ran under
+                    // (prompt.budget), never a constant restated after the fact.
+                    ...(prompt.budgetPolicyVersion !== undefined ? { budgetPolicyVersion: prompt.budgetPolicyVersion } : {}),
+                    ...(prompt.budgetCapacitySource !== undefined ? { budgetCapacitySource: prompt.budgetCapacitySource } : {}),
+                    ...(prompt.budgetCapacityStatus !== undefined ? { budgetCapacityStatus: prompt.budgetCapacityStatus } : {}),
+                    ...(prompt.budgetContextWindowTokens != null ? { budgetContextWindowTokens: prompt.budgetContextWindowTokens } : {}),
+                    // SPEC §7 v0.2: the bounded fallback reason code rides the event so
+                    // operators can tell model-identity absence from catalog ambiguity
+                    // etc. without touching logs. Detail stays out of events.
+                    ...(prompt.budgetFallbackReason !== undefined ? { budgetFallbackReason: prompt.budgetFallbackReason } : {}),
                     // PRI-904: selection diagnostics (bounded, optional). On this route
                     // the policy is legacy_fifo_prefix_v1 and NO rotation provenance is
                     // emitted — a fair claim would be untrue here (see above).

package/dist/prompt-activation-deliverability.d.ts

@@ -1,4 +1,4 @@
-import { type ActivatedPrinciple } from '@principles/core/runtime-v2';
+import { type ActivatedPrinciple, type PromptBudgetTierFit } from '@principles/core/runtime-v2';
 import { PROMPT_INJECTION_UNIT, type PromptInjectionBudgetScope, type PromptInjectionRouteDecision, type PromptInjectionRouteName, type PromptInjectionTargetHost } from './prompt-injection-projection.js';
 /**
  * SPEC PD_PROMPT_CAPACITY_V1 R-B2: ONE route-aware single-artifact capacity
@@ -25,18 +25,46 @@ export type PromptArtifactDeliverability = {
     route: PromptInjectionRouteName;
     hostKind?: PromptInjectionTargetHost;
     basis?: PromptInjectionRouteDecision['basis'];
+    /**
+     * The budget this judgment is binding against: the MINIMUM supported
+     * tier — a deliverable here fits under EVERY supported budget
+     * (SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.3), so the strictest tier is
+     * the honest evidence.
+     */
     budget: number;
+    budgetMinChars: number;
+    budgetMaxChars: number;
     /** Single-item cost in UTF-16 code units under the bound route's serializer. */
     costChars: number;
     budgetScope: PromptInjectionBudgetScope;
     unit: typeof PROMPT_INJECTION_UNIT;
+} | {
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.3: the artifact fits under
+     * SOME supported budgets but not all — whether it injects depends on the
+     * runtime model's context window. NOT a promise of injection and NOT a
+     * permanent refusal; approval flow proceeds unchanged.
+     */
+    status: 'model_dependent';
+    route: PromptInjectionRouteName;
+    hostKind?: PromptInjectionTargetHost;
+    basis?: PromptInjectionRouteDecision['basis'];
+    budgetMinChars: number;
+    budgetMaxChars: number;
+    costChars: number;
+    budgetScope: PromptInjectionBudgetScope;
+    unit: typeof PROMPT_INJECTION_UNIT;
+    nextAction: string;
 } | {
     status: 'undeliverable';
     reason: 'single_item_exceeds_budget';
     route: PromptInjectionRouteName;
     hostKind?: PromptInjectionTargetHost;
     basis?: PromptInjectionRouteDecision['basis'];
+    /** The budget this judgment is binding against: the MAXIMUM supported tier. */
     budget: number;
+    budgetMinChars: number;
+    budgetMaxChars: number;
     costChars: number;
     overByChars: number;
     budgetScope: PromptInjectionBudgetScope;
@@ -47,10 +75,10 @@ export type PromptArtifactDeliverability = {
     /** Stable machine-readable reason (route facts or artifact content unresolvable). */
     reason: string;
     nextAction: string;
-    /** Route-unconfirmed case: per-host single-item fit so the UI can show both. */
+    /** Route-unconfirmed case: per-host single-item tier fit so the UI can show both. */
     perHost?: readonly {
         hostKind: PromptInjectionTargetHost;
-        fits: boolean;
+        tierFit: PromptBudgetTierFit;
         costChars: number;
     }[];
 };
@@ -72,11 +100,16 @@ export declare function resolvePromptCandidatePrinciple(artifact: PromptDelivera
  * lines). For an entry that does NOT fit, trimToBudget returns only the
  * header line, so the would-be cost is reconstructed from the header line it
  * DID return plus the real entry line (same format authority, listEntryLine).
+ *
+ * The budget parameter defaults to the legacy fixed budget: approval-time
+ * callers hold no runtime model facts, and SPEC §6.3 requires the fixed
+ * fallback — never an invented capacity — when none can be confirmed.
  */
 export declare function computePromptSingleItemFit(input: {
     principle: ActivatedPrinciple;
     route: PromptInjectionRouteName;
     selfReportEnabled: boolean;
+    budget?: number;
 }): {
     fits: boolean;
     costChars: number;

package/dist/prompt-activation-deliverability.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { RUNTIME_V2_PRINCIPLE_BUDGET, SqliteConnection, SqlitePIArtifactStore, computeFeatureFlagsFromConfig, listEntryLine, renderPrinciplesToDirectives, resolvePrincipleFromArtifact, trimToBudget, } from '@principles/core/runtime-v2';
+import { PROMPT_BUDGET_FALLBACK_CHARS, PROMPT_BUDGET_MAX_CHARS, PROMPT_BUDGET_MIN_CHARS, SqliteConnection, SqlitePIArtifactStore, classifySingleItemBudgetTier, computeFeatureFlagsFromConfig, listEntryLine, renderPrinciplesToDirectives, resolvePrincipleFromArtifact, trimToBudget, } from '@principles/core/runtime-v2';
 import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
 import { PROMPT_INJECTION_TARGET_HOSTS, PROMPT_INJECTION_UNIT, promptRouteForHost, resolvePromptInjectionRouteDecision, } from './prompt-injection-projection.js';
@@ -38,13 +38,18 @@ function selfReportEnabledFor(workspaceDir) {
  * lines). For an entry that does NOT fit, trimToBudget returns only the
  * header line, so the would-be cost is reconstructed from the header line it
  * DID return plus the real entry line (same format authority, listEntryLine).
+ *
+ * The budget parameter defaults to the legacy fixed budget: approval-time
+ * callers hold no runtime model facts, and SPEC §6.3 requires the fixed
+ * fallback — never an invented capacity — when none can be confirmed.
  */
 export function computePromptSingleItemFit(input) {
+    const budget = input.budget ?? PROMPT_BUDGET_FALLBACK_CHARS;
     if (input.route === 'shared_render') {
         const render = renderPrinciplesToDirectives([input.principle], new Set([input.principle.principleId]), { escapeFn: escapeXml, selfReportInstruction: input.selfReportEnabled });
-        return { fits: render.length <= RUNTIME_V2_PRINCIPLE_BUDGET, costChars: render.length };
+        return { fits: render.length <= budget, costChars: render.length };
     }
-    const trimmed = trimToBudget([input.principle], RUNTIME_V2_PRINCIPLE_BUDGET, escapeXml);
+    const trimmed = trimToBudget([input.principle], budget, escapeXml);
     const fits = trimmed.injectedIds.has(input.principle.principleId);
     const costChars = trimmed.lines.length > 1
         ? trimmed.lines.join('\n').length
@@ -52,6 +57,7 @@ export function computePromptSingleItemFit(input) {
     return { fits, costChars };
 }
 const UNDELIVERABLE_NEXT_ACTION = 'shorten the principle statement and resubmit, or use the activations page "modify to injectable version" entry to create a replacement artifact (the approval facts are preserved)';
+const MODEL_DEPENDENT_NEXT_ACTION = 'this principle fits the injection budget only on models with a larger context window; it may be excluded at runtime on smaller-context models — the approval itself is unaffected';
 /**
  * Precheck one artifact against the workspace's effective injection route.
  * Pure read — no state mutation, safe to call before any governance write.
@@ -78,7 +84,7 @@ export async function checkPromptArtifactDeliverability(input) {
         targetHost: input.targetHost,
     });
     if (decision.status === 'confirmed' && decision.route !== undefined) {
-        const { fits, costChars } = computePromptSingleItemFit({
+        const { costChars } = computePromptSingleItemFit({
             principle: resolved.principle,
             route: decision.route,
             selfReportEnabled,
@@ -86,44 +92,56 @@ export async function checkPromptArtifactDeliverability(input) {
         const budgetScope = decision.route === 'shared_render'
             ? 'full_directive_context'
             : 'selected_lines';
-        if (fits) {
+        const shared = {
+            route: decision.route,
+            ...(decision.hostKind !== undefined ? { hostKind: decision.hostKind } : {}),
+            ...(decision.basis !== undefined ? { basis: decision.basis } : {}),
+            budgetMinChars: PROMPT_BUDGET_MIN_CHARS,
+            budgetMaxChars: PROMPT_BUDGET_MAX_CHARS,
+            costChars,
+            budgetScope,
+            unit: PROMPT_INJECTION_UNIT,
+        };
+        // SPEC §6.3: approval time holds no runtime model identity — classify
+        // against the SUPPORTED budget range instead of pretending to know the
+        // executing model's window.
+        const tierFit = classifySingleItemBudgetTier(costChars);
+        if (tierFit === 'fits_all_tiers') {
             return {
                 status: 'deliverable',
-                route: decision.route,
-                ...(decision.hostKind !== undefined ? { hostKind: decision.hostKind } : {}),
-                ...(decision.basis !== undefined ? { basis: decision.basis } : {}),
-                budget: RUNTIME_V2_PRINCIPLE_BUDGET,
-                costChars,
-                budgetScope,
-                unit: PROMPT_INJECTION_UNIT,
+                ...shared,
+                budget: PROMPT_BUDGET_MIN_CHARS,
+            };
+        }
+        if (tierFit === 'model_dependent') {
+            return {
+                status: 'model_dependent',
+                ...shared,
+                nextAction: MODEL_DEPENDENT_NEXT_ACTION,
             };
         }
         return {
             status: 'undeliverable',
+            ...shared,
             reason: 'single_item_exceeds_budget',
-            route: decision.route,
-            ...(decision.hostKind !== undefined ? { hostKind: decision.hostKind } : {}),
-            ...(decision.basis !== undefined ? { basis: decision.basis } : {}),
-            budget: RUNTIME_V2_PRINCIPLE_BUDGET,
-            costChars,
-            overByChars: costChars - RUNTIME_V2_PRINCIPLE_BUDGET,
-            budgetScope,
-            unit: PROMPT_INJECTION_UNIT,
+            budget: PROMPT_BUDGET_MAX_CHARS,
+            overByChars: costChars - PROMPT_BUDGET_MAX_CHARS,
             nextAction: UNDELIVERABLE_NEXT_ACTION,
         };
     }
-    // Route unconfirmed: report per-host fit for every standard host instead of
-    // guessing (R-A1) — the write gate refuses, the UI can show both facts.
-    // Roster derives from the single SSoT list (review P3-1: a hand-typed
-    // two-host array dropped WorkBuddy from unconfirmed deliverability reports).
+    // Route unconfirmed: report per-host tier fit for every standard host
+    // instead of guessing (R-A1) — the write gate refuses, the UI can show
+    // both facts. Roster derives from the single SSoT list (review P3-1: a
+    // hand-typed two-host array dropped WorkBuddy from unconfirmed
+    // deliverability reports).
     const perHost = PROMPT_INJECTION_TARGET_HOSTS.map((hostKind) => {
         const route = promptRouteForHost(hostKind, decision.flagEnabled);
-        const { fits, costChars } = computePromptSingleItemFit({
+        const { costChars } = computePromptSingleItemFit({
             principle: resolved.principle,
             route,
             selfReportEnabled,
         });
-        return { hostKind, fits, costChars };
+        return { hostKind, tierFit: classifySingleItemBudgetTier(costChars), costChars };
     });
     return {
         status: 'unconfirmed',

package/dist/prompt-injection-projection.d.ts

@@ -1,4 +1,4 @@
-import { type PromptSelectionPolicy } from '@principles/core/runtime-v2';
+import { type PromptBudgetResolution, type PromptSelectionPolicy } from '@principles/core/runtime-v2';
 /** Hosts with a production prompt-injection path today (shared GovernanceHostKind boundary). */
 export type PromptInjectionTargetHost = 'openclaw' | 'codex' | 'workbuddy';
 /** Single host roster (review P2): every consumer derives from this list, so a
@@ -140,6 +140,20 @@ export interface PromptInjectionProjection {
      * route (where `usedChars` already IS the full render).
      */
     fullRenderChars?: number;
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.1/§7: provenance of `budget` —
+     * the same policy/resolution the real injection runs, so consumers can
+     * tell "runtime capacity confirmed" apart from "fixed-budget fallback"
+     * instead of assuming the forecast matches every model.
+     */
+    budgetCapacitySource?: PromptBudgetResolution['capacitySource'];
+    budgetCapacityStatus?: PromptBudgetResolution['capacityStatus'];
+    budgetContextWindowTokens?: number | null;
+    budgetPolicyVersion?: PromptBudgetResolution['policyVersion'];
+    /** SPEC §7 v0.2: bounded fallback reason code; present only on legacy_fallback. */
+    budgetFallbackReason?: PromptBudgetResolution['fallbackReason'];
+    /** Non-sensitive log context; never emitted to events. */
+    budgetFallbackDetail?: string;
 }
 /**
  * PR #1844 follow-up: forecast the prompt-injection budget from the SAME
@@ -186,6 +200,14 @@ export declare function buildLivePromptInjectionProjection(input: {
     roundKey?: number;
     /** AC-01: explicit route binding — 'codex'/'workbuddy' always shared, 'openclaw' by flag. */
     targetHost?: PromptInjectionTargetHost;
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.1: budget resolution this
+     * projection must run under. Absent → the fixed-fallback default (the
+     * honest "no runtime capacity confirmed" policy), NOT a silent second
+     * policy. Callers holding live model facts (the plugin hook) pass the
+     * SAME resolution the injection uses.
+     */
+    promptBudget?: PromptBudgetResolution;
 }): Promise<PromptInjectionProjection>;
 /**
  * AC-01/R-A1: the host-aware entry every console/CLI consumer should use.

package/dist/prompt-injection-projection.js

@@ -1,4 +1,4 @@
-import { RUNTIME_V2_PRINCIPLE_BUDGET, computeFeatureFlagsFromConfig, renderPrinciplesToDirectives, trimToBudget, } from '@principles/core/runtime-v2';
+import { computeFeatureFlagsFromConfig, renderPrinciplesToDirectives, resolvePromptBudget, trimToBudget, } from '@principles/core/runtime-v2';
 import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
 import { buildActivePrinciplePromptContext, readPromptActivationCandidates, MAX_SHARED_DIAGNOSTIC_IDS } from './active-principle-prompt.js';
@@ -223,6 +223,7 @@ function isDiagnosticCapHit(ids) {
  * `selectionPolicy` on the result.
  */
 export async function buildLivePromptInjectionProjection(input) {
+    const promptBudget = input.promptBudget ?? resolvePromptBudget();
     const flagEnabled = computeFeatureFlagsFromConfig(loadPdConfigForPlugin(input.workspaceDir).effective).flags.abstraction_layer_v1?.enabled === true;
     // Route face follows THE one route formula (review P2-2: a re-typed
     // codex-only ternary forecast WorkBuddy as legacy_trim while its adapter
@@ -232,7 +233,7 @@ export async function buildLivePromptInjectionProjection(input) {
         ? flagEnabled
         : promptRouteForHost(input.targetHost, flagEnabled) === 'shared_render';
     if (sharedRoute) {
-        const context = await buildActivePrinciplePromptContext(input);
+        const context = await buildActivePrinciplePromptContext({ ...input, promptBudget });
         const oversized = context.oversizedActivationIds ?? [];
         const dropped = context.droppedActivationIds ?? [];
         return {
@@ -256,6 +257,12 @@ export async function buildLivePromptInjectionProjection(input) {
             droppedActivationIds: dropped,
             oversizedDiagnosticTruncated: isDiagnosticCapHit(oversized),
             droppedDiagnosticTruncated: isDiagnosticCapHit(dropped),
+            budgetCapacitySource: context.budgetCapacitySource,
+            budgetCapacityStatus: context.budgetCapacityStatus,
+            budgetContextWindowTokens: context.budgetContextWindowTokens,
+            budgetPolicyVersion: context.budgetPolicyVersion,
+            ...(context.budgetFallbackReason !== undefined ? { budgetFallbackReason: context.budgetFallbackReason } : {}),
+            ...(context.budgetFallbackDetail !== undefined ? { budgetFallbackDetail: context.budgetFallbackDetail } : {}),
         };
     }
     const candidates = await readPromptActivationCandidates(input);
@@ -263,7 +270,7 @@ export async function buildLivePromptInjectionProjection(input) {
     if (candidates.aborted || principles.length === 0) {
         return {
             route: 'legacy_trim',
-            budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+            budget: promptBudget.budgetChars,
             usedChars: 0,
             truncated: false,
             injectedPrincipleIds: [],
@@ -279,11 +286,17 @@ export async function buildLivePromptInjectionProjection(input) {
             droppedActivationIds: [],
             oversizedDiagnosticTruncated: false,
             droppedDiagnosticTruncated: false,
+            budgetCapacitySource: promptBudget.capacitySource,
+            budgetCapacityStatus: promptBudget.capacityStatus,
+            budgetContextWindowTokens: promptBudget.contextWindowTokens,
+            budgetPolicyVersion: promptBudget.policyVersion,
+            ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
+            ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
         };
     }
     // PR-1894: pass the caller's round key so the forecast runs the SAME
     // packing policy production runs this turn.
-    const trimmed = trimToBudget(principles, RUNTIME_V2_PRINCIPLE_BUDGET, escapeXml, input.roundKey);
+    const trimmed = trimToBudget(principles, promptBudget.budgetChars, escapeXml, input.roundKey);
     const injected = principles.filter((p) => trimmed.injectedIds.has(p.principleId));
     // PR-1894: the legacy_trim route IS the OpenClaw plugin-local route, which
     // rotates on every recorded user turn (PRI-904). Reachability is therefore
@@ -291,11 +304,11 @@ export async function buildLivePromptInjectionProjection(input) {
     // round key — a console without a session key must still be able to tell
     // "queued behind rotation" apart from "structurally starved", otherwise it
     // keeps telling the Owner to deactivate healthy principles.
-    const eventuallyInjectedActivationIds = collectReachableActivationIds(principles, RUNTIME_V2_PRINCIPLE_BUDGET);
+    const eventuallyInjectedActivationIds = collectReachableActivationIds(principles, promptBudget.budgetChars);
     const fullRenderChars = renderPrinciplesToDirectives(injected, trimmed.injectedIds, { escapeFn: escapeXml, selfReportInstruction: candidates.selfReportEnabled }).length;
     return {
         route: 'legacy_trim',
-        budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+        budget: promptBudget.budgetChars,
         usedChars: trimmed.lines.join('\n').length,
         truncated: trimmed.truncated,
         injectedPrincipleIds: [...trimmed.injectedIds],
@@ -312,6 +325,12 @@ export async function buildLivePromptInjectionProjection(input) {
         oversizedDiagnosticTruncated: isDiagnosticCapHit(trimmed.oversizedActivationIds),
         droppedDiagnosticTruncated: isDiagnosticCapHit(trimmed.droppedActivationIds),
         ...(injected.length > 0 ? { fullRenderChars } : {}),
+        budgetCapacitySource: promptBudget.capacitySource,
+        budgetCapacityStatus: promptBudget.capacityStatus,
+        budgetContextWindowTokens: promptBudget.contextWindowTokens,
+        budgetPolicyVersion: promptBudget.policyVersion,
+        ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
+        ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
     };
 }
 export async function resolveLivePromptInjectionProjection(input) {

package/dist/prompt-injection-status.d.ts

@@ -1,3 +1,4 @@
+import { type PromptBudgetTierFit } from '@principles/core/runtime-v2';
 import { type PromptInjectionBudgetScope, type PromptInjectionRouteDecision, type PromptInjectionRouteName, type PromptInjectionTargetHost } from './prompt-injection-projection.js';
 /**
  * SPEC PD_PROMPT_CAPACITY_V1 R-A3: per-live-activation injection status for
@@ -9,25 +10,39 @@ import { type PromptInjectionBudgetScope, type PromptInjectionRouteDecision, typ
  * `route_unconfirmed` surfaces AC-01's honest unknown instead of a guess.
  * No compliance/遵守 counts are produced here — absence of injection logs is
  * NOT reported as "zero compliance" (AC-12 boundary).
+ *
+ * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: "oversized" now means the entry
+ * exceeds the MAXIMUM supported budget (never injectable on any supported
+ * model); a row that misses the CURRENT projection budget but fits within
+ * the supported [min, max] range is `model_dependent` — whether it injects
+ * depends on the runtime model's context window, which this surface cannot
+ * see. Budget figures come from the projection's resolution (legacy
+ * fallback when no runtime capacity is confirmed), never a bare constant.
  */
-export type PromptActivationInjectionStatusKind = 'injectable' | 'oversized' | 'window_excluded' | 'resolution_failed' | 'route_unconfirmed';
+export type PromptActivationInjectionStatusKind = 'injectable' | 'oversized' | 'model_dependent' | 'window_excluded' | 'resolution_failed' | 'route_unconfirmed';
 export interface PromptActivationInjectionStatus {
     activationId: string;
     principleId?: string;
     status: PromptActivationInjectionStatusKind;
-    /** Present for injectable/window_excluded/oversized under a confirmed route. */
+    /**
+     * Present for injectable/window_excluded/oversized/model_dependent under a
+     * confirmed route. For model_dependent rows it keeps the POSITIVE window
+     * fact: true = the entry fits THIS surface's (usually fallback) projection
+     * window, but still exceeds the measured floor — a smaller-context runtime
+     * model would exclude it.
+     */
     inCurrentWindow?: boolean;
     /** Present when the single-item cost was computable. */
     costChars?: number;
     budget?: number;
     budgetScope?: PromptInjectionBudgetScope;
     route?: PromptInjectionRouteName;
-    /** Present for resolution_failed / route_unconfirmed (structured reason). */
+    /** Present for resolution_failed / route_unconfirmed / model_dependent (structured reason). */
     reason?: string;
-    /** Present for route_unconfirmed: per-host single-item fit facts. */
+    /** Present for route_unconfirmed: per-host single-item tier fit facts. */
     perHostFits?: readonly {
         hostKind: PromptInjectionTargetHost;
-        fits: boolean;
+        tierFit: PromptBudgetTierFit;
     }[];
 }
 export interface PromptActivationInjectionStatusReport {

package/dist/prompt-injection-status.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { RUNTIME_V2_PRINCIPLE_BUDGET, SqliteActivationStateStore, SqliteConnection, SqlitePIArtifactStore, computeFeatureFlagsFromConfig, filterPromptActivations, resolvePrincipleFromArtifact, } from '@principles/core/runtime-v2';
+import { PROMPT_BUDGET_MAX_CHARS, PROMPT_BUDGET_MIN_CHARS, SqliteActivationStateStore, SqliteConnection, SqlitePIArtifactStore, classifySingleItemBudgetTier, computeFeatureFlagsFromConfig, filterPromptActivations, resolvePrincipleFromArtifact, } from '@principles/core/runtime-v2';
 import { loadPdConfigForPlugin } from './pd-config.js';
 import { computePromptSingleItemFit } from './prompt-activation-deliverability.js';
 import { PROMPT_INJECTION_TARGET_HOSTS, buildLivePromptInjectionProjection, promptRouteForHost, resolvePromptInjectionRouteDecision, } from './prompt-injection-projection.js';
@@ -86,12 +86,12 @@ export async function readPromptActivationInjectionStatuses(input) {
             }
             const perHostFits = PROMPT_INJECTION_TARGET_HOSTS.map((hostKind) => {
                 const hostRoute = promptRouteForHost(hostKind, route.flagEnabled);
-                const { fits } = computePromptSingleItemFit({
+                const { costChars } = computePromptSingleItemFit({
                     principle: { principleId: row.principleId, text: row.text, artifactId: '', activationId: row.activationId },
                     route: hostRoute,
                     selfReportEnabled,
                 });
-                return { hostKind, fits };
+                return { hostKind, tierFit: classifySingleItemBudgetTier(costChars) };
             });
             return {
                 activationId: row.activationId,
@@ -116,20 +116,43 @@ export async function readPromptActivationInjectionStatuses(input) {
             principle: { principleId: row.principleId, text: row.text, artifactId: '', activationId: row.activationId },
             route: projection.route,
             selfReportEnabled,
+            budget: projection.budget,
         });
         const inCurrentWindow = projection.injectedActivationIds.includes(row.activationId);
         const budgetScope = projection.budgetScope;
-        if (!fits) {
+        const serialization = projection.route === 'shared_render' ? 'full directive render' : 'list entry';
+        // Tier verdict FIRST (SPEC §6.3): the projection budget on this surface
+        // is usually the fixed fallback (2000) — the console holds no runtime
+        // model facts. An entry in (MIN, fallback] fits THAT estimate and may
+        // even sit in the current window, but it exceeds the measured floor, so
+        // on a 32K/64K model (budget = floor) it would NOT inject. Reporting it
+        // as an unconditional `injectable` would contradict the approval-time
+        // `model_dependent` verdict for the very same artifact.
+        const tierFit = classifySingleItemBudgetTier(costChars);
+        if (tierFit === 'exceeds_max_tier') {
             return {
                 activationId: row.activationId,
                 principleId: row.principleId,
                 status: 'oversized',
                 inCurrentWindow: false,
                 costChars,
-                budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+                budget: projection.budget,
                 budgetScope,
                 route: projection.route,
-                reason: `single_item_exceeds_budget: this principle's own entry is ${costChars} chars > ${RUNTIME_V2_PRINCIPLE_BUDGET} under the ${projection.route === 'shared_render' ? 'full directive render' : 'list entry'} serialization`,
+                reason: `single_item_exceeds_budget: this principle's own entry is ${costChars} chars > the ${PROMPT_BUDGET_MAX_CHARS}-char maximum supported budget under the ${serialization} serialization`,
+            };
+        }
+        if (tierFit === 'model_dependent') {
+            return {
+                activationId: row.activationId,
+                principleId: row.principleId,
+                status: 'model_dependent',
+                inCurrentWindow,
+                costChars,
+                budget: projection.budget,
+                budgetScope,
+                route: projection.route,
+                reason: `model_dependent_capacity: this principle's own entry is ${costChars} chars — above the ${PROMPT_BUDGET_MIN_CHARS}-char measured floor, so smaller-context models exclude it${fits ? ' even though it fits this surface\'s fallback-budget estimate' : ''}; injection depends on the runtime model`,
             };
         }
         return {
@@ -138,7 +161,7 @@ export async function readPromptActivationInjectionStatuses(input) {
             status: inCurrentWindow ? 'injectable' : 'window_excluded',
             inCurrentWindow,
             costChars,
-            budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+            budget: projection.budget,
             budgetScope,
             route: projection.route,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "Shared host-neutral orchestration for Principles Disciple MVP-Core hook paths.",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,7 @@
     "lint": "eslint \"src/**/*.ts\""
   },
   "dependencies": {
-    "@principles/core": "^1.294.1",
+    "@principles/core": "^1.295.0",
     "@principles/install-layout": "^0.4.0",
     "better-sqlite3": "^13.0.3",
     "js-yaml": "^5.4.3"