@principles/host-runtime 0.10.4 → 0.12.0

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

@@ -1,3 +1,4 @@
+import { type PromptBudgetCapacitySource, type PromptBudgetCapacityStatus, type PromptBudgetFallbackReason, type PromptBudgetResolution, 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,27 +10,53 @@ 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;
     }[];
 }
+/**
+ * PRI-1017: provenance of the budget the rows were measured against, copied
+ * from the SAME resolution the projection ran under. Optional on every field
+ * so a caller can degrade without inventing a capacity fact.
+ */
+export interface PromptActivationBudgetProvenance {
+    capacitySource?: PromptBudgetCapacitySource;
+    capacityStatus?: PromptBudgetCapacityStatus;
+    contextWindowTokens?: number;
+    policyVersion?: string;
+    fallbackReason?: PromptBudgetFallbackReason;
+}
 export interface PromptActivationInjectionStatusReport {
     route: PromptInjectionRouteDecision;
     /** Empty when injection is globally unavailable (prompt flag off / state.db missing) — see `globalReason`. */
@@ -37,8 +64,23 @@ export interface PromptActivationInjectionStatusReport {
     warnings: string[];
     /** Present when no status could be computed at all (fail-loud degradation, rc-9). */
     globalReason?: string;
+    /** Present for a confirmed route: the budget basis every row was measured under. */
+    budgetProvenance?: PromptActivationBudgetProvenance;
 }
 export declare function readPromptActivationInjectionStatuses(input: {
     workspaceDir: string;
     targetHost?: PromptInjectionTargetHost;
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.1 / PRI-1017: budget resolution
+     * the status projection must run under — console callers pass the
+     * resolution rebuilt from the workspace's most recent runtime budget
+     * observation. Absent → the honest fixed-fallback default.
+     */
+    promptBudget?: PromptBudgetResolution;
+    /**
+     * PRI-1017: per-host observations for a route confirmed by WORKSPACE FACTS
+     * (no request-level targetHost). The projection uses only the resolved
+     * host's own budget; an unidentified shared route stays on the fallback.
+     */
+    perHostPromptBudget?: Partial<Record<PromptInjectionTargetHost, PromptBudgetResolution>>;
 }): Promise<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,
@@ -103,9 +103,12 @@ export async function readPromptActivationInjectionStatuses(input) {
         });
         return { route, statuses, warnings };
     }
+    const decidedBudget = input.promptBudget
+        ?? (route.hostKind !== undefined ? input.perHostPromptBudget?.[route.hostKind] : undefined);
     const projection = await buildLivePromptInjectionProjection({
         workspaceDir: input.workspaceDir,
         targetHost: route.hostKind,
+        ...(decidedBudget !== undefined ? { promptBudget: decidedBudget } : {}),
     });
     warnings.push(...projection.warnings);
     const statuses = rows.map((row) => {
@@ -116,20 +119,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 the fixed fallback (2000) unless the caller passed a runtime budget
+        // OBSERVATION (PRI-1017) — and even then an entry in (MIN, fallback]
+        // 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,10 +164,21 @@ export async function readPromptActivationInjectionStatuses(input) {
             status: inCurrentWindow ? 'injectable' : 'window_excluded',
             inCurrentWindow,
             costChars,
-            budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+            budget: projection.budget,
             budgetScope,
             route: projection.route,
         };
     });
-    return { route, statuses, warnings };
+    return {
+        route,
+        statuses,
+        warnings,
+        budgetProvenance: {
+            ...(projection.budgetCapacitySource !== undefined ? { capacitySource: projection.budgetCapacitySource } : {}),
+            ...(projection.budgetCapacityStatus !== undefined ? { capacityStatus: projection.budgetCapacityStatus } : {}),
+            ...(typeof projection.budgetContextWindowTokens === 'number' ? { contextWindowTokens: projection.budgetContextWindowTokens } : {}),
+            ...(projection.budgetPolicyVersion !== undefined ? { policyVersion: projection.budgetPolicyVersion } : {}),
+            ...(projection.budgetFallbackReason !== undefined ? { fallbackReason: projection.budgetFallbackReason } : {}),
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.10.4",
+  "version": "0.12.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"