@unson/brainbase-mcp 0.11.0 → 0.13.0

package/dist/local-web-host.js

@@ -10,7 +10,7 @@ import { createFoundationRevisionStore, FoundationStoreError } from './foundatio
 import { createGraphWebHttpHandler } from './graph-web-http.js';
 import { defaultJudgmentJournalRoot } from './judgment-value-proof-review.js';
 import { nodeRequestToFetch, writeFetchResponse } from './local-web-fetch-bridge.js';
-import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError, requestUrl, tokenMatches, writeHttpError, writeJson } from './local-web-security.js';
+import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError, readJsonObjectBody, requestUrl, tokenMatches, writeHttpError, writeJson } from './local-web-security.js';
 import { resolveDataDir } from './paths.js';
 import { loadPersonalOs, readPersonalOsSidecar } from './ssot.js';
 import { createValueProofReviewHttpHandler, VALUE_PROOF_REVIEW_TOKEN_HEADER } from './value-proof-review-http.js';
@@ -437,7 +437,7 @@ function worldModelError(error) {
     }
     if (error instanceof LocalWebHttpError)
         return error;
-    return new LocalWebHttpError(500, 'internal_error', 'World model read failed');
+    return new LocalWebHttpError(500, 'internal_error', 'World model request failed');
 }
 async function listReadableSidecarRecords(input) {
     try {
@@ -473,11 +473,112 @@ async function listReadableSidecarRecords(input) {
     }
     return { records, unreadable: { count, codes: [...codes] } };
 }
+const LOCAL_WEB_WORLD_MODEL_SCOPE_START = '1970-01-01T00:00:00.000Z';
+const WORLD_MODEL_VALUE_KINDS = new Set(['number', 'boolean', 'string', 'state']);
+const WORLD_MODEL_AGGREGATIONS = new Set(['none', 'sum', 'average', 'count', 'min', 'max', 'last', 'custom']);
+const WORLD_MODEL_VARIABLE_FIELDS = new Set([
+    'meaning', 'subject', 'valueKind', 'unit', 'aggregation', 'granularity', 'measurementMethod'
+]);
+const WORLD_MODEL_OBSERVATION_FIELDS = new Set(['variableRef', 'value']);
+const WORLD_MODEL_AUTHORITY_FIELDS = new Set([
+    'acl', 'scope', 'storage', 'provenance', 'authorizedUses', 'ownerId', 'readerIds', 'writerIds',
+    'principal', 'subjectId', 'recordedAt', 'occurredAt', 'period', 'id', 'revision', 'type'
+]);
+function worldModelInvalid(message) {
+    return new LocalWebHttpError(400, 'invalid_input', message);
+}
+function assertWorldModelBodyFields(body, allowed) {
+    for (const key of Object.keys(body)) {
+        if (allowed.has(key))
+            continue;
+        if (WORLD_MODEL_AUTHORITY_FIELDS.has(key)) {
+            throw new LocalWebHttpError(400, 'authority_field_in_body', `${key} is decided by the local Web host`);
+        }
+        throw worldModelInvalid(`Unknown World Model field ${key}`);
+    }
+}
+function requiredWorldModelText(body, key) {
+    const value = body[key];
+    if (typeof value !== 'string' || value.trim() === '')
+        throw worldModelInvalid(`${key} is required`);
+    return value.trim();
+}
+function worldModelVariableFromBody(body, principal) {
+    assertWorldModelBodyFields(body, WORLD_MODEL_VARIABLE_FIELDS);
+    const valueKind = requiredWorldModelText(body, 'valueKind');
+    if (!WORLD_MODEL_VALUE_KINDS.has(valueKind))
+        throw worldModelInvalid(`Unknown valueKind ${valueKind}`);
+    const aggregation = requiredWorldModelText(body, 'aggregation');
+    if (!WORLD_MODEL_AGGREGATIONS.has(aggregation))
+        throw worldModelInvalid(`Unknown aggregation ${aggregation}`);
+    const unit = body.unit === undefined ? undefined : requiredWorldModelText(body, 'unit');
+    if (valueKind === 'number' && !unit)
+        throw worldModelInvalid('unit is required for number variables');
+    return {
+        id: `web.variable.${randomBytes(10).toString('hex')}`,
+        type: 'variable',
+        revision: '1',
+        meaning: requiredWorldModelText(body, 'meaning'),
+        epistemicState: 'unverified',
+        adoptionState: 'draft',
+        authorizedUses: ['draft', 'judgment', 'evaluation'],
+        acl: { ownerId: principal, visibility: 'private', readerIds: [], writerIds: [] },
+        storage: 'ontology',
+        provenance: [{ sourceId: LOCAL_WEB_PROVENANCE_SOURCE_ID, sourceKind: 'observation', evidenceIds: [] }],
+        scope: { subjectIds: [principal], validFrom: LOCAL_WEB_WORLD_MODEL_SCOPE_START },
+        subject: requiredWorldModelText(body, 'subject'),
+        valueKind: valueKind,
+        ...(unit ? { unit } : {}),
+        aggregation: aggregation,
+        granularity: requiredWorldModelText(body, 'granularity'),
+        measurementMethod: requiredWorldModelText(body, 'measurementMethod'),
+        // The local host stamps the current date into observations; a broad owner-only
+        // validity window avoids asking the first-time user for hidden scope fields.
+    };
+}
+function worldModelReference(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw worldModelInvalid('variableRef is required');
+    const reference = value;
+    if (reference.type !== 'variable' || typeof reference.id !== 'string' || reference.id.trim() === ''
+        || typeof reference.revision !== 'string' || !/^[1-9]\d*$/u.test(reference.revision)) {
+        throw worldModelInvalid('variableRef must reference a variable revision');
+    }
+    if (Object.keys(reference).some((key) => !['id', 'type', 'revision'].includes(key))) {
+        throw worldModelInvalid('variableRef contains an unsupported field');
+    }
+    return { id: reference.id.trim(), type: 'variable', revision: reference.revision };
+}
+function worldModelObservationFromBody(body, principal, now) {
+    assertWorldModelBodyFields(body, WORLD_MODEL_OBSERVATION_FIELDS);
+    if (!Object.hasOwn(body, 'value') || body.value === null || body.value === undefined)
+        throw worldModelInvalid('value is required');
+    const value = body.value;
+    if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+        throw worldModelInvalid('value must be a string, number, or boolean');
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw worldModelInvalid('value must be a finite number');
+    }
+    const nowIso = now.toISOString();
+    const day = nowIso.slice(0, 10);
+    const observationId = `web.observation.${randomBytes(10).toString('hex')}`;
+    return {
+        id: observationId,
+        variableRef: worldModelReference(body.variableRef),
+        subjectId: principal,
+        value,
+        occurredAt: nowIso,
+        period: { from: `${day}T00:00:00.000Z`, until: `${day}T23:59:59.999Z` },
+        recordedAt: nowIso,
+        sourceRef: { sourceId: LOCAL_WEB_PROVENANCE_SOURCE_ID, sourceKind: 'observation', evidenceIds: [observationId] }
+    };
+}
 /**
- * Read-only World Model routes.  Writes (observations, corrections, model
- * adoption) are not on the Web in v1.  Without an approval reader an approved
- * adoption cannot be verified, so only the adoptions route reports
- * `approval_reference_unresolved`; the other routes stay readable.
+ * World Model routes.  Reads retain the explicit absence/partial contract;
+ * the first-user Web entry writes only a trusted Variable definition and an
+ * initial Observation. Models, adoption and corrections stay out of this
+ * focused route until their own authority and review contract exists.
  */
 export function createWorldModelReadModule(context) {
     const foundationStore = createFoundationRevisionStore({ dataDir: context.dataDir });
@@ -519,17 +620,39 @@ export function createWorldModelReadModule(context) {
                 writeJson(response, 404, { error: { code: 'not_found', message: 'Not found' } });
                 return true;
             }
-            if (request.method !== 'GET') {
-                writeJson(response, 405, { error: { code: 'method_not_allowed', message: 'The world model is read-only here' } });
-                return true;
-            }
             const graph = await readLocalGraphState(context.dataDir);
             if (graph.status !== 'ready' || !graph.ownerId) {
                 writeGraphUnavailable(response, graph, context.dataDir);
                 return true;
             }
+            const principal = { principal: graph.ownerId };
+            if (request.method === 'POST' && (resource === 'variables' || resource === 'observations')) {
+                try {
+                    const body = await readJsonObjectBody(request, LOCAL_WEB_FOUNDATION_BODY_LIMIT_BYTES);
+                    if (resource === 'variables') {
+                        const definition = worldModelVariableFromBody(body, graph.ownerId);
+                        const reference = await worldModel.createVariable(definition, principal);
+                        writeJson(response, 201, {
+                            reference: { id: reference.id, type: reference.type, revision: reference.revision },
+                            digest: reference.digest
+                        });
+                    }
+                    else {
+                        const observation = await worldModel.saveObservation(worldModelObservationFromBody(body, graph.ownerId, context.now()), principal);
+                        writeJson(response, 201, { observation });
+                    }
+                }
+                catch (error) {
+                    writeHttpError(response, worldModelError(error));
+                }
+                return true;
+            }
+            if (request.method !== 'GET') {
+                writeJson(response, 405, { error: { code: 'method_not_allowed', message: 'この入口では変数と観測値を登録できます' } });
+                return true;
+            }
             try {
-                writeJson(response, 200, await read(resource, { principal: graph.ownerId }));
+                writeJson(response, 200, await read(resource, principal));
             }
             catch (error) {
                 writeHttpError(response, worldModelError(error));
@@ -619,7 +742,9 @@ if (extensionScreens.some((screen, index) => screen?.id !== extensionIds[index]
   throw new Error('Invalid extension screen id');
 }
 const meta = (name) => document.querySelector(\`meta[name="\${name}"]\`)?.getAttribute('content') ?? '';
-const screenFromHash = () => decodeURIComponent(location.hash.replace(/^#/, '')) || undefined;
+// Keep the query portion intact; the shell parses the Graph entity query and
+// only treats the entity id as a target of the Graph screen.
+const screenFromHash = () => location.hash.replace(/^#/, '') || undefined;
 const shell = createLocalWebShell({
   root: document.getElementById('brainbase-local-web'),
   token: meta('brainbase-web-token'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -155,6 +155,10 @@
       "types": "./dist/judgment-problem-snapshot.d.ts",
       "import": "./dist/judgment-problem-snapshot.js"
     },
+    "./judgment-problem-snapshot-http": {
+      "types": "./dist/judgment-problem-snapshot-http.d.ts",
+      "import": "./dist/judgment-problem-snapshot-http.js"
+    },
     "./personal-knowledge": {
       "types": "./dist/personal-knowledge.d.ts",
       "import": "./dist/personal-knowledge.js"
@@ -348,5 +352,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "070f39f8014fbbe224bb4615ef89999aeeb8d0a5"
+  "gitHead": "c9b9adbff2dd409f77ed868d9c3939b3269f2d4f"
 }

package/ui/graph-registry-view.js

@@ -163,6 +163,7 @@ function textCell(value, fallback) {
  * @param {string} [options.token] Launch token sent with a correction.
  * @param {string} [options.tokenHeader] Header name for the token.
  * @param {boolean} [options.autoLoad=true] Runs the empty search and reads the kinds on mount.
+ * @param {string} [options.initialEntityId] Opens this exact entity after the initial Graph read.
  * @param {() => Date} [options.now] The owner's clock.
  * @param {boolean} [options.canCorrect=true] When false, no correction control is drawn anywhere
  *   (この記録を直す, 関係を加える, この関係を直す, and この画面で直せること under the kinds of
@@ -204,6 +205,7 @@ export function createGraphRegistryView({
   token,
   tokenHeader,
   autoLoad = true,
+  initialEntityId,
   now = () => new Date(),
   canCorrect = true,
   correctionScope,
@@ -617,6 +619,23 @@ export function createGraphRegistryView({
       const canFix = scope.entity(entity.type) && scope.fields(graphEntityCorrectionFields(entity.type)).length > 0;
       const relatable = newRelationOptions(entity.type).length > 0;
       const related = loaded.outgoing.length + loaded.incoming.length > 0;
+      const correctionEntries = [
+        canFix ? '「この記録を直す」' : null,
+        relatable && scope.createEdges ? '「関係を加える」' : null,
+        related && scope.edges ? '関係ごとの「この関係を直す」' : null,
+      ].filter(Boolean);
+      if (correctionEntries.length > 0) {
+        const lastEntry = correctionEntries.at(-1);
+        const entries = correctionEntries.length === 1
+          ? lastEntry
+          : `${correctionEntries.slice(0, -1).join('、')}、または${lastEntry}`;
+        children.push(workspaceRailBlock(doc, {
+          title: '訂正の流れ',
+          content: makeElement(doc, 'p', {
+            text: `誤りを見つけたときの訂正入口です。${entries}から変更案を入力します。承認待ちの提出ではなく、保存するとその場でGraphに反映され、理由と変更前後が履歴に残ります。保存後に読み直して一致を確かめ、確認できた内容は、次のMCPの search・get_context・resolve_entity で使われます。`,
+          }),
+        }));
+      }
       const actions = [
         canFix ? workspaceButton(doc, { text: 'この記録を直す', onClick: () => openCorrection('entity', () => correction.openEntity(entity, { title: 'この記録を直す' })) }) : null,
         relatable && scope.createEdges
@@ -797,7 +816,14 @@ export function createGraphRegistryView({
     },
   };
   controller.render();
-  if (autoLoad) void controller.load();
+  if (autoLoad) {
+    void controller.load().then(() => {
+      if (initialEntityId) return controller.openEntity(initialEntityId);
+      return undefined;
+    });
+  } else if (initialEntityId) {
+    void controller.openEntity(initialEntityId);
+  }
   return controller;
 }
 

package/ui/local-web-shell.js

@@ -21,6 +21,7 @@ import { createObjectiveEditorController } from './objective-editor.js';
 import { createObjectiveEditorHttpPort } from './objective-editor-http-port.js';
 import { createValueProofReviewUI } from './value-proof-review.js';
 import { createWorldModelView } from './world-model-view.js';
+import { createGraphClient } from './graph-view-shared.js';
 
 export const LOCAL_WEB_SHELL_CONTRACT_VERSION = 'brainbase.local-web-shell.v1';
 
@@ -75,6 +76,60 @@ function isRecord(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+/**
+ * Parses the local shell's hash target without treating query data as a
+ * screen id.  Only the Graph screen accepts an entity target; all other
+ * screens deliberately discard query parameters.
+ */
+export function parseLocalWebTarget(target) {
+  const raw = typeof target === 'string' ? target.replace(/^#/, '') : '';
+  const separator = raw.indexOf('?');
+  const screenId = separator < 0 ? raw : raw.slice(0, separator);
+  if (!screenId) return { screenId: null, entityId: null };
+  const query = separator < 0 ? '' : raw.slice(separator + 1);
+  const params = new URLSearchParams(query);
+  return {
+    screenId,
+    entityId: screenId === 'graph' ? params.get('entity_id')?.trim() || null : null,
+  };
+}
+
+function graphSourceReader(context) {
+  const client = createGraphClient({ fetcher: context.fetcher, basePath: '/api/graph', token: context.token });
+  return async (source) => {
+    if (!isRecord(source) || source.kind !== 'local_graph'
+      || typeof source.entity_id !== 'string' || !source.entity_id.trim()
+      || typeof source.entity_type !== 'string' || !source.entity_type.trim()) {
+      return { state: 'unavailable', reason: 'source_contract_invalid' };
+    }
+    const result = await client.read(`/entities/${encodeURIComponent(source.entity_id)}`);
+    if (result.state === 'error') {
+      if (result.status === 404 || result.code === 'entity_not_found') return { state: 'not_found' };
+      if (result.status === 403 || result.code === 'authorization_denied' || result.code === 'scope_violation') return { state: 'forbidden' };
+      if (result.code === 'entity_id_ambiguous') return { state: 'ambiguous' };
+      return { state: 'unavailable', reason: result.code };
+    }
+    if (result.state !== 'ok' || !isRecord(result.payload?.entity)) return { state: 'unavailable', reason: 'source_response_invalid' };
+    const entity = result.payload.entity;
+    if (entity.id !== source.entity_id || entity.type !== source.entity_type) {
+      return { state: 'unavailable', reason: 'source_target_mismatch' };
+    }
+    if (source.digest && entity.digest !== source.digest) {
+      return { state: 'unavailable', reason: 'source_digest_mismatch' };
+    }
+    // The local Graph response currently exposes a content digest, not a
+    // revision number.  A requested version is therefore linkable only when
+    // the provider returns the same explicit version field.
+    if (source.version) {
+      const currentVersion = entity.version ?? entity.revision ?? null;
+      if (!currentVersion || currentVersion !== source.version) {
+        return { state: 'unavailable', reason: 'source_version_mismatch' };
+      }
+    }
+    return { state: 'available' };
+  };
+}
+
 function makePage(container, context) {
   const page = makeElement(context.document, 'div', { className: 'bb-shell-page' });
   container.append(page);
@@ -89,6 +144,7 @@ function mountToday(container, context) {
     document: context.document,
     fetcher: context.fetcher,
     token: context.token,
+    sourceReader: graphSourceReader(context),
   });
 }
 
@@ -129,7 +185,13 @@ function mountObjectives(container, context) {
     constraintsEditable: false,
     storyLinks: false,
   });
-  const worldModel = createWorldModelView({ root: worldRoot, rail: context.rail, document: doc, fetcher: context.fetcher });
+  const worldModel = createWorldModelView({
+    root: worldRoot,
+    rail: context.rail,
+    document: doc,
+    fetcher: context.fetcher,
+    token: context.token,
+  });
   return { editor, worldModel };
 }
 
@@ -144,6 +206,7 @@ function mountGraphScreen(createView) {
       document: context.document,
       fetcher: context.fetcher,
       token: context.token,
+      initialEntityId: context.initialEntityId,
     });
   };
 }
@@ -248,6 +311,7 @@ export function createLocalWebShell({
   const mounted = new Map();
   const slots = new Map();
   const links = new Map();
+  const pendingEntityIds = new Map();
   let active = null;
 
   const shell = makeElement(doc, 'div', { className: 'bb-shell', attrs: { 'data-contract-version': LOCAL_WEB_SHELL_CONTRACT_VERSION } });
@@ -311,8 +375,14 @@ export function createLocalWebShell({
     for (const [screenId, railSlot] of rails) railSlot.hidden = !(showRail && screenId === active);
   }
 
-  function ensureMounted(screen) {
-    if (mounted.has(screen.id)) return;
+  function ensureMounted(screen, entityId = pendingEntityIds.get(screen.id) ?? null) {
+    if (mounted.has(screen.id)) {
+      if (entityId && screen.id === 'graph') {
+        const view = mounted.get(screen.id);
+        if (typeof view?.openEntity === 'function') void view.openEntity(entityId);
+      }
+      return;
+    }
     const slot = slots.get(screen.id);
     if (screen.usesGraph && !(status.phase === 'ready' && status.data.graph.status === 'ready')) {
       renderGraphGate(doc, slot, status, controller.refreshStatus, screen.label);
@@ -322,7 +392,7 @@ export function createLocalWebShell({
     const rail = rails.get(screen.id) ?? null;
     rail?.replaceChildren();
     const page = Object.freeze({ crumbs: Object.freeze(['あなたのBrainbase', screen.label]), source: screen.source ?? null });
-    mounted.set(screen.id, screen.mount(slot, Object.freeze({ ...context, rail, page })) ?? true);
+    mounted.set(screen.id, screen.mount(slot, Object.freeze({ ...context, rail, page, initialEntityId: entityId })) ?? true);
     updateRail();
   }
 
@@ -330,15 +400,17 @@ export function createLocalWebShell({
     get state() {
       return { active, status, mounted: [...mounted.keys()] };
     },
-    show(id) {
-      const screen = screens.find((candidate) => candidate.id === id) ?? screens[0];
+    show(target) {
+      const parsed = parseLocalWebTarget(target);
+      const screen = screens.find((candidate) => candidate.id === parsed.screenId) ?? screens[0];
+      pendingEntityIds.set(screen.id, screen.id === 'graph' ? parsed.entityId : null);
       active = screen.id;
       for (const [screenId, slot] of slots) slot.hidden = screenId !== screen.id;
       for (const [screenId, link] of links) {
         if (screenId === screen.id) link.setAttribute('aria-current', 'page');
         else link.removeAttribute('aria-current');
       }
-      ensureMounted(screen);
+      ensureMounted(screen, pendingEntityIds.get(screen.id));
       updateRail();
       return controller;
     },
@@ -362,7 +434,7 @@ export function createLocalWebShell({
       renderSource(doc, source, status, controller.refreshStatus);
       // Re-evaluate Graph-backed screens that are waiting behind the gate.
       for (const screen of screens) {
-        if (screen.usesGraph && !mounted.has(screen.id) && (screen.id === active)) ensureMounted(screen);
+        if (screen.usesGraph && !mounted.has(screen.id) && (screen.id === active)) ensureMounted(screen, pendingEntityIds.get(screen.id));
       }
       return status;
     },

package/ui/project-workspace.js

@@ -667,7 +667,7 @@ function renderDenseOverview(doc, detail, context, entities, actions = {}) {
   todayHead.append(makeElement(doc, 'h4', { text: '今日判断・対応すること' }));
   if (typeof actions.openWorkList === 'function') todayHead.append(denseButton(doc, 'すべて見る', 'bb-pkw-dense-action', actions.openWorkList));
   today.append(todayHead);
-  const todayNotice = denseContextStateNotice(doc, taskSection ?? (context?.state !== 'ok' ? context : null), 'タスクを読み取れませんでした。');
+  const todayNotice = denseContextStateNotice(doc, taskSection ?? (context?.state && context.state !== 'ok' ? context : { state: 'unknown' }), 'タスクを読み取れませんでした。');
   if (todayNotice) today.append(todayNotice);
   if (!todayNotice && due.length === 0) today.append(makeElement(doc, 'p', { className: 'bb-pkw-muted', text: '表示できる仕事はありません。' }));
   if (!todayNotice && due.length > 0) {

package/ui/value-proof-review.css

@@ -93,6 +93,28 @@ body:has(#brainbase-value-proof-review) {
   font-weight: 700;
 }
 
+.bb-vpr-setup-guide {
+  display: grid;
+  gap: var(--bb-space-1);
+  padding: var(--bb-space-2) var(--bb-space-3);
+  border: 1px solid var(--bb-color-border, #d8dee9);
+  background: var(--bb-color-panel, #ffffff);
+}
+
+.bb-vpr-setup-guide p,
+.bb-vpr-setup-guide ol {
+  margin: 0;
+}
+
+.bb-vpr-setup-guide ol {
+  padding-left: var(--bb-space-5);
+}
+
+.bb-vpr-setup-guide code {
+  overflow-wrap: anywhere;
+  font-size: .92em;
+}
+
 .bb-vpr-rejected summary {
   cursor: pointer;
 }
@@ -225,6 +247,38 @@ body:has(#brainbase-value-proof-review) {
   font-size: 13px;
 }
 
+/* A source-bearing target is still trace metadata until the host has read the
+ * exact Graph record.  Only the same-origin link is styled as an action. */
+.bb-vpr-source-target {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: var(--bb-space-1, 4px);
+  align-items: baseline;
+}
+
+.bb-vpr-source-link {
+  color: var(--vpr-action);
+  font-weight: 680;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.bb-vpr-source-status {
+  color: var(--vpr-muted);
+  font-size: 12px;
+}
+
+.bb-vpr-source-status.is-loading {
+  color: var(--vpr-muted);
+}
+
+.bb-vpr-source-status.is-not_found,
+.bb-vpr-source-status.is-ambiguous,
+.bb-vpr-source-status.is-forbidden,
+.bb-vpr-source-status.is-unavailable {
+  color: var(--vpr-warning);
+}
+
 /* Detail: in the rail, or after the workspace when the host has none. */
 .bb-vpr-inline-detail {
   max-width: 760px;