create-principles-disciple 1.145.11 → 1.145.13

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
-  "productVersion": "2.3.8",
-  "sourceCommit": "ec66d23385b88a7f36442702ea862432435aa470"
+  "productVersion": "2.3.9",
+  "sourceCommit": "6f9ce4614572e0ad439801a9d86fe398a0781752"
 }

package/codex-adapter/dist/codec/input-decoder.js

@@ -59,10 +59,15 @@ function validateCommon(raw, needsTurn) {
     const sessionId = requiredString(raw, 'session_id');
     requiredNullableString(raw, 'transcript_path');
     const workspaceDir = requiredString(raw, 'cwd');
-    requiredString(raw, 'model');
+    // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: keep the VALIDATED model identity
+    // (was: checked then discarded). It is an identity string only — never a
+    // capacity; the budget resolver turns it into a budget via the installed
+    // catalog, falling back to the fixed budget on unknown/ambiguous ids. It
+    // must not block the hook or leak into tool allow/deny decisions.
+    const modelId = requiredString(raw, 'model');
     requiredString(raw, 'permission_mode');
     const turnId = needsTurn ? requiredString(raw, 'turn_id') : undefined;
-    return { workspaceDir, sessionId, ...(turnId ? { turnId } : {}) };
+    return { base: { workspaceDir, sessionId, ...(turnId ? { turnId } : {}) }, modelId };
 }
 export function decodeCodexInput(raw) {
     if (!isRecord(raw))
@@ -71,7 +76,10 @@ export function decodeCodexInput(raw) {
     const kind = EVENT_KINDS.get(eventName);
     if (!kind)
         throw new CodexDecoderError(`unknown hook_event_name "${eventName}"`, 'Configure only PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, or Stop.');
-    const common = validateCommon(raw, kind !== 'session_start');
+    const { base, modelId } = validateCommon(raw, kind !== 'session_start');
+    // Model identity rides every event context under modelContext (budget
+    // resolution happens on the prompt path; other paths carry it harmlessly).
+    const common = { ...base, modelContext: { modelId } };
     let context;
     let rawPayload = raw;
     if (kind === 'before_tool_call' || kind === 'after_tool_call') {

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Codex CLI host adapter for Principles Disciple — implements HostAdapter interface for OpenAI Codex CLI's stdin/stdout JSON hook model (ADR-0020).",
   "type": "module",
   "main": "./dist/index.js",

package/console/dist/server/models/ActivationsConsoleModel.d.ts

@@ -127,7 +127,9 @@ export interface OwnerMutationInput {
  * that path made every activation's shadow metrics report "unavailable" in the
  * console while real evaluations accumulated unread in `.state/logs`. Readers
  * scan both candidates until the writer migrates (ERR-031: both readers derive
- * from this same list).
+ * from this same list — the single source is the host-runtime constant
+ * `RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS`, shared with the PRI-1017 budget
+ * observation reader so the two readers can never drift).
  */
 export declare const RULECODE_EVENT_LOG_CANDIDATE_DIRS: readonly string[];
 export interface CollectedRuleCodeEventEntries {

package/console/dist/server/models/ActivationsConsoleModel.js

@@ -1,5 +1,5 @@
 import { SqliteConnection, SqliteActivationStateStore, SqlitePIArtifactStore, extractPrincipleId, extractEvidenceRefs, PromotionReadinessReader, RuleHostWriter, createProductionGateDeps, SqliteActivationSafetyStore, isFeatureEnabled, RuleCodeOwnerDecisionService, collectOpenClawPromotionChecks, summarizeRuleCodeShadowEvents, buildPromotionEvidenceSnapshot, } from '@principles/core/runtime-v2';
-import { resolvePromotionHostLiveness, resolveWorkspaceHostToolSemantics, readPromptActivationInjectionStatuses } from '@principles/host-runtime';
+import { resolvePromotionHostLiveness, resolveWorkspaceHostToolSemantics, readPromptActivationInjectionStatuses, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS } from '@principles/host-runtime';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -63,9 +63,11 @@ function unavailableShadowSummary() {
  * that path made every activation's shadow metrics report "unavailable" in the
  * console while real evaluations accumulated unread in `.state/logs`. Readers
  * scan both candidates until the writer migrates (ERR-031: both readers derive
- * from this same list).
+ * from this same list — the single source is the host-runtime constant
+ * `RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS`, shared with the PRI-1017 budget
+ * observation reader so the two readers can never drift).
  */
-export const RULECODE_EVENT_LOG_CANDIDATE_DIRS = ['.pd/logs', '.state/logs'];
+export const RULECODE_EVENT_LOG_CANDIDATE_DIRS = RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS;
 /**
  * Collect rulehost telemetry entries from all candidate log directories.
  * Malformed lines are excluded individually. A directory counts as a source
@@ -318,10 +320,33 @@ export class ActivationsConsoleModel {
             // status with positive single-item evidence. Degradation is observable
             // (route summary carries the reason) and never turns a row "healthy"
             // by omission (rc-9 / AC-06).
+            // PRI-1017: the status projection runs under the workspace's most
+            // recent runtime budget OBSERVATION for the target host, so per-row
+            // `budget` figures match the budget the last real injection used —
+            // SPEC §6.1's same-budget rule for this surface too.
             let promptInjectionRoute;
             let statusByActivation;
             try {
-                const report = await readPromptActivationInjectionStatuses({ workspaceDir: this.workspaceDir, targetHost });
+                const budgetFacts = selectConsoleRuntimeBudgetFacts({
+                    workspaceDir: this.workspaceDir,
+                    ...(targetHost !== undefined ? { targetHost } : {}),
+                });
+                const perHostBudget = new Map([...budgetFacts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
+                const report = await readPromptActivationInjectionStatuses({
+                    workspaceDir: this.workspaceDir,
+                    ...(targetHost !== undefined ? { targetHost } : {}),
+                    ...(budgetFacts.selected !== undefined
+                        ? { promptBudget: runtimeBudgetObservationToResolution(budgetFacts.selected) }
+                        : {}),
+                    ...(perHostBudget.size > 0 ? { perHostPromptBudget: Object.fromEntries(perHostBudget) } : {}),
+                });
+                // The status report resolved the route internally; bind the observation
+                // to THAT host only. A stale observation is never presented as current.
+                const decidedHost = report.route.status === 'confirmed' ? report.route.hostKind : undefined;
+                const usedObservation = decidedHost !== undefined ? budgetFacts.perHost.get(decidedHost) : undefined;
+                const staleObservation = decidedHost !== undefined && usedObservation === undefined
+                    ? budgetFacts.stalePerHost.get(decidedHost)
+                    : undefined;
                 promptInjectionRoute = {
                     status: report.route.status,
                     ...(report.route.hostKind !== undefined ? { hostKind: report.route.hostKind } : {}),
@@ -330,6 +355,15 @@ export class ActivationsConsoleModel {
                     ...(report.route.unconfirmedReason !== undefined ? { unconfirmedReason: report.route.unconfirmedReason } : {}),
                     ...(report.route.nextAction !== undefined ? { nextAction: report.route.nextAction } : {}),
                     ...(report.globalReason !== undefined ? { globalReason: report.globalReason } : {}),
+                    ...(report.budgetProvenance?.capacitySource !== undefined ? { budgetCapacitySource: report.budgetProvenance.capacitySource } : {}),
+                    ...(report.budgetProvenance?.capacityStatus !== undefined ? { budgetCapacityStatus: report.budgetProvenance.capacityStatus } : {}),
+                    ...(report.budgetProvenance?.contextWindowTokens !== undefined ? { budgetContextWindowTokens: report.budgetProvenance.contextWindowTokens } : {}),
+                    ...(staleObservation !== undefined
+                        ? { budgetFallbackReason: RUNTIME_BUDGET_OBSERVATION_STALE_REASON }
+                        : report.budgetProvenance?.fallbackReason !== undefined
+                            ? { budgetFallbackReason: report.budgetProvenance.fallbackReason }
+                            : {}),
+                    ...(usedObservation !== undefined ? { budgetObservedAt: usedObservation.observedAt } : {}),
                 };
                 statusByActivation = new Map(report.statuses.map((entry) => [
                     entry.activationId,
@@ -343,7 +377,7 @@ export class ActivationsConsoleModel {
                         ...(entry.route !== undefined ? { route: entry.route } : {}),
                         ...(entry.reason !== undefined ? { reason: entry.reason } : {}),
                         ...(entry.perHostFits !== undefined
-                            ? { perHostFits: entry.perHostFits.map((fit) => ({ hostKind: fit.hostKind, fits: fit.fits })) }
+                            ? { perHostFits: entry.perHostFits.map((fit) => ({ hostKind: fit.hostKind, tierFit: fit.tierFit })) }
                             : {}),
                     },
                 ]));

package/console/dist/server/models/ApprovalsConsoleModel.d.ts

@@ -84,7 +84,7 @@ export type ApproveWithActivationResult = {
         overByChars?: number;
         perHost?: {
             hostKind: 'openclaw' | 'codex' | 'workbuddy';
-            fits: boolean;
+            tierFit: 'fits_all_tiers' | 'model_dependent' | 'exceeds_max_tier';
             costChars: number;
         }[];
     };

package/console/dist/server/models/ApprovalsConsoleModel.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, RuleHostWriter, createProductionGateDeps, ApprovalCompletionService, ApprovalQueue, mapConfidenceToLabel, isArtifactRevisionOf, detectPromptReplacementTarget, buildOwnerRevisionArtifact, PrincipleTreeLedgerAdapter, MVP_CHANNELS, } from '@principles/core/runtime-v2';
 import { resolveLedgerPrincipleId } from './principle-id-resolution.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
-import { resolveWorkspaceHostToolSemantics, checkPromptArtifactDeliverabilityById, resolveLivePromptInjectionProjection, } from '@principles/host-runtime';
+import { resolveWorkspaceHostToolSemantics, checkPromptArtifactDeliverabilityById, resolveLivePromptInjectionProjection, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
 const MVP_PROVEN_CHANNELS = new Set(MVP_CHANNELS);
 const EMPTY_STATS = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
 function isMissingTableError(err) {
@@ -14,6 +14,30 @@ function isMissingTableError(err) {
 function isActivationSuccess(activation) {
     return activation.decision === 'activated' || activation.decision === 'already_activated';
 }
+/**
+ * PRI-1017 (SPEC §6.5 rules 1/8): name the budget basis a forecast ACTUALLY
+ * ran under. Every case is spelled out — silence reads as "the console is not
+ * bound to the runtime", and on an unconfirmed route a per-host number
+ * without its own basis lets one host's observation look like another host's
+ * confirmation.
+ */
+function describeBudgetBasis(hostKind, facts) {
+    const used = facts.perHost.get(hostKind);
+    if (used !== undefined) {
+        return used.capacityStatus === 'confirmed'
+            ? `budget basis=runtime_observation (${hostKind}, observed at ${used.observedAt})`
+            // A usable observation can itself be the runtime's honest fallback (the
+            // host supplied no trusted capacity). The number is then the fixed
+            // budget, not a host window — say so.
+            : `budget basis=runtime_observation_fallback (${hostKind}, runtime reason=${used.fallbackReason ?? 'unknown'}, observed at ${used.observedAt})`;
+    }
+    const stale = facts.stalePerHost.get(hostKind);
+    if (stale !== undefined) {
+        return `budget basis=fixed_fallback (the runtime budget observation for ${hostKind} is stale — older than 24h and NOT used as the current budget)`;
+    }
+    // No observation at all: the number is the console's fixed fallback.
+    return `budget basis=fixed_fallback (no runtime budget observation for ${hostKind})`;
+}
 function stateDbExists(workspaceDir) {
     return fs.existsSync(path.join(workspaceDir, '.pd', 'state.db'));
 }
@@ -252,6 +276,13 @@ export class ApprovalsConsoleModel {
         }
         if (deliverability.status === 'deliverable')
             return undefined;
+        // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.3: model_dependent is NOT a
+        // refusal — the entry fits within the supported budget range and whether
+        // it injects depends on the runtime model. The approval proceeds; the
+        // honest uncertainty is already visible on the pre-approval badge
+        // (promptBudgetTierFit) and the activation status surface.
+        if (deliverability.status === 'model_dependent')
+            return undefined;
         if (deliverability.status === 'undeliverable') {
             return {
                 ok: false,
@@ -276,7 +307,7 @@ export class ApprovalsConsoleModel {
             capacity: {
                 category: deliverability.reason.startsWith('route_unconfirmed') ? 'route_unconfirmed' : 'content_unconfirmed',
                 ...(deliverability.perHost !== undefined
-                    ? { perHost: deliverability.perHost.map((entry) => ({ hostKind: entry.hostKind, fits: entry.fits, costChars: entry.costChars })) }
+                    ? { perHost: deliverability.perHost.map((entry) => ({ hostKind: entry.hostKind, tierFit: entry.tierFit, costChars: entry.costChars })) }
                     : {}),
             },
         };
@@ -295,30 +326,55 @@ export class ApprovalsConsoleModel {
      */
     async checkPromptInjectionBudget(activationId, targetHost) {
         let resolution;
+        let budgetFacts;
+        // PRI-1017: the post-approval forecast runs under the workspace's most
+        // recent runtime budget OBSERVATION for the target host (per-host for
+        // unconfirmed routes), so the warning describes the budget the last real
+        // injection used — SPEC §6.1's same-budget rule. The read model degrades
+        // to "no observation" on unreadable logs; a projection failure below stays
+        // a traceable warning because the activation is already committed.
         try {
+            budgetFacts = selectConsoleRuntimeBudgetFacts({
+                workspaceDir: this.workspaceDir,
+                ...(targetHost !== undefined ? { targetHost } : {}),
+            });
+            const perHostBudget = new Map([...budgetFacts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
             resolution = await resolveLivePromptInjectionProjection({
                 workspaceDir: this.workspaceDir,
-                targetHost,
+                ...(targetHost !== undefined ? { targetHost } : {}),
+                ...(budgetFacts.selected !== undefined
+                    ? { promptBudget: runtimeBudgetObservationToResolution(budgetFacts.selected) }
+                    : {}),
+                ...(perHostBudget.size > 0
+                    ? { perHostPromptBudget: Object.fromEntries(perHostBudget) }
+                    : {}),
             });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            return `injection_budget_check_failed: could not recompute the prompt injection projection (${message}); the activation is committed but its injection status is unverified. nextAction=check .pd/state.db readability and re-run pd runtime activation list`;
+            return `injection_budget_check_failed: could not recompute the prompt injection projection from the runtime budget observation (${message}); the activation is committed but its injection status is unverified. nextAction=check .pd/state.db and event log readability and re-run pd runtime activation list`;
         }
         if (resolution.status === 'unconfirmed') {
-            return `injection_capacity_unconfirmed: the activation is committed but this workspace's effective injection route cannot be confirmed (${resolution.decision.unconfirmedReason ?? 'unknown reason'}); per-host forecasts: ${resolution.perHost.map((entry) => `${entry.hostKind}=${entry.projection.route} (${entry.projection.usedChars}c${entry.projection.truncated ? ', truncated' : ''})`).join('; ')}. nextAction=${resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)'}`;
+            // Each per-host forecast ran under ITS OWN budget basis (observation,
+            // runtime fallback, stale fallback, or no observation) — the headline
+            // numbers must never imply a single host's confirmation covers them all.
+            return `injection_capacity_unconfirmed: the activation is committed but this workspace's effective injection route cannot be confirmed (${resolution.decision.unconfirmedReason ?? 'unknown reason'}); per-host forecasts: ${resolution.perHost.map((entry) => `${entry.hostKind}=${entry.projection.route} (${entry.projection.usedChars}c/${entry.projection.budget}c${entry.projection.truncated ? ', truncated' : ''}) ${describeBudgetBasis(entry.hostKind, budgetFacts)}`).join('; ')}. nextAction=${resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)'}`;
         }
         const { projection } = resolution;
         if (projection.injectedActivationIds.includes(activationId)) {
             return undefined;
         }
+        // Never let a stale observation masquerade as the current budget in the
+        // warning: name the basis the forecast actually ran under.
+        const decidedHost = resolution.decision.hostKind;
+        const budgetBasisNote = decidedHost === undefined ? '' : ` ${describeBudgetBasis(decidedHost, budgetFacts)}`;
         const projectionDetail = projection.warnings.length > 0 ? ` projection warnings: ${projection.warnings.join(' | ')}` : '';
         // AC-02/R-A3: oversized is independent of `truncated` — say WHY first.
         if (projection.oversizedActivationIds.includes(activationId)) {
             const scopeNote = projection.route === 'shared_render'
                 ? 'the full directive render of this single principle exceeds the cap'
                 : 'its own list entry exceeds the cap';
-            return `injection_oversized: the activation is committed but ${scopeNote} (${projection.budget} chars, measured in UTF-16 units on the ${projection.route} route) — it can never enter the prompt as written, regardless of rotation or free capacity. nextAction=shorten the statement via the activations page "modify to injectable version" entry, or deactivate this activation`;
+            return `injection_oversized: the activation is committed but ${scopeNote} (${projection.budget} chars, measured in UTF-16 units on the ${projection.route} route) — it can never enter the prompt as written, regardless of rotation or free capacity.${budgetBasisNote} nextAction=shorten the statement via the activations page "modify to injectable version" entry, or deactivate this activation`;
         }
         if (!projection.truncated) {
             // Not included and the budget did NOT truncate — the projection skipped
@@ -333,7 +389,7 @@ export class ApprovalsConsoleModel {
         // empty reachability set falls through to the starvation branch below.
         if (projection.productionRotates && projection.eventuallyInjectedActivationIds.includes(activationId)) {
             const window = projection.eligibleCount;
-            return `injection_budget_queued: the activation is committed but sits outside the CURRENT prompt injection window (${projection.budget}c; ${projection.injectedActivationIds.length} of ${window} eligible activations injected this round; production selection policy fair_rotation_v1). Fair rotation advances the window by one position per recorded user turn, so this principle WILL enter agent behavior within at most ${window} consecutive user turns of a continuously advancing session — deactivating older principles is NOT required. nextAction=none; verify presence via the activations page or the prompt injection telemetry`;
+            return `injection_budget_queued: the activation is committed but sits outside the CURRENT prompt injection window (${projection.budget}c; ${projection.injectedActivationIds.length} of ${window} eligible activations injected this round; production selection policy fair_rotation_v1).${budgetBasisNote} Fair rotation advances the window by one position per recorded user turn, so this principle WILL enter agent behavior within at most ${window} consecutive user turns of a continuously advancing session — deactivating older principles is NOT required. nextAction=none; verify presence via the activations page or the prompt injection telemetry`;
         }
         // PR-1894: report the PRODUCTION policy, not the policy this forecast
         // happened to run. The console holds no session round key, so its own
@@ -348,7 +404,7 @@ export class ApprovalsConsoleModel {
         const unreachableNote = projection.productionRotates
             ? ' (this forecast ran without a round key, so the window shown is the legacy FIFO prefix; the entry is unreachable because it exceeds the budget on its own, not because of its position)'
             : '';
-        return `injection_budget_excluded: the activation is committed but the prompt injection budget (${projection.budget}c) is full and this activation is not reachable under the ${policyNote}; ${projection.injectedActivationIds.length}/${projection.eligibleCount} eligible injected${unreachableNote} — this principle will NOT enter agent behavior until capacity frees up. nextAction=review the activations page and deactivate superseded principles`;
+        return `injection_budget_excluded: the activation is committed but the prompt injection budget (${projection.budget}c) is full and this activation is not reachable under the ${policyNote}; ${projection.injectedActivationIds.length}/${projection.eligibleCount} eligible injected${unreachableNote}.${budgetBasisNote} This principle will NOT enter agent behavior until capacity frees up. nextAction=review the activations page and deactivate superseded principles`;
     }
     /**
      * Bug-O L3b fix: upgrade the ledger principle linked to `artifactId` from

package/console/dist/server/models/ApprovalsGroupedConsoleModel.d.ts

@@ -11,11 +11,23 @@ export interface ApprovalGroup {
     /**
      * PR-1894: whether this candidate's own serialized prompt entry fits the
      * injection budget on its own. `false` means the entry is oversized, so fair
-     * rotation can NEVER inject it �?the pre-approval badge must not promise it
+     * rotation can NEVER inject it — the pre-approval badge must not promise it
      * will come around. Computed server-side with the production serializer
      * (the client has no access to the escaped, serialized size).
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: `true` now means "fits within the
+     * supported budget range" — see `promptBudgetTierFit` for whether that is
+     * unconditional (fits every tier) or model-dependent.
      */
     fitsPromptBudget?: boolean;
+    /**
+     * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §6.3: honest tier classification of
+     * the candidate's own serialized entry against the supported
+     * [min, max] budget range. `model_dependent` = fits only on
+     * larger-context models — the badge must qualify rotation promises, not
+     * promise unconditionally. `unconfirmed` mirrors the precheck's honest
+     * unknown.
+     */
+    promptBudgetTierFit?: 'fits_all_tiers' | 'model_dependent' | 'exceeds_max_tier' | 'unconfirmed';
     revisionReviewUnavailable?: boolean;
     revisionReview?: {
         oldStatement: string;
@@ -62,6 +74,18 @@ export declare class ApprovalsGroupedConsoleModel {
      * only: a projection failure omits the field — the approve-time precheck
      * (B1) remains the fail-loud gate (rc-9), so this must never fail the
      * grouped read.
+     *
+     * PRI-1017: the forecast now runs under the workspace's most recent
+     * RUNTIME BUDGET OBSERVATION (the budget the last real injection used,
+     * read from the existing `runtime_v2_prompt_activations_injected` events)
+     * instead of the console's own parameterless fallback — SPEC
+     * §6.1 forbids the injection and the console forecasting under different
+     * budgets. The observation is a PAST fact: `budgetObservedAt` travels with
+     * the payload so the UI labels it as such. No observation, an observation
+     * for a different host, or an observation past the freshness bound ⇒ the
+     * honest fixed-fallback projection (with `runtime_budget_observation_stale`
+     * when a stale observation exists). No second budget state is created:
+     * the events remain the single runtime record and this is a read model.
      */
     private readPromptInjectionBudgetStatus;
     dispose(): void;

package/console/dist/server/models/ApprovalsGroupedConsoleModel.js

@@ -1,5 +1,5 @@
 import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, RUNTIME_V2_PRINCIPLE_BUDGET, detectPromptReplacementTarget, SqliteActivationStateStore, } from '@principles/core/runtime-v2';
-import { checkPromptArtifactDeliverability, resolveLivePromptInjectionProjection, } from '@principles/host-runtime';
+import { checkPromptArtifactDeliverability, resolveLivePromptInjectionProjection, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
 import { createArtifactPrincipleResolutionDeps, resolveArtifactPrincipleId, } from './artifact-principle-resolver.js';
 import * as fs from 'node:fs';
@@ -104,19 +104,21 @@ function extractCandidateDescription(contentJson) {
     return null;
 }
 /**
- * PR-1894 → PD_PROMPT_CAPACITY_V1 R-A2: would this candidate's own prompt
- * entry fit the injection budget if it were the ONLY entry?
+ * PR-1894 → PD_PROMPT_CAPACITY_V1 R-A2 → SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001:
+ * classify this candidate's own prompt entry against the SUPPORTED budget
+ * range (not one fixed number — approval time cannot know the executing
+ * model).
  *
- * The judgment now comes from the ONE shared host-runtime precheck
+ * The judgment comes from the ONE shared host-runtime precheck
  * (`checkPromptArtifactDeliverability`): the REAL resolved principle id (not a
  * fixed 36-char UUID allowance — a title-derived id can only be longer), the
  * effective route's own serializer (list entry vs full directive render incl.
  * the self-report footer), and an honest `unconfirmed` verdict when the route
- * or the artifact content cannot be confirmed. `false` is also the
- * conservative answer for unconfirmed candidates — an unknown size must
+ * or the artifact content cannot be confirmed. `unconfirmed` is also the
+ * conservative answer when the precheck itself fails — an unknown size must
  * never become a rotation promise (rc-9).
  */
-async function candidateFitsPromptBudget(workspaceDir, artifact, targetHost) {
+async function candidatePromptBudgetTierFit(workspaceDir, artifact, targetHost) {
     const deliverability = await checkPromptArtifactDeliverability({
         workspaceDir,
         targetHost,
@@ -130,15 +132,31 @@ async function candidateFitsPromptBudget(workspaceDir, artifact, targetHost) {
             : null,
     });
     if (deliverability.status === 'deliverable')
-        return true;
+        return 'fits_all_tiers';
+    if (deliverability.status === 'model_dependent')
+        return 'model_dependent';
     if (deliverability.status === 'undeliverable')
-        return false;
-    // Unconfirmed: with per-host facts, only promise when EVERY applicable host
-    // can deliver; without them, do not promise at all.
+        return 'exceeds_max_tier';
+    // Route/artifact unconfirmed: aggregate the per-host tier verdicts
+    // MONOTONICALLY. The list route bills ~700 fewer chars than the shared
+    // route for the same entry (fixed wrapper delta), so "shared exceeds but
+    // list does not" is REACHABLE (e.g. a ~15300-char statement: list ≈15341
+    // = model_dependent, shared ≈16058 = exceeds). Collapsing that to
+    // exceeds_max_tier would tell an OpenClaw owner their entry can never
+    // inject when a large-window list-route host could carry it. Only when
+    // EVERY applicable host exceeds is "oversized everywhere" true; any
+    // disagreement leaves the honest model_dependent. Without per-host
+    // facts, do not promise at all.
     if (deliverability.perHost && deliverability.perHost.length > 0) {
-        return deliverability.perHost.every((entry) => entry.fits);
+        if (deliverability.perHost.every((entry) => entry.tierFit === 'exceeds_max_tier')) {
+            return 'exceeds_max_tier';
+        }
+        if (deliverability.perHost.every((entry) => entry.tierFit === 'fits_all_tiers')) {
+            return 'fits_all_tiers';
+        }
+        return 'model_dependent';
     }
-    return false;
+    return 'unconfirmed';
 }
 export class ApprovalsGroupedConsoleModel {
     workspaceDir;
@@ -231,14 +249,14 @@ export class ApprovalsGroupedConsoleModel {
                             if (!detection.ok || (detection.target !== null && !revisionReviews.has(artifact.artifactId)))
                                 revisionReviewUnavailable.add(artifact.artifactId);
                         }
-                        artifactFitsBudgetMap.set(approval.artifactId, await candidateFitsPromptBudget(this.workspaceDir, artifact, targetHost));
+                        artifactFitsBudgetMap.set(approval.artifactId, await candidatePromptBudgetTierFit(this.workspaceDir, artifact, targetHost));
                         artifactUnavailableMap.set(approval.artifactId, artifact === null);
                     }
                     catch (err) {
                         if (isMissingTableError(err)) {
                             artifactPrincipleMap.set(approval.artifactId, null);
                             artifactDescriptionMap.set(approval.artifactId, null);
-                            artifactFitsBudgetMap.set(approval.artifactId, false);
+                            artifactFitsBudgetMap.set(approval.artifactId, 'unconfirmed');
                             artifactUnavailableMap.set(approval.artifactId, true);
                         }
                         else {
@@ -302,10 +320,18 @@ export class ApprovalsGroupedConsoleModel {
                     principleTitle,
                     candidateDescription,
                     status,
-                    // PR-1894: undefined-safe �?absent when the artifact could not be
+                    // PR-1894: undefined-safe — absent when the artifact could not be
                     // read, which the UI treats as "do not promise rotation".
+                    // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: the boolean stays the
+                    // rotation-promise signal (true = within the supported budget
+                    // range); the tier fit carries the honest fits-everywhere vs
+                    // model-dependent distinction.
                     ...(firstArtifactId !== undefined && artifactFitsBudgetMap.has(firstArtifactId)
-                        ? { fitsPromptBudget: artifactFitsBudgetMap.get(firstArtifactId) === true }
+                        ? {
+                            fitsPromptBudget: artifactFitsBudgetMap.get(firstArtifactId) === 'fits_all_tiers'
+                                || artifactFitsBudgetMap.get(firstArtifactId) === 'model_dependent',
+                            promptBudgetTierFit: artifactFitsBudgetMap.get(firstArtifactId),
+                        }
                         : {}),
                     // PRI-940: absent when the pinned artifact is readable — same
                     // spread style as fitsPromptBudget so the wire contract stays
@@ -345,16 +371,48 @@ export class ApprovalsGroupedConsoleModel {
      * only: a projection failure omits the field — the approve-time precheck
      * (B1) remains the fail-loud gate (rc-9), so this must never fail the
      * grouped read.
+     *
+     * PRI-1017: the forecast now runs under the workspace's most recent
+     * RUNTIME BUDGET OBSERVATION (the budget the last real injection used,
+     * read from the existing `runtime_v2_prompt_activations_injected` events)
+     * instead of the console's own parameterless fallback — SPEC
+     * §6.1 forbids the injection and the console forecasting under different
+     * budgets. The observation is a PAST fact: `budgetObservedAt` travels with
+     * the payload so the UI labels it as such. No observation, an observation
+     * for a different host, or an observation past the freshness bound ⇒ the
+     * honest fixed-fallback projection (with `runtime_budget_observation_stale`
+     * when a stale observation exists). No second budget state is created:
+     * the events remain the single runtime record and this is a read model.
      */
     async readPromptInjectionBudgetStatus(targetHost) {
         try {
+            const facts = selectConsoleRuntimeBudgetFacts({
+                workspaceDir: this.workspaceDir,
+                ...(targetHost !== undefined ? { targetHost } : {}),
+            });
+            const perHostBudget = new Map([...facts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
             const resolution = await resolveLivePromptInjectionProjection({
                 workspaceDir: this.workspaceDir,
-                targetHost,
+                ...(targetHost !== undefined ? { targetHost } : {}),
+                ...(facts.selected !== undefined
+                    ? { promptBudget: runtimeBudgetObservationToResolution(facts.selected) }
+                    : {}),
+                ...(perHostBudget.size > 0
+                    ? { perHostPromptBudget: Object.fromEntries(perHostBudget) }
+                    : {}),
             });
             if (resolution.status === 'unconfirmed') {
                 // The numbers still come from the flag-based view so the badge can
                 // show SOMETHING, but capacityStatus marks them not authoritative.
+                // PRI-1017: each per-host forecast runs under THAT host's own
+                // observation (or its own fallback) — no host's window is smuggled
+                // into another host's number, and the headline reference is never
+                // presented as the current host's actual budget (the banner says so).
+                // The top-level numbers are a legacy REFERENCE view only (required
+                // fields for old consumers). Under `capacityStatus: 'unconfirmed'`
+                // they bind to no host, so the UI must never present them as the
+                // current host's actual budget — every host's own basis is in
+                // `perHost`, including its own fallback reason.
                 const reference = resolution.perHost[0]?.projection;
                 return {
                     promptInjection: {
@@ -364,16 +422,37 @@ export class ApprovalsGroupedConsoleModel {
                         capacityStatus: 'unconfirmed',
                         unconfirmedReason: resolution.decision.unconfirmedReason ?? 'effective injection route cannot be confirmed',
                         nextAction: resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)',
-                        perHost: resolution.perHost.map((entry) => ({
-                            hostKind: entry.hostKind,
-                            route: entry.projection.route,
-                            usedChars: entry.projection.usedChars,
-                            truncated: entry.projection.truncated,
-                        })),
+                        perHost: resolution.perHost.map((entry) => {
+                            const observation = facts.perHost.get(entry.hostKind);
+                            const stale = observation === undefined ? facts.stalePerHost.get(entry.hostKind) : undefined;
+                            return {
+                                hostKind: entry.hostKind,
+                                route: entry.projection.route,
+                                usedChars: entry.projection.usedChars,
+                                truncated: entry.projection.truncated,
+                                budget: entry.projection.budget,
+                                ...(entry.projection.budgetCapacitySource !== undefined ? { budgetCapacitySource: entry.projection.budgetCapacitySource } : {}),
+                                ...(entry.projection.budgetCapacityStatus !== undefined ? { budgetCapacityStatus: entry.projection.budgetCapacityStatus } : {}),
+                                ...(observation !== undefined ? { budgetObservedAt: observation.observedAt } : {}),
+                                ...(stale !== undefined
+                                    ? { budgetFallbackReason: RUNTIME_BUDGET_OBSERVATION_STALE_REASON }
+                                    : entry.projection.budgetFallbackReason !== undefined
+                                        ? { budgetFallbackReason: entry.projection.budgetFallbackReason }
+                                        : {}),
+                            };
+                        }),
                     },
                 };
             }
             const { projection } = resolution;
+            // Bind the observation to the host the route actually resolved to — not
+            // to a request parameter that may be absent (single-host workspace) or
+            // to whichever host happens to appear first.
+            const decidedHost = resolution.decision.hostKind;
+            const usedObservation = decidedHost !== undefined ? facts.perHost.get(decidedHost) : undefined;
+            const staleObservation = decidedHost !== undefined && usedObservation === undefined
+                ? facts.stalePerHost.get(decidedHost)
+                : undefined;
             return {
                 promptInjection: {
                     budget: projection.budget,
@@ -391,6 +470,19 @@ export class ApprovalsGroupedConsoleModel {
                     ...(projection.fullRenderChars !== undefined ? { fullRenderChars: projection.fullRenderChars } : {}),
                     oversizedActivationIds: projection.oversizedActivationIds,
                     oversizedDiagnosticTruncated: projection.oversizedDiagnosticTruncated,
+                    // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §7: budget provenance — when
+                    // a runtime budget OBSERVATION backs this forecast (PRI-1017) the
+                    // numbers are the ones the last real injection used; otherwise this
+                    // is the fixed-budget view and the UI labels it as such.
+                    ...(projection.budgetCapacitySource !== undefined ? { budgetCapacitySource: projection.budgetCapacitySource } : {}),
+                    ...(projection.budgetCapacityStatus !== undefined ? { budgetCapacityStatus: projection.budgetCapacityStatus } : {}),
+                    ...(projection.budgetContextWindowTokens != null ? { budgetContextWindowTokens: projection.budgetContextWindowTokens } : {}),
+                    ...(projection.budgetFallbackReason !== undefined ? { budgetFallbackReason: projection.budgetFallbackReason } : {}),
+                    // A stale observation is NOT a current fact: the honest reason code
+                    // replaces the generic absence code so the UI can say why the
+                    // runtime's last budget was not used.
+                    ...(staleObservation !== undefined ? { budgetFallbackReason: RUNTIME_BUDGET_OBSERVATION_STALE_REASON } : {}),
+                    ...(usedObservation !== undefined ? { budgetObservedAt: usedObservation.observedAt } : {}),
                 },
             };
         }

package/console/dist/server/routes/approvals-grouped.js

@@ -1,5 +1,6 @@
 import { ApprovalsGroupedConsoleModel } from '../models/ApprovalsGroupedConsoleModel.js';
 import { sendSuccess, sendError, sendNotFound, sendBadRequest } from '../utils/response.js';
+import { isPromptInjectionTargetHost } from '@principles/host-runtime';
 const models = new Map();
 function getModel(workspaceDir) {
     let model = models.get(workspaceDir);
@@ -17,12 +18,14 @@ export async function handleApprovalsGroupedRoute(req, res, workspaceDir) {
     // PD_PROMPT_CAPACITY_V1 R-A1: request-level target host for the capacity
     // forecast — the request-scoped selection entry when the workspace's
     // applicable hosts would take different routes. No new persisted config.
+    // The roster is the host-runtime one (openclaw|codex|workbuddy) — the
+    // focus page offers all three, so the API must accept all three.
     const url = new URL(req.url ?? '/api/v1/approvals/grouped', 'http://localhost');
     let targetHost;
     const rawHost = url.searchParams.get('host');
     if (rawHost !== null) {
-        if (rawHost !== 'openclaw' && rawHost !== 'codex') {
-            sendBadRequest(res, 'host must be one of: openclaw, codex');
+        if (!isPromptInjectionTargetHost(rawHost)) {
+            sendBadRequest(res, 'host must be one of: openclaw, codex, workbuddy');
             return;
         }
         targetHost = rawHost;