@principles/host-runtime 0.10.3 → 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/governance-signal-admission.d.ts

@@ -144,12 +144,23 @@ export type AdmitGovernanceSignalsResult = {
     ok: true;
     outcomes: readonly GovernanceAdmissionOutcome[];
 } | Degradation;
+/** Public generic intake stays Codex + explicit WorkBuddy only. */
+export declare function admitGovernanceSignals(input: AdmitGovernanceSignalsInput): AdmitGovernanceSignalsResult;
+/** Pure check: no DB, no filesystem, no classifier, no historical transcript. */
+export declare function assessWorkbuddyLiveKeyword(text: string, sessionId: string): {
+    matched: boolean;
+    reason: 'matched' | 'not_a_signal' | 'prompt_too_large';
+};
 /**
- * Admit governance signal candidates. Each candidate commits in its own
- * trajectory.db transaction (marker + pain row + quota together), so one
- * failing candidate never rolls back another's admission.
+ * Narrow native event gateway: validate true current user origin and flags.
+ * The ordinary generic admission API cannot bypass this WorkBuddy gate.
  */
-export declare function admitGovernanceSignals(input: AdmitGovernanceSignalsInput): AdmitGovernanceSignalsResult;
+export declare function admitTrustedWorkbuddyLiveCorrection(input: {
+    workspaceDir: string;
+    rawEvent: unknown;
+    now?: Date;
+    databaseFactory?: ObservationDatabaseFactory;
+}): AdmitGovernanceSignalsResult;
 export interface EnsureGovernanceTaskInput {
     readonly workspaceDir: string;
     readonly logicalObservationKey: string;

package/dist/governance-signal-admission.js

@@ -34,7 +34,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { collectSync, CORRECTION_SEED_KEYWORDS, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, PainToPrincipleService, PrincipleTreeLedgerAdapter, RuntimeStateManager, createDiagnosticianTaskId, disposePainSignalBridgesForWorkspace, sanitizeString, boundCorrectionEvidenceText, MAX_EVIDENCE_VALUE_CHARS, } from '@principles/core/runtime-v2';
+import { collectSync, computeFeatureFlagsFromConfig, CORRECTION_SEED_KEYWORDS, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, PainToPrincipleService, PrincipleTreeLedgerAdapter, RuntimeStateManager, createDiagnosticianTaskId, disposePainSignalBridgesForWorkspace, sanitizeString, boundCorrectionEvidenceText, MAX_EVIDENCE_VALUE_CHARS, } from '@principles/core/runtime-v2';
 import { deriveProductionCorrectionPainIdentity, deriveProductionToolPainIdentity, hasProductionPainSchema, PRODUCTION_WRITE_TOOLS, } from './production-pain-evidence.js';
 import { promoteGovernanceEvidence, ensureGovernanceSchema } from './governance-observation-store.js';
 import { loadPdConfigForPlugin } from './pd-config.js';
@@ -432,7 +432,8 @@ function toolFailureTaskPayload(fields) {
     };
     return JSON.stringify(payload);
 }
-function taskSubmissionPayload(candidate, workspaceDir, reason) {
+function taskSubmissionPayload(candidate, workspaceDir, details) {
+    const { reason, canonicalPainId } = details;
     if (candidate.kind === 'user_correction') {
         // P1-1 privacy (review round 2): sanitize the FULL text before any
         // truncation — a token crossing the 200-char boundary must be redacted, not
@@ -446,9 +447,14 @@ function taskSubmissionPayload(candidate, workspaceDir, reason) {
             hostKind: candidate.hostKind,
             // WorkBuddy explicit intake has no transcript observation to promote.
             // The classified Owner statement is its input basis, not a pseudo-trace.
-            evidence: candidate.hostKind === 'workbuddy' && candidate.explicitOwnerStatement === true
-                ? []
-                : [{ sourceRef: `governance_observation:${candidate.logicalObservationKey}`, note: sanitizeString(candidate.text, workspaceDir) }],
+            evidence: candidate.hostKind === 'workbuddy'
+                ? candidate.explicitOwnerStatement === true ? [] : [{
+                        // WorkBuddy has no governance_observation, anchor to the canonical
+                        // Pain persisted in this same trajectory.db transaction.
+                        sourceRef: 'pain_event:' + (canonicalPainId ?? ''),
+                        note: sanitizeString(candidate.text, workspaceDir),
+                    }]
+                : [{ sourceRef: 'governance_observation:' + candidate.logicalObservationKey, note: sanitizeString(candidate.text, workspaceDir) }],
             // SPEC-CODEX-PAIN-CLOSURE-001 CR-02 (merged from main): an explicit
             // Owner statement rides as classified correction evidence — never
             // summarized by an AI, never inside evidence[] pseudo-trace entries.
@@ -544,7 +550,7 @@ function admitCorrection({ db, candidate, workspaceDir, now, nowIso, keywordStor
                 // detection, so `detection` is optional — no ruleVersion exists for them.
                 ruleVersion: detection?.ruleVersion ?? null,
                 reason,
-                payloadJson: taskSubmissionPayload(candidate, workspaceDir, reason),
+                payloadJson: taskSubmissionPayload(candidate, workspaceDir, { reason, canonicalPainId: painId }),
                 nowIso,
             });
         })();
@@ -637,7 +643,7 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
                 canonicalPainId: painId,
                 ruleVersion: null,
                 reason: sanitizeString(reason, workspaceDir),
-                payloadJson: taskSubmissionPayload(candidate, workspaceDir, reason),
+                payloadJson: taskSubmissionPayload(candidate, workspaceDir, { reason }),
                 nowIso,
             });
         }
@@ -650,8 +656,8 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
     }
     return { disposition: 'admitted', kind: 'tool_failure', logicalObservationKey: candidate.logicalObservationKey, canonicalPainId: painId, duplicate, ruleVersion: null };
 }
-function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDegradation }) {
-    if (candidate.hostKind !== 'codex' && !(candidate.hostKind === 'workbuddy' && candidate.kind === 'user_correction' && candidate.explicitOwnerStatement === true)) {
+function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDegradation, trustedWorkbuddyLive }) {
+    if (candidate.hostKind !== 'codex' && !(candidate.hostKind === 'workbuddy' && candidate.kind === 'user_correction' && (candidate.explicitOwnerStatement === true || trustedWorkbuddyLive === true))) {
         return { ok: false, reason: 'unsupported_host_kind', nextAction: 'governance signal admission accepts Codex observations or explicit WorkBuddy Owner statements' };
     }
     const marker = db.prepare('SELECT * FROM governance_signal_admissions WHERE logical_observation_key = ?').get(candidate.logicalObservationKey);
@@ -676,7 +682,7 @@ function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDe
  * trajectory.db transaction (marker + pain row + quota together), so one
  * failing candidate never rolls back another's admission.
  */
-export function admitGovernanceSignals(input) {
+function admitGovernanceSignalsInternal(input, trustedWorkbuddyLive = false) {
     const opened = openAdmissionStore(input.workspaceDir, input.databaseFactory);
     if (!('db' in opened))
         return opened;
@@ -691,7 +697,7 @@ export function admitGovernanceSignals(input) {
     const outcomes = [];
     try {
         for (const candidate of input.candidates) {
-            outcomes.push(admitOne({ db, candidate, workspaceDir, now, nowIso, ...(input.keywordStore ? { keywordStore: input.keywordStore } : {}), ...(input.onDegradation ? { onDegradation: input.onDegradation } : {}) }));
+            outcomes.push(admitOne({ db, candidate, workspaceDir, now, nowIso, ...(input.keywordStore ? { keywordStore: input.keywordStore } : {}), ...(input.onDegradation ? { onDegradation: input.onDegradation } : {}), trustedWorkbuddyLive }));
         }
         return { ok: true, outcomes };
     }
@@ -703,6 +709,87 @@ export function admitGovernanceSignals(input) {
         close();
     }
 }
+/** Public generic intake stays Codex + explicit WorkBuddy only. */
+export function admitGovernanceSignals(input) {
+    return admitGovernanceSignalsInternal(input);
+}
+/** P0: a four-term projection of existing canonical high-precision seeds. */
+const WORKBUDDY_AUTO_TERMS = new Set(['这是错的', '不要自作主张', '不应该这么做', '又搞错']);
+const WORKBUDDY_MAX_PROMPT_BYTES = 16 * 1024;
+function workbuddyP0KeywordStore() {
+    const seed = buildSharedSeedKeywordStore();
+    const terms = {};
+    for (const [term, def] of Object.entries(seed.terms)) {
+        if (WORKBUDDY_AUTO_TERMS.has(term) && def.category === 'correction' && def.precision === 'high') {
+            terms[term] = def;
+        }
+    }
+    return { version: seed.version, terms };
+}
+/** Pure check: no DB, no filesystem, no classifier, no historical transcript. */
+export function assessWorkbuddyLiveKeyword(text, sessionId) {
+    if (Buffer.byteLength(text, 'utf8') > WORKBUDDY_MAX_PROMPT_BYTES) {
+        return { matched: false, reason: 'prompt_too_large' };
+    }
+    const store = workbuddyP0KeywordStore();
+    // Prefer precision to recall: reject quoted/embedded/reported phrases.
+    if (!Object.keys(store.terms).some(term => text.trimStart().toLowerCase().startsWith(term.toLowerCase()))) {
+        return { matched: false, reason: 'not_a_signal' };
+    }
+    const out = collectSync(text, sessionId, store, SYNC_DETECTION_CONFIG, new Date().toISOString());
+    const matched = out.isSignal && out.strength === 'STRONG' &&
+        out.type === 'correction' && out.matchedPrecision === 'high';
+    return { matched, reason: matched ? 'matched' : 'not_a_signal' };
+}
+/**
+ * Narrow native event gateway: validate true current user origin and flags.
+ * The ordinary generic admission API cannot bypass this WorkBuddy gate.
+ */
+export function admitTrustedWorkbuddyLiveCorrection(input) {
+    const raw = input.rawEvent;
+    if (!isRecord(raw) || own(raw, 'hook_event_name') !== 'UserPromptSubmit' ||
+        own(raw, 'is_internal_continuation') !== false) {
+        return { ok: false, reason: 'native_current_user_unverified', nextAction: 'Require a real current WorkBuddy UserPromptSubmit event.' };
+    }
+    const sessionId = own(raw, 'session_id');
+    const generationId = own(raw, 'generation_id');
+    const prompt = own(raw, 'prompt');
+    if (typeof sessionId !== 'string' || !sessionId.trim() ||
+        typeof generationId !== 'string' || !generationId.trim() ||
+        typeof prompt !== 'string') {
+        return { ok: false, reason: 'native_identity_invalid', nextAction: 'Require nonblank native session_id/generation_id and prompt.' };
+    }
+    const config = loadPdConfigForPlugin(input.workspaceDir);
+    if (!config.ok)
+        return { ok: false, reason: 'workbuddy_config_invalid', nextAction: 'Repair WorkBuddy governance workspace config.' };
+    const { flags } = computeFeatureFlagsFromConfig(config.effective);
+    if (flags['host.workbuddy']?.enabled !== true || flags.workbuddy_live_keyword_pain?.enabled !== true) {
+        return { ok: false, reason: 'workbuddy_auto_disabled', nextAction: 'Explicitly enable both WorkBuddy host and live keyword Pain.' };
+    }
+    if (prompt.trimStart().startsWith('PD记录痛苦')) {
+        return { ok: false, reason: 'explicit_owner_statement_reserved', nextAction: 'Use original Owner intake; no keyword fallback.' };
+    }
+    if (!assessWorkbuddyLiveKeyword(prompt, sessionId).matched) {
+        return { ok: true, outcomes: [] };
+    }
+    const nativeIdentity = JSON.stringify(['workbuddy', sessionId, generationId]);
+    return admitGovernanceSignalsInternal({
+        workspaceDir: input.workspaceDir,
+        candidates: [{
+                kind: 'user_correction',
+                hostKind: 'workbuddy',
+                logicalObservationKey: nativeIdentity + '|user',
+                rolloutIdentity: JSON.stringify(['workbuddy', sessionId]),
+                rootSessionId: sessionId,
+                hostTurnId: nativeIdentity,
+                text: prompt,
+                observedAt: (input.now ?? new Date()).toISOString(),
+            }],
+        keywordStore: workbuddyP0KeywordStore(),
+        ...(input.now ? { now: input.now } : {}),
+        ...(input.databaseFactory ? { databaseFactory: input.databaseFactory } : {}),
+    }, true);
+}
 // ─── Diagnostician continuation (one pain → exactly one pending task) ───────
 function isGovernanceTaskPayload(value) {
     if (!isRecord(value))

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.3",
+  "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.293.5",
+    "@principles/core": "^1.295.0",
     "@principles/install-layout": "^0.4.0",
     "better-sqlite3": "^13.0.3",
     "js-yaml": "^5.4.3"