create-principles-disciple 1.145.16 → 1.145.18

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
-  "productVersion": "2.3.9",
-  "sourceCommit": "a821a6fe469e297285c206a53f5175a6de679aa7"
+  "productVersion": "2.3.10",
+  "sourceCommit": "de6c5bd575e8135aab7bf0bc9f2d9c04e4754f7e"
 }

package/codex-adapter/dist/worker/workspace-worker.js

@@ -28,7 +28,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { computeFeatureFlagsFromConfig, createRuntimeStateHandle, createPainSignalBridge, isRetryWaitBackoffElapsed, PrincipleTreeLedgerAdapter, resolveDiagnosticianCapability, } from '@principles/core/runtime-v2';
-import { createWorkspaceBehaviorEvidencePort, loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, saveHostToolDeclaration, } from '@principles/host-runtime';
+import { createWorkspaceBehaviorEvidencePort, createCodexArtificerTrustedFactsPort, loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, saveHostToolDeclaration, } from '@principles/host-runtime';
 import { catchUpCodexIngestion } from '../ingestion/catch-up.js';
 import { CODEX_TOOL_SEMANTIC_MAPPINGS, CODEX_TOOL_SEMANTICS } from '../tool-semantics.js';
 const WORKER_OWNER = 'companion-worker';
@@ -407,6 +407,7 @@ export async function runCodexWorkspaceWorkerCycle(options) {
         logger,
         emitEvent,
         behaviorEvidence: createWorkspaceBehaviorEvidencePort(workspaceDir, CODEX_TOOL_SEMANTICS),
+        trustedFacts: createCodexArtificerTrustedFactsPort(),
         toolSemantics: CODEX_TOOL_SEMANTICS,
         // PRI-741: artificer generation gets the Codex host projection
         // (Bash/apply_patch — evidence-bound, intentionally sparse).

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "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/index.js

@@ -23,6 +23,7 @@ import { handleApprovalsGroupedRoute, disposeApprovalsGroupedModels } from './ro
 import { handleGovernanceRoute, handleGovernanceExperienceRoute, resolveOwnerConfigSnapshot, disposeGovernanceModels } from './routes/governance.js';
 import { handleOwnerDecisionsRoute } from './routes/owner-decisions.js';
 import { handleEvidenceOutcomesRoute } from './routes/evidence-outcomes.js';
+import { handleDesignGateRoute } from './routes/design-gate.js';
 import { handleOwnerDecisionInboxRoute, handleOwnerDecisionViewRoute, handleOwnerDecisionLibraryRoute, parseOwnerDecisionViewSubPath } from './routes/owner-decision.js';
 import { handleOwnerIdentityRoute } from './routes/owner-identity.js';
 import { handleEvidenceChainRoute, disposeEvidenceChainModels } from './routes/evidence-chain.js';
@@ -502,6 +503,17 @@ function handleRequest(services) {
                 }))(req, res);
                 return;
             }
+            if (urlPath.startsWith('/api/v1/governance/design-gate/')) {
+                const identity = resolveOwnerIdentity(process.env, defaultOwnerIdentityHomeDir());
+                const { ownerId, credentialId } = identity;
+                asyncHandler(() => handleDesignGateRoute(req, res, {
+                    workspaceDir: services.workspaceDir,
+                    subPath: urlPath.slice('/api/v1/governance/design-gate'.length),
+                    ownerIdentity: services.authConfig.isEnabled() && ownerId !== null && credentialId !== null
+                        ? { ownerId, credentialId } : null,
+                }))(req, res);
+                return;
+            }
             // PRI-466/477: GET/POST/PUT /api/v1/intent (+ /init, /content sub-paths)
             if (urlPath === '/api/v1/intent' || urlPath.startsWith('/api/v1/intent/')) {
                 const subPath = urlPath === '/api/v1/intent' ? '' : urlPath.slice('/api/v1/intent'.length);

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

@@ -1,5 +1,6 @@
 import { SqliteConnection, SqliteActivationStateStore, SqlitePIArtifactStore, extractPrincipleId, extractEvidenceRefs, PromotionReadinessReader, RuleHostWriter, createProductionGateDeps, SqliteActivationSafetyStore, isFeatureEnabled, RuleCodeOwnerDecisionService, collectOpenClawPromotionChecks, summarizeRuleCodeShadowEvents, buildPromotionEvidenceSnapshot, } from '@principles/core/runtime-v2';
-import { resolvePromotionHostLiveness, resolveWorkspaceHostToolSemantics, readPromptActivationInjectionStatuses, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS } from '@principles/host-runtime';
+import { resolvePromotionHostLiveness, resolveWorkspaceHostToolSemantics, readPromptActivationInjectionStatuses, operatorDeclaredBudgetResolution, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, RUNTIME_V2_EVENT_LOG_CANDIDATE_DIRS } from '@principles/host-runtime';
+import { PROMPT_BUDGET_HOST_KINDS } from '@principles/core/runtime-v2';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -332,6 +333,21 @@ export class ActivationsConsoleModel {
                     ...(targetHost !== undefined ? { targetHost } : {}),
                 });
                 const perHostBudget = new Map([...budgetFacts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
+                // PRI-1020: hosts with no fresh observation fall back to the Owner's
+                // declared basis (.pd/config.yaml promptBudget), same as the grouped
+                // surface — observation wins when present.
+                const configLoad = loadPdConfig(this.workspaceDir);
+                const declaredConfig = configLoad.ok ? configLoad.effective.config.promptBudget : undefined;
+                const declaredHosts = new Set();
+                for (const hostKind of PROMPT_BUDGET_HOST_KINDS) {
+                    if (perHostBudget.has(hostKind))
+                        continue;
+                    const declared = operatorDeclaredBudgetResolution(declaredConfig, hostKind);
+                    if (declared !== undefined) {
+                        perHostBudget.set(hostKind, declared);
+                        declaredHosts.add(hostKind);
+                    }
+                }
                 const report = await readPromptActivationInjectionStatuses({
                     workspaceDir: this.workspaceDir,
                     ...(targetHost !== undefined ? { targetHost } : {}),
@@ -342,9 +358,11 @@ export class ActivationsConsoleModel {
                 });
                 // The status report resolved the route internally; bind the observation
                 // to THAT host only. A stale observation is never presented as current.
+                // PRI-1020: nor when a declared basis actually backed the route — the
+                // stale marker would contradict the declared source label.
                 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
+                const staleObservation = decidedHost !== undefined && usedObservation === undefined && !declaredHosts.has(decidedHost)
                     ? budgetFacts.stalePerHost.get(decidedHost)
                     : undefined;
                 promptInjectionRoute = {

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

@@ -3,7 +3,8 @@ 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, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
+import { resolveWorkspaceHostToolSemantics, checkPromptArtifactDeliverabilityById, operatorDeclaredBudgetResolution, resolveLivePromptInjectionProjection, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
+import { PROMPT_BUDGET_HOST_KINDS } from '@principles/core/runtime-v2';
 const MVP_PROVEN_CHANNELS = new Set(MVP_CHANNELS);
 const EMPTY_STATS = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
 function isMissingTableError(err) {
@@ -21,7 +22,7 @@ function isActivationSuccess(activation) {
  * without its own basis lets one host's observation look like another host's
  * confirmation.
  */
-function describeBudgetBasis(hostKind, facts) {
+function describeBudgetBasis(hostKind, facts, declared) {
     const used = facts.perHost.get(hostKind);
     if (used !== undefined) {
         return used.capacityStatus === 'confirmed'
@@ -31,6 +32,11 @@ function describeBudgetBasis(hostKind, facts) {
             // budget, not a host window — say so.
             : `budget basis=runtime_observation_fallback (${hostKind}, runtime reason=${used.fallbackReason ?? 'unknown'}, observed at ${used.observedAt})`;
     }
+    // PRI-1020: the Owner's declared window backing this forecast — name it as
+    // a declaration, never as a runtime fact.
+    if (declared !== undefined) {
+        return `budget basis=operator_declared (${hostKind}, context window declared as ${declared.contextWindowTokens ?? 'unknown'} tokens in .pd/config.yaml)`;
+    }
     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)`;
@@ -327,6 +333,11 @@ export class ApprovalsConsoleModel {
     async checkPromptInjectionBudget(activationId, targetHost) {
         let resolution;
         let budgetFacts;
+        // PRI-1020: declared bases per host (Owner's promptBudget config), used
+        // when a host has no fresh runtime observation. Scoped here so the basis
+        // descriptions at the call sites below see the same facts the projection
+        // ran under.
+        let declaredBudgetByHost = new Map();
         // 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
@@ -339,6 +350,19 @@ export class ApprovalsConsoleModel {
                 ...(targetHost !== undefined ? { targetHost } : {}),
             });
             const perHostBudget = new Map([...budgetFacts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
+            // PRI-1020: no fresh observation ⇒ the Owner's declared basis, same as
+            // the grouped/activations surfaces; a fresh observation still wins.
+            const configLoad = loadPdConfig(this.workspaceDir);
+            const declaredConfig = configLoad.ok ? configLoad.effective.config.promptBudget : undefined;
+            for (const hostKind of PROMPT_BUDGET_HOST_KINDS) {
+                if (perHostBudget.has(hostKind))
+                    continue;
+                const declared = operatorDeclaredBudgetResolution(declaredConfig, hostKind);
+                if (declared !== undefined) {
+                    perHostBudget.set(hostKind, declared);
+                    declaredBudgetByHost.set(hostKind, declared);
+                }
+            }
             resolution = await resolveLivePromptInjectionProjection({
                 workspaceDir: this.workspaceDir,
                 ...(targetHost !== undefined ? { targetHost } : {}),
@@ -358,7 +382,7 @@ export class ApprovalsConsoleModel {
             // 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)'}`;
+            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, declaredBudgetByHost.get(entry.hostKind))}`).join('; ')}. nextAction=${resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)'}`;
         }
         const { projection } = resolution;
         if (projection.injectedActivationIds.includes(activationId)) {
@@ -367,7 +391,7 @@ export class ApprovalsConsoleModel {
         // 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 budgetBasisNote = decidedHost === undefined ? '' : ` ${describeBudgetBasis(decidedHost, budgetFacts, declaredBudgetByHost.get(decidedHost))}`;
         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)) {

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

@@ -1,6 +1,8 @@
 import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, RUNTIME_V2_PRINCIPLE_BUDGET, detectPromptReplacementTarget, SqliteActivationStateStore, } from '@principles/core/runtime-v2';
-import { checkPromptArtifactDeliverability, resolveLivePromptInjectionProjection, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
+import { checkPromptArtifactDeliverability, operatorDeclaredBudgetResolution, resolveLivePromptInjectionProjection, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
+import { PROMPT_BUDGET_HOST_KINDS } from '@principles/core/runtime-v2';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
+import { loadPdConfig } from '../config/pd-config-store.js';
 import { createArtifactPrincipleResolutionDeps, resolveArtifactPrincipleId, } from './artifact-principle-resolver.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -391,6 +393,23 @@ export class ApprovalsGroupedConsoleModel {
                 ...(targetHost !== undefined ? { targetHost } : {}),
             });
             const perHostBudget = new Map([...facts.perHost].map(([hostKind, observation]) => [hostKind, runtimeBudgetObservationToResolution(observation)]));
+            // PRI-1020: a host with NO fresh runtime observation falls back to the
+            // Owner's declared basis (.pd/config.yaml promptBudget) instead of the
+            // fixed 2000 — resolved through the same tier-0 policy branch the real
+            // injection uses, so forecast and injection can never disagree. A fresh
+            // observation still wins (it is what the runtime actually did last).
+            const configLoad = loadPdConfig(this.workspaceDir);
+            const declaredConfig = configLoad.ok ? configLoad.effective.config.promptBudget : undefined;
+            const declaredHosts = new Set();
+            for (const hostKind of PROMPT_BUDGET_HOST_KINDS) {
+                if (perHostBudget.has(hostKind))
+                    continue;
+                const declared = operatorDeclaredBudgetResolution(declaredConfig, hostKind);
+                if (declared !== undefined) {
+                    perHostBudget.set(hostKind, declared);
+                    declaredHosts.add(hostKind);
+                }
+            }
             const resolution = await resolveLivePromptInjectionProjection({
                 workspaceDir: this.workspaceDir,
                 ...(targetHost !== undefined ? { targetHost } : {}),
@@ -424,7 +443,13 @@ export class ApprovalsGroupedConsoleModel {
                         nextAction: resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)',
                         perHost: resolution.perHost.map((entry) => {
                             const observation = facts.perHost.get(entry.hostKind);
-                            const stale = observation === undefined ? facts.stalePerHost.get(entry.hostKind) : undefined;
+                            // PRI-1020: the stale marker explains a FALLBACK that ignored a
+                            // too-old observation; it must not contradict a declared basis
+                            // that was actually used.
+                            const declaredUsed = observation === undefined && declaredHosts.has(entry.hostKind);
+                            const stale = observation === undefined && !declaredUsed
+                                ? facts.stalePerHost.get(entry.hostKind)
+                                : undefined;
                             return {
                                 hostKind: entry.hostKind,
                                 route: entry.projection.route,
@@ -450,7 +475,8 @@ export class ApprovalsGroupedConsoleModel {
             // 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
+            const declaredHeadlineUsed = decidedHost !== undefined && usedObservation === undefined && declaredHosts.has(decidedHost);
+            const staleObservation = decidedHost !== undefined && usedObservation === undefined && !declaredHeadlineUsed
                 ? facts.stalePerHost.get(decidedHost)
                 : undefined;
             return {

package/console/dist/server/routes/design-gate.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface DesignGateRouteContext {
+    workspaceDir: string;
+    subPath: string;
+    ownerIdentity: {
+        ownerId: string;
+        credentialId: string;
+    } | null;
+}
+/** Authenticated Owner attestations; never treats a principle approval as a design decision. */
+export declare function handleDesignGateRoute(req: IncomingMessage, res: ServerResponse, ctx: DesignGateRouteContext): Promise<void>;

package/console/dist/server/routes/design-gate.js

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { createRuntimeStateHandle, SqliteDesignGateStore, DesignGateStoreError } from '@principles/core/runtime-v2';
+import { listObservedDesignGateSessions, readDesignGateSpecSnapshot } from '@principles/host-runtime';
+import { readBody } from '../utils/request.js';
+import { sendSuccess, sendError, sendBadRequest, sendMethodNotAllowed } from '../utils/response.js';
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === 'string' && value.trim().length > 0 && value.length <= 4096;
+}
+function decision(value) {
+    return value === 'approved' || value === 'not_approved' || value === 'not_required';
+}
+function scope(value) {
+    return record(value) && Object.keys(value).every(key => key === 'paths' || key === 'actions')
+        && Array.isArray(value.paths) && value.paths.length > 0 && value.paths.length <= 100
+        && value.paths.every(p => text(p) && !/[*?[\]]/.test(p) && !path.isAbsolute(p) && !p.split(/[\\/]/).includes('..'))
+        && Array.isArray(value.actions) && value.actions.length > 0 && value.actions.length <= 3
+        && value.actions.every(a => a === 'read' || a === 'write' || a === 'execute');
+}
+function closedBody(value, keys) {
+    return record(value) && Object.keys(value).every(key => keys.includes(key));
+}
+/** Authenticated Owner attestations; never treats a principle approval as a design decision. */
+export async function handleDesignGateRoute(req, res, ctx) {
+    if (!ctx.ownerIdentity) {
+        sendError(res, 403, 'owner_authentication_required', 'A verified Owner identity is required to read or change design declarations.');
+        return;
+    }
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    if (req.method === 'GET' && ctx.subPath === '/sessions') {
+        try {
+            sendSuccess(res, { sessions: listObservedDesignGateSessions(ctx.workspaceDir) });
+        }
+        catch {
+            sendError(res, 503, 'session_source_unavailable', 'Observed Codex session data is unavailable.', { nextAction: 'Run a Codex session with PD observation enabled, then refresh.' });
+        }
+        return;
+    }
+    if (req.method === 'GET' && ctx.subPath === '/declaration') {
+        const project = url.searchParams.get('projectWorkspacePath');
+        const session = url.searchParams.get('hostSessionId');
+        if (!text(project) || !text(session)) {
+            sendBadRequest(res, 'Project and native session are required.');
+            return;
+        }
+        let declaration;
+        try {
+            const handle = await createRuntimeStateHandle({ workspaceDir: ctx.workspaceDir, readonly: true, bootstrapIfMissing: false });
+            try {
+                declaration = new SqliteDesignGateStore(handle.stateManager.connection).getLatestDeclaration(project, session);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            sendError(res, 503, 'declaration_source_unavailable', 'The design declaration source could not be read.', {
+                nextAction: 'Restore or initialize the governance workspace state database, then refresh the declaration.',
+            });
+            return;
+        }
+        sendSuccess(res, { declaration });
+        return;
+    }
+    if (req.method !== 'POST') {
+        sendMethodNotAllowed(res);
+        return;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(await readBody(req));
+    }
+    catch {
+        sendBadRequest(res, 'Request body must be valid JSON.');
+        return;
+    }
+    const create = ctx.subPath === '/declarations';
+    const mutate = /^\/declarations\/([^/]+)\/(decision|revoke)$/.exec(ctx.subPath);
+    if (!create && !mutate) {
+        sendError(res, 404, 'not_found', 'Unknown design declaration operation.');
+        return;
+    }
+    if (create) {
+        if (!closedBody(raw, ['projectWorkspacePath', 'hostSessionId', 'specPath', 'scope', 'decision'])
+            || !text(raw.projectWorkspacePath) || !text(raw.hostSessionId) || !text(raw.specPath)
+            || !scope(raw.scope) || !decision(raw.decision)) {
+            sendBadRequest(res, 'Expected an observed project/session, SPEC path, explicit paths/actions and decision; identity fields are not accepted.');
+            return;
+        }
+    }
+    else if (!closedBody(raw, mutate?.[2] === 'decision' ? ['expectedRevision', 'decision'] : ['expectedRevision'])
+        || typeof raw.expectedRevision !== 'number' || !Number.isSafeInteger(raw.expectedRevision) || raw.expectedRevision < 1
+        || (mutate?.[2] === 'decision' && !decision(raw.decision))) {
+        sendBadRequest(res, 'Expected the current revision and a valid decision.');
+        return;
+    }
+    // All request validation/source checks precede any write transaction.
+    if (!record(raw)) {
+        sendBadRequest(res, 'Invalid declaration.');
+        return;
+    }
+    try {
+        let createInput = null;
+        if (create && text(raw.projectWorkspacePath) && text(raw.hostSessionId) && text(raw.specPath) && scope(raw.scope) && decision(raw.decision)) {
+            const chosen = listObservedDesignGateSessions(ctx.workspaceDir).find(entry => entry.projectWorkspacePath === raw.projectWorkspacePath && entry.hostSessionId === raw.hostSessionId);
+            if (!chosen) {
+                sendError(res, 409, 'native_scope_unverified', 'Select a Codex session already observed by this workspace.');
+                return;
+            }
+            const snapshot = readDesignGateSpecSnapshot(chosen.projectWorkspacePath, path.resolve(chosen.projectWorkspacePath, raw.specPath));
+            createInput = { project: chosen.projectWorkspacePath, session: chosen.hostSessionId, specPath: snapshot.realPath, specDigest: snapshot.digest, scope: raw.scope, decision: raw.decision };
+        }
+        const handle = await createRuntimeStateHandle({ workspaceDir: ctx.workspaceDir, bootstrapIfMissing: false });
+        try {
+            const store = new SqliteDesignGateStore(handle.stateManager.connection);
+            const actor = ctx.ownerIdentity;
+            const decidedAt = new Date().toISOString();
+            if (createInput) {
+                sendSuccess(res, { declaration: store.createDeclaration({ sourceRef: randomUUID(), governanceWorkspacePath: path.resolve(ctx.workspaceDir), projectWorkspacePath: createInput.project, hostSessionId: createInput.session, taskRef: `codex:${createInput.session}`, specPath: createInput.specPath, specDigest: createInput.specDigest, scope: createInput.scope, decision: createInput.decision, actor, decidedAt }) });
+            }
+            else if (mutate && typeof raw.expectedRevision === 'number') {
+                const sourceRef = decodeURIComponent(mutate[1] ?? '');
+                if (mutate[2] === 'revoke')
+                    sendSuccess(res, { declaration: store.revoke({ sourceRef, expectedRevision: raw.expectedRevision, actor, decidedAt }) });
+                else if (decision(raw.decision)) {
+                    const existing = store.getDeclaration(sourceRef);
+                    if (existing) {
+                        const currentSpec = readDesignGateSpecSnapshot(existing.projectWorkspacePath, existing.specPath);
+                        if (currentSpec.digest !== existing.specDigest) {
+                            sendError(res, 409, 'design_gate_spec_changed', 'The bound SPEC changed after this declaration was recorded.', {
+                                nextAction: 'Review the current SPEC and create a new declaration before changing its decision.',
+                            });
+                            return;
+                        }
+                    }
+                    sendSuccess(res, { declaration: store.updateDecision({ sourceRef, expectedRevision: raw.expectedRevision, decision: raw.decision, actor, decidedAt }) });
+                }
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (error instanceof DesignGateStoreError) {
+            const status = error.code === 'invalid_input' ? 400 : error.code === 'not_found' ? 404 : error.code === 'corrupt_data' ? 503 : 409;
+            sendError(res, status, `design_gate_${error.code}`, error.message, { nextAction: 'Refresh the declaration before retrying; no previous record was overwritten.' });
+        }
+        else {
+            sendError(res, 503, 'design_gate_source_unavailable', 'The SPEC, observed session or declaration source could not be verified.', { nextAction: 'Check that the SPEC is a readable file inside the observed project and refresh the session list.' });
+        }
+    }
+}

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

@@ -15,7 +15,7 @@
 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 PromptBudgetCapacitySourceWire = 'operator_declared' | 'host_effective_window' | 'pi_catalog_exact' | 'legacy_fallback';
 export type PromptBudgetCapacityStatusWire = 'confirmed' | 'unknown';
 /**
  * Bounded machine-readable fallback reason. Closed set mirroring the core

package/console/dist/ui/api.d.ts

@@ -1,5 +1,6 @@
 import type { ApiResponse } from "../types.js";
 import type { OwnerDecisionsData, OwnerResolutionResultData, OwnerDecisionInboxData, OwnerDecisionLibraryData } from "./utils/validators.js";
+import type { DesignGateAction, DesignGateDecision, DesignGateDeclaration, DesignGateScope } from "@principles/core/runtime-v2/internalization/design-gate-facts";
 import type { GovernanceExperienceSnapshot, OwnerGovernanceView, OwnerDecisionViewCore } from '@principles/core/runtime-v2';
 import type { OwnerIdentityViewData, OwnerIdentityRegisterData, OwnerIdentityUnregisterData } from "./utils/validators.js";
 import type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, RecoveryResultData, FailedTaskDetailData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, UpdateRecoveryData, UpdateTransactionData, ApprovalRecordData, PrinciplesListData, CorePrinciplesData, ApprovalsGroupedData, EvidenceChainData, TrajectoryData, IntentSummaryData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, IntentInitResultData, IntentSaveResultData, IntentRawContentData, IntentVersionData, RuleCodeOwnerReviewData, RuleCodeMutationData } from "./utils/validators.js";
@@ -343,7 +344,34 @@ export interface FollowUpPayload {
     candidateId?: string;
 }
 declare function dispatchFollowUp(decisionId: string, payload: FollowUpPayload): Promise<ApiResponse<FollowUpResponseData>>;
-export { request, getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchCorePrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchOwnerDecisionView, fetchOwnerDecisionInbox, fetchOwnerDecisionLibrary, fetchPrincipleTrajectory, fetchPrincipleReceipts, fetchReceiptCounts, fetchEvidenceAudit, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchGovernanceExperience, recoverFailedTask, fetchFailedTaskDetail, fetchOwnerDecisions, resolveOwnerDecision, fetchApprovalsGrouped, fetchAllActivations, disableActivation, proposePromptRevision, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyFullUpdate, fetchUpdateRecovery, fetchUpdateTransaction, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
+export interface DesignGateObservedSession {
+    projectWorkspacePath: string;
+    hostSessionId: string;
+}
+export interface DesignGateDeclarationInput {
+    projectWorkspacePath: string;
+    hostSessionId: string;
+    specPath: string;
+    scope: DesignGateScope;
+    decision: DesignGateDecision;
+}
+declare function fetchDesignGateSessions(): Promise<ApiResponse<{
+    sessions: DesignGateObservedSession[];
+}>>;
+declare function fetchDesignGateDeclaration(projectWorkspacePath: string, hostSessionId: string): Promise<ApiResponse<{
+    declaration: DesignGateDeclaration | null;
+}>>;
+declare function createDesignGateDeclaration(input: DesignGateDeclarationInput): Promise<ApiResponse<{
+    declaration: DesignGateDeclaration | null;
+}>>;
+declare function updateDesignGateDecision(sourceRef: string, expectedRevision: number, decision: DesignGateDecision): Promise<ApiResponse<{
+    declaration: DesignGateDeclaration | null;
+}>>;
+declare function revokeDesignGateDeclaration(sourceRef: string, expectedRevision: number): Promise<ApiResponse<{
+    declaration: DesignGateDeclaration | null;
+}>>;
+export { request, getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchCorePrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchOwnerDecisionView, fetchOwnerDecisionInbox, fetchOwnerDecisionLibrary, fetchPrincipleTrajectory, fetchPrincipleReceipts, fetchReceiptCounts, fetchEvidenceAudit, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchGovernanceExperience, recoverFailedTask, fetchFailedTaskDetail, fetchOwnerDecisions, resolveOwnerDecision, fetchApprovalsGrouped, fetchAllActivations, disableActivation, proposePromptRevision, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyFullUpdate, fetchUpdateRecovery, fetchUpdateTransaction, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, fetchDesignGateSessions, fetchDesignGateDeclaration, createDesignGateDeclaration, updateDesignGateDecision, revokeDesignGateDeclaration, };
+export type { DesignGateAction, DesignGateDecision, DesignGateDeclaration, DesignGateScope };
 export type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, RecoveryResultData, ActivationsData, DisableActivationData, RuleCodeOwnerReviewData, RuleCodeMutationData, FailedTaskDetailData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, UpdateRecoveryData, ApprovalRecordData, PrinciplesListData, CorePrinciplesData, CorePrincipleData, ApprovalsGroupedData, EvidenceChainData, EvidenceChainRecordData, EvidenceChainStateData, TrajectoryData, TrajectoryStageData, IntentSummaryData, IntentSectionsData, IntentDocWarningData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, LinkCandidateFollowUpData, GuideRulehostFollowUpData, GeneratePatchProposalFollowUpData, IntentVersionEntry, IntentVersionData, } from "./utils/validators.js";
 export type { ActivationRecordData as ActivationRecord } from "./utils/validators.js";
 export type { OwnerDecisionInboxData, OwnerDecisionLibraryData } from "./utils/validators.js";

package/console/dist/ui/api.js

@@ -891,9 +891,113 @@ async function dispatchFollowUp(decisionId, payload) {
         body: JSON.stringify(payload),
     }, validateFollowUpResponse);
 }
+function isDesignGateRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateDesignGateSessions(value) {
+    if (!isDesignGateRecord(value) || !Array.isArray(value.sessions))
+        return null;
+    const sessions = [];
+    for (const entry of value.sessions) {
+        if (!isDesignGateRecord(entry)
+            || typeof entry.projectWorkspacePath !== "string" || entry.projectWorkspacePath.trim() === ""
+            || typeof entry.hostSessionId !== "string" || entry.hostSessionId.trim() === "")
+            return null;
+        sessions.push({ projectWorkspacePath: entry.projectWorkspacePath, hostSessionId: entry.hostSessionId });
+    }
+    return { sessions };
+}
+function isDesignGateAction(value) {
+    return value === "read" || value === "write" || value === "execute";
+}
+function isDesignGateDecisionValue(value) {
+    return value === "approved" || value === "not_approved" || value === "not_required";
+}
+function isNonEmptyDesignGateString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isDesignGateStringArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index) || !isNonEmptyDesignGateString(value[index]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Field-by-field mirror of the server declaration contract (rc-1 style) —
+ * the browser bundle never runtime-imports the Node-oriented core barrel, so
+ * the wire format is re-validated locally; the server remains the authority.
+ */
+function isDesignGateDeclarationValue(value) {
+    if (!isDesignGateRecord(value))
+        return false;
+    if (!Object.hasOwn(value, "sourceRef") || !isNonEmptyDesignGateString(value.sourceRef))
+        return false;
+    if (!isNonEmptyDesignGateString(value.governanceWorkspacePath))
+        return false;
+    if (!isNonEmptyDesignGateString(value.projectWorkspacePath))
+        return false;
+    if (!isNonEmptyDesignGateString(value.hostSessionId))
+        return false;
+    if (!isNonEmptyDesignGateString(value.taskRef))
+        return false;
+    if (!isNonEmptyDesignGateString(value.specPath) || !isNonEmptyDesignGateString(value.specDigest))
+        return false;
+    if (!isDesignGateRecord(value.scope))
+        return false;
+    if (!Object.hasOwn(value.scope, "paths") || !Object.hasOwn(value.scope, "actions"))
+        return false;
+    if (!isDesignGateStringArray(value.scope.paths) || value.scope.paths.length === 0)
+        return false;
+    if (!Array.isArray(value.scope.actions) || value.scope.actions.length === 0)
+        return false;
+    for (let index = 0; index < value.scope.actions.length; index += 1) {
+        if (!Object.hasOwn(value.scope.actions, index) || !isDesignGateAction(value.scope.actions[index]))
+            return false;
+    }
+    if (!isDesignGateDecisionValue(value.decision))
+        return false;
+    if (typeof value.revision !== "number" || !Number.isSafeInteger(value.revision) || value.revision < 1)
+        return false;
+    if (typeof value.revoked !== "boolean")
+        return false;
+    if (!isDesignGateRecord(value.actor)
+        || !Object.hasOwn(value.actor, "ownerId") || !Object.hasOwn(value.actor, "credentialId")
+        || !isNonEmptyDesignGateString(value.actor.ownerId) || !isNonEmptyDesignGateString(value.actor.credentialId))
+        return false;
+    if (!isNonEmptyDesignGateString(value.decidedAt))
+        return false;
+    return true;
+}
+function validateDesignGateDeclarationEnvelope(value) {
+    if (!isDesignGateRecord(value) || !Object.hasOwn(value, "declaration"))
+        return null;
+    if (value.declaration === null)
+        return { declaration: null };
+    return isDesignGateDeclarationValue(value.declaration) ? { declaration: value.declaration } : null;
+}
+const designGateBasePath = "/api/v1/governance/design-gate";
+async function fetchDesignGateSessions() {
+    return request(`${designGateBasePath}/sessions`, undefined, validateDesignGateSessions);
+}
+async function fetchDesignGateDeclaration(projectWorkspacePath, hostSessionId) {
+    const query = new URLSearchParams({ projectWorkspacePath, hostSessionId });
+    return request(`${designGateBasePath}/declaration?${query.toString()}`, undefined, validateDesignGateDeclarationEnvelope);
+}
+async function createDesignGateDeclaration(input) {
+    return request(`${designGateBasePath}/declarations`, { method: "POST", body: JSON.stringify(input) }, validateDesignGateDeclarationEnvelope);
+}
+async function updateDesignGateDecision(sourceRef, expectedRevision, decision) {
+    return request(`${designGateBasePath}/declarations/${encodeURIComponent(sourceRef)}/decision`, { method: "POST", body: JSON.stringify({ expectedRevision, decision }) }, validateDesignGateDeclarationEnvelope);
+}
+async function revokeDesignGateDeclaration(sourceRef, expectedRevision) {
+    return request(`${designGateBasePath}/declarations/${encodeURIComponent(sourceRef)}/revoke`, { method: "POST", body: JSON.stringify({ expectedRevision }) }, validateDesignGateDeclarationEnvelope);
+}
 // ── Exports ───────────────────────────────────────────────────────────────────
 export { request, 
 // auth
 getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchCorePrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchOwnerDecisionView, fetchOwnerDecisionInbox, fetchOwnerDecisionLibrary, fetchPrincipleTrajectory, fetchPrincipleReceipts, fetchReceiptCounts, fetchEvidenceAudit, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, 
 // Feedback submit ladder (Slice 3, spec §8)
-fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchGovernanceExperience, recoverFailedTask, fetchFailedTaskDetail, fetchOwnerDecisions, resolveOwnerDecision, fetchApprovalsGrouped, fetchAllActivations, disableActivation, proposePromptRevision, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyFullUpdate, fetchUpdateRecovery, fetchUpdateTransaction, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
+fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchGovernanceExperience, recoverFailedTask, fetchFailedTaskDetail, fetchOwnerDecisions, resolveOwnerDecision, fetchApprovalsGrouped, fetchAllActivations, disableActivation, proposePromptRevision, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyFullUpdate, fetchUpdateRecovery, fetchUpdateTransaction, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, fetchDesignGateSessions, fetchDesignGateDeclaration, createDesignGateDeclaration, updateDesignGateDecision, revokeDesignGateDeclaration, };