create-principles-disciple 1.145.12 → 1.145.15

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
-  "productVersion": "2.3.8",
-  "sourceCommit": "0062c218a3ccffcfc3c1b79783bb147dff353648"
+  "productVersion": "2.3.9",
+  "sourceCommit": "58c7642a470bddb80030ccd2c7fc9d583675107c"
 }

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.5.9",
+  "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,

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'));
 }
@@ -302,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
@@ -340,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
@@ -355,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

@@ -74,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';
@@ -371,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: {
@@ -390,17 +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,
-                        })),
-                        ...(reference?.budgetFallbackReason !== undefined ? { budgetFallbackReason: reference.budgetFallbackReason } : {}),
+                        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,
@@ -418,14 +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 — the
-                    // console holds no runtime model facts, so this is the fixed-budget
-                    // view by construction; the UI must label it as such rather than
-                    // presenting it as a model-accurate forecast.
+                    // 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;

package/console/dist/shared/prompt-injection-contract.d.ts

@@ -15,11 +15,43 @@
 export type PromptInjectionTargetHostName = 'openclaw' | 'codex' | 'workbuddy';
 export type PromptInjectionRouteName = 'legacy_trim' | 'shared_render';
 export type PromptInjectionBudgetScopeName = 'selected_lines' | 'full_directive_context';
+export type PromptBudgetCapacitySourceWire = 'host_effective_window' | 'pi_catalog_exact' | 'legacy_fallback';
+export type PromptBudgetCapacityStatusWire = 'confirmed' | 'unknown';
+/**
+ * Bounded machine-readable fallback reason. Closed set mirroring the core
+ * `PromptBudgetFallbackReason` plus the console-side observation code
+ * `runtime_budget_observation_stale` (PRI-1017: a runtime observation exists
+ * but is too old to be presented as the current budget). Never free-form
+ * detail or user content.
+ */
+export type PromptBudgetFallbackReasonWire = 'host_capacity_absent' | 'host_capacity_source_untrusted' | 'host_capacity_invalid_value' | 'catalog_unavailable' | 'model_identity_absent' | 'catalog_no_exact_match' | 'catalog_no_match_for_model_id' | 'catalog_ambiguous_model_id' | 'catalog_provider_absent' | 'catalog_metadata_invalid' | 'runtime_budget_observation_stale';
 export interface PromptInjectionPerHostForecast {
     hostKind: PromptInjectionTargetHostName;
     route: PromptInjectionRouteName;
     usedChars: number;
     truncated: boolean;
+    /**
+     * PRI-1017: the budget THIS host's forecast ran under — per-host forecasts
+     * no longer share one headline budget (each host carries its own runtime
+     * budget observation or its own honest fallback).
+     */
+    budget?: number;
+    /** Provenance of this host's `budget` (absent = legacy fixed view). */
+    budgetCapacitySource?: PromptBudgetCapacitySourceWire;
+    /** confirmed = a real window fact; unknown = fixed fallback for this host. */
+    budgetCapacityStatus?: PromptBudgetCapacityStatusWire;
+    /**
+     * PRI-1017: ISO timestamp of the runtime budget observation this host's
+     * budget came from (absent = no observation; the fixed fallback applies).
+     * A PAST fact — the UI labels it as the most recent observation, never as
+     * a live confirmation.
+     */
+    budgetObservedAt?: string;
+    /**
+     * PRI-1017: this host's OWN fallback reason. Per-host so one host's
+     * missing capacity is never attributed to another host.
+     */
+    budgetFallbackReason?: PromptBudgetFallbackReasonWire;
 }
 /**
  * PD_PROMPT_CAPACITY_V1 R-A3: per-live-prompt-activation injection status on
@@ -60,6 +92,19 @@ export interface PromptInjectionRouteSummaryWire {
     nextAction?: string;
     /** Present when no status could be computed at all (fail-loud degradation). */
     globalReason?: string;
+    /**
+     * PRI-1017: ISO timestamp of the runtime budget observation the per-row
+     * `budget` figures were computed under (absent = fixed fallback). A PAST
+     * fact — label it as the most recent observation, never as live.
+     */
+    budgetObservedAt?: string;
+    /** PRI-1017: provenance of the budget basis behind the per-row figures. */
+    budgetCapacitySource?: PromptBudgetCapacitySourceWire;
+    budgetCapacityStatus?: PromptBudgetCapacityStatusWire;
+    /** Present only when the budget basis was confirmed from a real window. */
+    budgetContextWindowTokens?: number;
+    /** Present only when the rows were measured under the fixed fallback. */
+    budgetFallbackReason?: PromptBudgetFallbackReasonWire;
 }
 export interface PromptInjectionBudgetStatus {
     /** Hard char cap of the prompt injection surface (e.g. 2000). */
@@ -114,6 +159,15 @@ export interface PromptInjectionBudgetStatus {
     nextAction?: string;
     /** Present when capacityStatus === 'unconfirmed': per-host forecasts. */
     perHost?: PromptInjectionPerHostForecast[];
+    /**
+     * PRI-1017: ISO timestamp of the runtime budget OBSERVATION `budget` and
+     * the provenance fields came from (absent = no usable observation; the
+     * numbers are the console's own fixed-fallback projection). The console
+     * holds no live host facts: an observation is the budget the LAST real
+     * injection ran under, and the UI must say so — never present it as a
+     * live confirmation.
+     */
+    budgetObservedAt?: string;
     /**
      * SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001 §7: provenance of `budget` — the
      * same resolution the real injection runs. `legacy_fallback` + `unknown`
@@ -122,15 +176,14 @@ export interface PromptInjectionBudgetStatus {
      * model-accurate forecast. Absent behaves as the legacy fixed view
      * (pre-SPEC payload compat).
      */
-    budgetCapacitySource?: 'host_effective_window' | 'pi_catalog_exact' | 'legacy_fallback';
+    budgetCapacitySource?: PromptBudgetCapacitySourceWire;
     /** confirmed = a real context window was resolved; unknown = fixed-budget fallback. */
-    budgetCapacityStatus?: 'confirmed' | 'unknown';
+    budgetCapacityStatus?: PromptBudgetCapacityStatusWire;
     /** The context window the budget was derived from; present only when confirmed. */
     budgetContextWindowTokens?: number;
     /**
      * SPEC §7 v0.2: bounded machine-readable reason — present only when
-     * budgetCapacityStatus is 'unknown'. Closed set mirroring the core
-     * `PromptBudgetFallbackReason`; never free-form detail or user content.
+     * budgetCapacityStatus is 'unknown'. See `PromptBudgetFallbackReasonWire`.
      */
-    budgetFallbackReason?: 'host_capacity_absent' | 'host_capacity_source_untrusted' | 'host_capacity_invalid_value' | 'catalog_unavailable' | 'model_identity_absent' | 'catalog_no_exact_match' | 'catalog_no_match_for_model_id' | 'catalog_ambiguous_model_id' | 'catalog_provider_absent' | 'catalog_metadata_invalid';
+    budgetFallbackReason?: PromptBudgetFallbackReasonWire;
 }

package/console/dist/ui/i18n/en.json

@@ -100,13 +100,35 @@
             "promptCapacityUnconfirmed": "Host capacity unconfirmed: the applicable hosts of this workspace take different injection routes; the numbers below are not bound to a specific host.",
             "promptCapacitySharedRoute": "shared injection (billed on the full injected block)",
             "promptCapacityListRoute": "list injection (billed on the selected lines)",
-            "promptCapacityPerHostEntry": "{{host}}: {{billing}} — {{used}}/{{budget}} chars{{full}}",
+            "promptCapacityPerHostEntry": "{{host}}: {{billing}} — {{used}}/{{budget}} chars{{full}}{{observed}}",
             "promptCapacityPerHostFull": " (full)",
+            "promptCapacityPerHostObserved": " (budget from this host's most recent runtime observation at {{observedAt}})",
             "promptCapacityViewAsHost": "View as {{host}}",
             "promptCapacityClearHost": "Clear selection",
             "promptScopeShared": "Forecast window (shared route, billed on the full injected block, unit=chars)",
             "promptScopeList": "Forecast window (list route, billed on the selected lines{{full}}, unit=chars)",
             "promptScopeFullRender": "; full injected block ≈ {{count}} chars",
+            "promptBudgetModelAwareNote": "Budget resolved from the confirmed model context ({{window}} tokens)",
+            "promptBudgetObservedNote": "Budget from the most recent runtime observation (source {{source}}, context {{window}} tokens, observed at {{observedAt}})",
+            "promptBudgetFallbackNote": "Estimated with the fixed fallback budget (console not bound to a runtime model{{reason}})",
+            "promptBudgetFallbackObservedNote": "The runtime's most recent observation did not confirm host capacity; estimated with the fixed fallback budget ({{reason}}, observed at {{observedAt}})",
+            "promptBudgetFallbackReasonSuffix": ", reason: {{code}}",
+            "promptBudgetFallbackObservedSuffix": "; the runtime's most recent observation was at {{observedAt}}",
+            "budgetCapacitySourceHostWindow": "host effective context window",
+            "budgetCapacitySourcePiCatalog": "exact model catalog match",
+            "budgetFallbackReason": {
+                "host_capacity_absent": "the host provided no context capacity fact",
+                "host_capacity_source_untrusted": "the host capacity source is untrusted",
+                "host_capacity_invalid_value": "the host capacity value is invalid",
+                "catalog_unavailable": "the model catalog is unavailable",
+                "model_identity_absent": "model identity is missing",
+                "catalog_no_exact_match": "no exact match in the model catalog",
+                "catalog_no_match_for_model_id": "the model id is not in the model catalog",
+                "catalog_ambiguous_model_id": "the model id is ambiguous in the model catalog",
+                "catalog_provider_absent": "the provider id is missing",
+                "catalog_metadata_invalid": "the model catalog metadata is invalid",
+                "runtime_budget_observation_stale": "the runtime budget observation is stale (older than 24h; not used as the current budget)"
+            },
             "artifactUnavailableNote": "The draft artifact this approval points to is no longer in the artifact store (likely superseded by a newer revision), so its content cannot be shown. If in doubt, reject it; the raw artifact ID is shown in the replacement section's current-artifact field.",
             "unlinkedCandidateNote": "No principle name is available for this card: its lineage cannot be resolved to a principle, and no readable title could be extracted from its stored content. Judge it from the approval records below; if you cannot decide, you can reject it.",
             "approveAction": "Approve",
@@ -1031,6 +1053,8 @@
             "tagHighRisk": "High Risk",
             "tagNeverActivated": "Never Activated",
             "injectionLabel": "Injection status",
+            "budgetObservedNote": "The budget figures in the injection status come from the most recent runtime observation (source {{source}}, context {{window}} tokens, observed at {{observedAt}}), not a live confirmation.",
+            "budgetFallbackNote": "The injection status is estimated with the fixed fallback budget ({{reason}}{{observed}}).",
             "injectionInjectable": "Injectable (in current window, {{cost}}/{{budget}} chars)",
             "injectionWindowRotates": "Out of window this turn: fits alone ({{cost}}/{{budget}} chars); rotation will reach it in later turns (forecast)",
             "injectionWindowFifo": "Out of window this turn: fits alone ({{cost}}/{{budget}} chars); this route does not rotate, capacity must free up first",

package/console/dist/ui/i18n/zh-CN.json

@@ -100,13 +100,35 @@
             "promptCapacityUnconfirmed": "当前宿主容量未确认：本工作区适用的宿主会走不同的注入路由，以下数字未绑定具体宿主。",
             "promptCapacitySharedRoute": "共享注入（按完整注入块计费）",
             "promptCapacityListRoute": "列表注入（按选中行计费）",
-            "promptCapacityPerHostEntry": "{{host}}：{{billing}} — {{used}}/{{budget}} 字符{{full}}",
+            "promptCapacityPerHostEntry": "{{host}}：{{billing}} — {{used}}/{{budget}} 字符{{full}}{{observed}}",
             "promptCapacityPerHostFull": "（已满）",
+            "promptCapacityPerHostObserved": "（预算来自该宿主最近一次运行时观测，观测于 {{observedAt}}）",
             "promptCapacityViewAsHost": "按 {{host}} 查看",
             "promptCapacityClearHost": "清除选择",
             "promptScopeShared": "预测窗口（共享注入路由，按完整注入块计费，单位=字符）",
             "promptScopeList": "预测窗口（列表注入路由，按选中行计费{{full}}，单位=字符）",
             "promptScopeFullRender": "，完整注入块约 {{count}} 字符",
+            "promptBudgetModelAwareNote": "预算按已确认的模型上下文解析（{{window}} tokens）",
+            "promptBudgetObservedNote": "预算取自最近一次运行时观测（来源 {{source}}，上下文 {{window}} tokens，观测于 {{observedAt}}）",
+            "promptBudgetFallbackNote": "按固定回退预算估算（控制台未绑定运行时模型{{reason}}）",
+            "promptBudgetFallbackObservedNote": "运行时最近一次观测未确认宿主容量，预算按固定回退估算（{{reason}}，观测于 {{observedAt}}）",
+            "promptBudgetFallbackReasonSuffix": "，原因: {{code}}",
+            "promptBudgetFallbackObservedSuffix": "；运行时最近一次观测于 {{observedAt}}",
+            "budgetCapacitySourceHostWindow": "宿主有效上下文窗口",
+            "budgetCapacitySourcePiCatalog": "模型目录精确匹配",
+            "budgetFallbackReason": {
+                "host_capacity_absent": "宿主未提供上下文容量事实",
+                "host_capacity_source_untrusted": "宿主容量来源不可信",
+                "host_capacity_invalid_value": "宿主容量值无效",
+                "catalog_unavailable": "模型目录不可用",
+                "model_identity_absent": "缺少模型身份",
+                "catalog_no_exact_match": "模型目录无精确匹配",
+                "catalog_no_match_for_model_id": "模型目录中无此模型 ID",
+                "catalog_ambiguous_model_id": "模型 ID 在目录中存在歧义",
+                "catalog_provider_absent": "缺少提供商标识",
+                "catalog_metadata_invalid": "模型目录元数据无效",
+                "runtime_budget_observation_stale": "运行时预算观测已过期（超过 24 小时，不作为当前预算依据）"
+            },
             "artifactUnavailableNote": "该审批指向的草稿原件已不在工件库中（可能已被新版本取代），内容无法显示。如无法判断，可选择拒绝；原始工件编号可点「替换待审版本」后在「当前工件」一栏查看。",
             "unlinkedCandidateNote": "这张卡片没有可展示的原则名称：无法把它的血缘解析到某条原则，也没能从其存档内容里提取出可读的标题。请依据下方的审批记录判断；如无法判断，可选择拒绝。",
             "approveAction": "批准",
@@ -1031,6 +1053,8 @@
             "tagHighRisk": "高风险",
             "tagNeverActivated": "从未激活",
             "injectionLabel": "注入状态",
+            "budgetObservedNote": "注入状态中的预算数字取自最近一次运行时观测（来源 {{source}}，上下文 {{window}} tokens，观测于 {{observedAt}}），并非实时确认值。",
+            "budgetFallbackNote": "注入状态按固定回退预算估算（{{reason}}{{observed}}）。",
             "injectionInjectable": "可注入（当前窗口内，{{cost}}/{{budget}} 字符）",
             "injectionWindowRotates": "本轮未入窗口：单条可装入（{{cost}}/{{budget}} 字符），后续轮次会轮到（预测）",
             "injectionWindowFifo": "本轮未入窗口：单条可装入（{{cost}}/{{budget}} 字符），当前路由不轮转，需腾出容量才会注入",