create-principles-disciple 1.141.0 → 1.142.1

package/codex-adapter/dist/pd-hook.d.ts

@@ -5,5 +5,6 @@ export interface PdHookResult {
     exitCode: number;
     stderr: string[];
 }
+export declare function annotateContextWarnings(warnings: readonly string[]): string[];
 export declare function processHookInvocation(rawStdin: string, _env?: EnvMap, cwd?: string): Promise<PdHookResult>;
 export {};

package/codex-adapter/dist/pd-hook.js

@@ -54,6 +54,26 @@ function diagnostic(reason, nextAction) {
 function errorMessage(error) {
     return error instanceof Error ? error.message.slice(0, MAX_DIAGNOSTIC) : 'unknown_error';
 }
+/**
+ * PRI-780 Codex capability declaration (structured UNSUPPORTED — suspension
+ * semantics, revised after Codex review round 2 P1): the Codex host has no
+ * runtime context provider, and the "unavailable → allow" contract is
+ * generation-time prompt discipline, NOT a runtime-enforced invariant. Handing
+ * v2 rules a truthy unavailable-posture context would let a persisted rule
+ * evaluate context-blind and DENY tool calls that were previously suspended —
+ * a silent governance behavior change. Codex therefore passes NO context
+ * provider: the shared gate skips v2 rules with its structured
+ * `rule_context_v2_unavailable` warning, and this hook annotates that warning
+ * with the explicit host-unsupported reason before it reaches Codex stderr
+ * (see annotateContextWarnings — ticket option B: 明确 unsupported + 结构化
+ * warning, never a silent skip).
+ */
+const CODEX_CONTEXT_UNSUPPORTED_NOTE = 'codex_runtime_context_unsupported: the Codex host provides no runtime context provider; v2 rules stay suspended on this host';
+export function annotateContextWarnings(warnings) {
+    return warnings.map((warning) => warning.startsWith('rule_context_v2_unavailable')
+        ? `${warning}; ${CODEX_CONTEXT_UNSUPPORTED_NOTE}`
+        : warning);
+}
 // Bounded governance-observation ingestion (Codex Governance Closure Slice
 // A) followed by the Slice B signal-admission pass (SPEC §12/§13): detection
 // → canonical pain → evidence promotion → one pending Diagnostician task.
@@ -163,8 +183,11 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
             hostKind: 'codex',
             toolSemantics: CODEX_TOOL_SEMANTICS,
             events: codexEventEmitter(path.join(resolution.workspaceDir, '.state')),
+            // PRI-780 (revised after Codex review round 2 P1): NO context provider —
+            // v2 rules stay SUSPENDED on Codex (never loaded context-blind). See
+            // annotateContextWarnings for the structured unsupported declaration.
         }).dispatch(event);
-        const stderr = [...(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...ingestionDiagnostics];
+        const stderr = [...annotateContextWarnings(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...ingestionDiagnostics];
         return { stdout: adapter.encodeOutput(result, event.kind), exitCode: 0, stderr };
     }
     catch (error) {

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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/config/pd-config-store.d.ts

@@ -86,6 +86,11 @@ export declare function loadPdConfig(workspaceDir: string): ConfigLoadResult;
  * Compute feature flags from the loaded PD config (PRI-460).
  * Works with both ok and error results (uses defaults for errors).
  * Replaces the legacy `loadWorkspaceFeatureFlags` + `buildFeedbackChannelFlags` path.
+ *
+ * On a failed load, flags whose gate fail-closes on config errors are forced
+ * disabled with an observable warning — the registry default (ON for a
+ * graduated flag) must never be displayed as enforcing when the workspace
+ * config is unreadable.
  */
 export declare function computeFlagsFromLoadResult(result: ConfigLoadResult): FeatureFlagsResult;
 export declare function getConfigSummary(workspaceDir: string): {

package/console/dist/server/config/pd-config-store.js

@@ -212,14 +212,38 @@ export function loadPdConfig(workspaceDir) {
     };
 }
 // ── Feature Flags from Config ────────────────────────────────────────────────
+/**
+ * Flags whose production gate FAILS CLOSED when the workspace config cannot
+ * be loaded: the gate cannot know the flag state, so the gated capability is
+ * suspended (OpenClaw `buildRuleContextIfEnabled` returns undefined context on
+ * config failure → v2 rules skip). Status derivation must mirror that posture
+ * or the Console would display "active" for rules that are actually not
+ * enforcing (PRI-780 review B3).
+ */
+const CONFIG_FAILURE_FAIL_CLOSED_FLAGS = new Set(['rulecode_context_v2']);
 /**
  * Compute feature flags from the loaded PD config (PRI-460).
  * Works with both ok and error results (uses defaults for errors).
  * Replaces the legacy `loadWorkspaceFeatureFlags` + `buildFeedbackChannelFlags` path.
+ *
+ * On a failed load, flags whose gate fail-closes on config errors are forced
+ * disabled with an observable warning — the registry default (ON for a
+ * graduated flag) must never be displayed as enforcing when the workspace
+ * config is unreadable.
  */
 export function computeFlagsFromLoadResult(result) {
     const effective = result.ok ? result.effective : result.defaults;
-    return computeFeatureFlagsFromConfig(effective);
+    const flags = computeFeatureFlagsFromConfig(effective);
+    if (!result.ok) {
+        for (const flagId of CONFIG_FAILURE_FAIL_CLOSED_FLAGS) {
+            const flag = flags.flags[flagId];
+            if (flag?.enabled) {
+                flags.flags[flagId] = { ...flag, enabled: false };
+                flags.warnings.push(`${flagId}: config load failed — flag displayed as disabled (fail-closed, matches the gate's config-failure suspension)`);
+            }
+        }
+    }
+    return flags;
 }
 // ── Get Redacted Summary ─────────────────────────────────────────────────────
 export function getConfigSummary(workspaceDir) {

package/console/dist/ui/api.js

@@ -1,14 +1,17 @@
+import { clearStoredToken, loadStoredToken, storeToken } from "./utils/token-storage.js";
 import { listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm, } from "./utils/signal-keywords-api.js";
 import { validateErrorResponse, validateHeaders, validateFeedbackReport, validateFeedbackDraftsList, validateFeedbackDraftEnvelope, validateFeedbackChannels, validateFeedbackSubmitResult, validateDeleteEnvelope, validateWorkspaceEntry, validateWorkspaceList, validateRemovedEnvelope, validateSyncResult, validateConfigSummary, validateConfigCatalog, validateAgentBindingUpdate, validateDefaultRuntimeUpdate, validateRuntimeProfileMutation, validateReadinessCheck, validateFeatureFlagUpdate, validateOutputLanguage, validateGovernanceQueue, validateRecoveryResult, validateFailedTaskDetail, validateOwnerDecisionsData, validateOwnerResolutionResult, validateActivations, validateDisableActivation, validateLifecycleMetrics, validateUpdateStatus, validateUpdateHistory, validateApplyUpdateResult, validateRollbackResult, validateApprovalRecordDirect, validatePrinciplesList, validateCorePrinciples, validateApprovalsGrouped, validateEvidenceChain, validateTrajectoryData, validateIntentSummary, validateIntentDecisionList, validateIntentDecisionResult, validateIntentDecisionSummary, validateFollowUpResponse, validateIntentInitResult, validateIntentSaveResult, validateIntentRawContent, validateIntentVersions, validateOwnerGovernanceView, validateGovernanceExperienceSnapshot, validateRuleCodeOwnerReview, validateRuleCodeMutation, validateOwnerIdentityView, validateOwnerIdentityRegister, validateOwnerIdentityUnregister, } from "./utils/validators.js";
 // ── Auth ──────────────────────────────────────────────────────────────────────
 function getToken() {
-    return sessionStorage.getItem("pd_token");
+    // PRI-793: localStorage-backed (with one-time migration from the legacy
+    // sessionStorage copy) so the token survives browser restarts.
+    return loadStoredToken();
 }
 function setToken(token) {
-    sessionStorage.setItem("pd_token", token);
+    storeToken(token);
 }
 function clearToken() {
-    sessionStorage.removeItem("pd_token");
+    clearStoredToken();
 }
 /**
  * True when an unauthorized response should route the UI to the login route.

package/console/dist/ui/utils/__tests__/token-storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/console/dist/ui/utils/__tests__/token-storage.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { clearStoredToken, loadStoredToken, storeToken } from "../token-storage.js";
+/** Minimal in-memory Storage double (no window dependency). */
+function fakeStorage() {
+    const map = new Map();
+    return {
+        get length() {
+            return map.size;
+        },
+        clear: () => map.clear(),
+        getItem: (k) => (map.has(k) ? map.get(k) : null),
+        key: (i) => Array.from(map.keys())[i] ?? null,
+        removeItem: (k) => void map.delete(k),
+        setItem: (k, v) => void map.set(k, v),
+    };
+}
+describe("token-storage (PRI-793)", () => {
+    it("stores into localStorage and leaves no sessionStorage copy", () => {
+        const main = fakeStorage();
+        const legacy = fakeStorage();
+        storeToken("tok-1", main, legacy);
+        expect(main.getItem("pd_token")).toBe("tok-1");
+        expect(legacy.getItem("pd_token")).toBe(null);
+    });
+    it("loads the persisted token across 'browser restarts'", () => {
+        const main = fakeStorage();
+        const legacy = fakeStorage();
+        storeToken("tok-2", main, legacy);
+        expect(loadStoredToken(main, legacy)).toBe("tok-2");
+    });
+    it("migrates a legacy sessionStorage token once, then owns it in localStorage only", () => {
+        const main = fakeStorage();
+        const legacy = fakeStorage();
+        legacy.setItem("pd_token", "legacy-tok");
+        expect(loadStoredToken(main, legacy)).toBe("legacy-tok");
+        expect(main.getItem("pd_token")).toBe("legacy-tok");
+        expect(legacy.getItem("pd_token")).toBe(null);
+    });
+    it("returns null when nothing is stored anywhere", () => {
+        expect(loadStoredToken(fakeStorage(), fakeStorage())).toBe(null);
+    });
+    it("clear removes both storage copies so a stale token cannot resurrect", () => {
+        const main = fakeStorage();
+        const legacy = fakeStorage();
+        storeToken("tok-3", main, legacy);
+        legacy.setItem("pd_token", "stale");
+        clearStoredToken(main, legacy);
+        expect(main.getItem("pd_token")).toBe(null);
+        expect(legacy.getItem("pd_token")).toBe(null);
+        expect(loadStoredToken(main, legacy)).toBe(null);
+    });
+    it("re-login overwrites the persisted token", () => {
+        const main = fakeStorage();
+        const legacy = fakeStorage();
+        storeToken("old", main, legacy);
+        storeToken("new", main, legacy);
+        expect(loadStoredToken(main, legacy)).toBe("new");
+    });
+    it("degrades gracefully when no Storage exists (non-DOM environment)", () => {
+        expect(loadStoredToken(null, null)).toBe(null);
+        expect(() => storeToken("tok", null, null)).not.toThrow();
+        expect(() => clearStoredToken(null, null)).not.toThrow();
+    });
+});

package/console/dist/ui/utils/token-storage.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Browser-side persistence for the Console login token (PRI-793).
+ *
+ * The token lives in localStorage so the Owner is not re-prompted on every
+ * browser start. sessionStorage is only a migration source: a token left
+ * there by older builds is promoted to localStorage once and then removed —
+ * localStorage is the single source of truth afterwards (P4).
+ *
+ * Clearing (logout / Settings "清除凭证") removes both keys so a stale copy
+ * can never resurrect the session.
+ *
+ * Storages are resolved from globalThis (browsers expose localStorage /
+ * sessionStorage there) and may be absent — non-DOM test environments run
+ * the same code path with null storages, where persistence degrades to
+ * "no stored token" instead of crashing. Explicit arguments override the
+ * builtins for tests.
+ */
+type TokenStorage = Storage | null | undefined;
+export declare function loadStoredToken(storage?: TokenStorage, legacy?: TokenStorage): string | null;
+export declare function storeToken(token: string, storage?: TokenStorage, legacy?: TokenStorage): void;
+export declare function clearStoredToken(storage?: TokenStorage, legacy?: TokenStorage): void;
+export {};

package/console/dist/ui/utils/token-storage.js

@@ -0,0 +1,47 @@
+/**
+ * Browser-side persistence for the Console login token (PRI-793).
+ *
+ * The token lives in localStorage so the Owner is not re-prompted on every
+ * browser start. sessionStorage is only a migration source: a token left
+ * there by older builds is promoted to localStorage once and then removed —
+ * localStorage is the single source of truth afterwards (P4).
+ *
+ * Clearing (logout / Settings "清除凭证") removes both keys so a stale copy
+ * can never resurrect the session.
+ *
+ * Storages are resolved from globalThis (browsers expose localStorage /
+ * sessionStorage there) and may be absent — non-DOM test environments run
+ * the same code path with null storages, where persistence degrades to
+ * "no stored token" instead of crashing. Explicit arguments override the
+ * builtins for tests.
+ */
+const TOKEN_KEY = "pd_token";
+function builtin(kind) {
+    const g = globalThis;
+    return (kind === "local" ? g.localStorage : g.sessionStorage) ?? null;
+}
+export function loadStoredToken(storage, legacy) {
+    const main = storage ?? builtin("local");
+    const old = legacy ?? builtin("session");
+    const current = main?.getItem(TOKEN_KEY) ?? null;
+    if (current !== null)
+        return current;
+    const legacyToken = old?.getItem(TOKEN_KEY) ?? null;
+    if (legacyToken === null)
+        return null;
+    main?.setItem(TOKEN_KEY, legacyToken);
+    old?.removeItem(TOKEN_KEY);
+    return legacyToken;
+}
+export function storeToken(token, storage, legacy) {
+    const main = storage ?? builtin("local");
+    const old = legacy ?? builtin("session");
+    main?.setItem(TOKEN_KEY, token);
+    old?.removeItem(TOKEN_KEY);
+}
+export function clearStoredToken(storage, legacy) {
+    const main = storage ?? builtin("local");
+    const old = legacy ?? builtin("session");
+    main?.removeItem(TOKEN_KEY);
+    old?.removeItem(TOKEN_KEY);
+}