@ran-sh/dsh-crew 1.1.1 → 1.2.0-rc.4

package/src/provider-health.mjs

@@ -1,124 +1,130 @@
-// Bounded provider/model callability evidence.
-//
-// Catalog presence is not proof of a callable route. This store keeps only
-// sanitized state and timestamps; raw provider errors never leave the caller.
-
-export const PROVIDER_HEALTH_STATES = Object.freeze([
-  'callable', 'credential-missing', 'quota-exhausted', 'rate-limited',
-  'timeout', 'internal-error', 'disabled', 'not-configured', 'tombstoned', 'unprobed',
-]);
-
-const REASON_CODES = Object.freeze({
-  callable: 'PROVIDER_CALLABLE',
-  'credential-missing': 'CREDENTIAL_MISSING',
-  'quota-exhausted': 'QUOTA_EXHAUSTED',
-  'rate-limited': 'RATE_LIMITED',
-  timeout: 'PROBE_TIMEOUT',
-  'internal-error': 'PROVIDER_INTERNAL_ERROR',
-  disabled: 'PROVIDER_DISABLED',
-  'not-configured': 'PROVIDER_NOT_CONFIGURED',
-  tombstoned: 'PROVIDER_TOMBSTONED',
-});
-
-const DEFAULT_TTLS = Object.freeze({
-  callable: 5 * 60 * 1000,
-  'credential-missing': 30 * 1000,
-  'quota-exhausted': 15 * 60 * 1000,
-  'rate-limited': 60 * 1000,
-  timeout: 60 * 1000,
-  'internal-error': 60 * 1000,
-  disabled: 5 * 60 * 1000,
-  'not-configured': 30 * 1000,
-  tombstoned: 5 * 60 * 1000,
-});
-
-function text(value) {
-  return typeof value === 'string' && value.trim() ? value.trim() : null;
-}
-
-function providerKey(provider, model) {
-  const p = text(provider);
-  const m = text(model);
-  return p && m ? `${p}\u0000${m}` : null;
-}
-
-function errorText(error) {
-  if (!error || typeof error !== 'object') return '';
-  return [error.code, error.name, error.message, error.status].filter((value) => value !== undefined && value !== null).join(' ').toLowerCase();
-}
-
-/** Map an upstream error to one bounded, secret-free callability state. */
-export function classifyProviderError(error = {}) {
-  const textValue = errorText(error);
-  const code = text(error?.code)?.toUpperCase() ?? '';
-  if (code === 'MISSING_CREDENTIAL' || code === 'CREDENTIAL_MISSING' || /no (api )?key|credential.*missing|missing.*credential/.test(textValue)) {
-    return { state: 'credential-missing', reason_code: REASON_CODES['credential-missing'] };
-  }
-  if (code === 'QUOTA_EXCEEDED' || /monthly|account/.test(textValue) && /quota|exhaust|limit/.test(textValue)) {
-    return { state: 'quota-exhausted', reason_code: REASON_CODES['quota-exhausted'] };
-  }
-  if (Number(error?.status) === 429 || code === 'RATE_LIMITED' || /rate.?limit|too many requests/.test(textValue)) {
-    return { state: 'rate-limited', reason_code: REASON_CODES['rate-limited'] };
-  }
-  if (error?.name === 'TimeoutError' || error?.name === 'AbortError' || code === 'TIMEOUT' || /timed? out|timeout|aborted/.test(textValue)) {
-    return { state: 'timeout', reason_code: REASON_CODES.timeout };
-  }
-  return { state: 'internal-error', reason_code: REASON_CODES['internal-error'] };
-}
-
-function boundedTimestamp(value, fallback) {
-  return Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-
-function view(entry, now) {
-  if (!entry) return { state: 'unprobed', reason_code: null, observed_at: null, expires_at: null, fresh: false };
-  const fresh = now < entry.expires_at;
-  if (!fresh) return { state: 'unprobed', reason_code: null, observed_at: entry.observed_at, expires_at: entry.expires_at, fresh: false };
-  return { ...entry, fresh: true };
-}
-
-export function createProviderHealthStore({ clock = () => Date.now(), ttls = {}, maxEntries = 256 } = {}) {
-  const records = new Map();
-  const limits = { ...DEFAULT_TTLS };
-  for (const state of PROVIDER_HEALTH_STATES) {
-    if (Number.isFinite(ttls[state]) && ttls[state] >= 0) limits[state] = Math.min(ttls[state], 24 * 60 * 60 * 1000);
-  }
-  const boundedMax = Number.isInteger(maxEntries) && maxEntries > 0 ? Math.min(maxEntries, 2048) : 256;
-
-  const get = (provider, model) => {
-    const key = providerKey(provider, model);
-    if (!key) return { provider: text(provider), model: text(model), state: 'unprobed', reason_code: null, observed_at: null, expires_at: null, fresh: false };
-    const entry = records.get(key);
-    const current = view(entry, clock());
-    if (entry && !current.fresh) records.delete(key);
-    return { provider: text(provider), model: text(model), ...current };
-  };
-
-  const record = (provider, model, result = {}) => {
-    const key = providerKey(provider, model);
-    if (!key) return null;
-    const now = clock();
-    const observed = boundedTimestamp(result.observed_at, now);
-    const previous = records.get(key);
-    if (previous && previous.observed_at > observed) return get(provider, model);
-    let classified;
-    if (result.ok === true) classified = { state: 'callable', reason_code: REASON_CODES.callable };
-    else if (PROVIDER_HEALTH_STATES.includes(result.state) && result.state !== 'unprobed') classified = { state: result.state, reason_code: REASON_CODES[result.state] ?? null };
-    else classified = classifyProviderError(result.error ?? result);
-    const expires = observed + limits[classified.state];
-    records.set(key, {
-      provider: text(provider), model: text(model), ...classified,
-      observed_at: observed, expires_at: expires,
-    });
-    while (records.size > boundedMax) {
-      const oldest = [...records.entries()].sort((a, b) => a[1].observed_at - b[1].observed_at)[0]?.[0];
-      if (!oldest) break;
-      records.delete(oldest);
-    }
-    return get(provider, model);
-  };
-
-  const list = () => [...records.values()].map((entry) => view(entry, clock())).filter((entry) => entry.fresh).slice(0, boundedMax);
-
-  return { get, record, list, ttls: { ...limits }, maxEntries: boundedMax };
-}
+// Bounded provider/model callability evidence.
+//
+// Catalog presence is not proof of a callable route. This store keeps only
+// sanitized state and timestamps; raw provider errors never leave the caller.
+
+export const PROVIDER_HEALTH_STATES = Object.freeze([
+  'callable', 'credential-missing', 'quota-exhausted', 'rate-limited',
+  'timeout', 'internal-error', 'disabled', 'not-configured', 'tombstoned', 'unprobed',
+]);
+
+const REASON_CODES = Object.freeze({
+  callable: 'PROVIDER_CALLABLE',
+  'credential-missing': 'CREDENTIAL_MISSING',
+  'quota-exhausted': 'QUOTA_EXHAUSTED',
+  'rate-limited': 'RATE_LIMITED',
+  timeout: 'PROBE_TIMEOUT',
+  'internal-error': 'PROVIDER_INTERNAL_ERROR',
+  disabled: 'PROVIDER_DISABLED',
+  'not-configured': 'PROVIDER_NOT_CONFIGURED',
+  tombstoned: 'PROVIDER_TOMBSTONED',
+});
+
+const DEFAULT_TTLS = Object.freeze({
+  callable: 5 * 60 * 1000,
+  'credential-missing': 30 * 1000,
+  'quota-exhausted': 15 * 60 * 1000,
+  'rate-limited': 60 * 1000,
+  timeout: 60 * 1000,
+  'internal-error': 60 * 1000,
+  disabled: 5 * 60 * 1000,
+  'not-configured': 30 * 1000,
+  tombstoned: 5 * 60 * 1000,
+});
+
+function text(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function providerKey(provider, model) {
+  const p = text(provider);
+  const m = text(model);
+  return p && m ? `${p}\u0000${m}` : null;
+}
+
+function errorText(error) {
+  if (!error || typeof error !== 'object') return '';
+  return [error.code, error.name, error.message, error.status].filter((value) => value !== undefined && value !== null).join(' ').toLowerCase();
+}
+
+/** Map an upstream error to one bounded, secret-free callability state. */
+export function classifyProviderError(error = {}) {
+  const textValue = errorText(error);
+  const code = text(error?.code)?.toUpperCase() ?? '';
+  if (code === 'MISSING_CREDENTIAL' || code === 'CREDENTIAL_MISSING' || /no (api )?key|credential.*missing|missing.*credential/.test(textValue)) {
+    return { state: 'credential-missing', reason_code: REASON_CODES['credential-missing'] };
+  }
+  if (code === 'QUOTA_EXCEEDED' || /monthly|account/.test(textValue) && /quota|exhaust|limit/.test(textValue)) {
+    return { state: 'quota-exhausted', reason_code: REASON_CODES['quota-exhausted'] };
+  }
+  if (Number(error?.status) === 429 || code === 'RATE_LIMITED' || /rate.?limit|too many requests/.test(textValue)) {
+    return { state: 'rate-limited', reason_code: REASON_CODES['rate-limited'] };
+  }
+  if (error?.name === 'TimeoutError' || error?.name === 'AbortError' || code === 'TIMEOUT' || /timed? out|timeout|aborted/.test(textValue)) {
+    return { state: 'timeout', reason_code: REASON_CODES.timeout };
+  }
+  return { state: 'internal-error', reason_code: REASON_CODES['internal-error'] };
+}
+
+function boundedTimestamp(value, fallback) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+function view(entry, now) {
+  if (!entry) return { state: 'unprobed', reason_code: null, observed_at: null, expires_at: null, fresh: false };
+  const fresh = now < entry.expires_at;
+  if (!fresh) return { state: 'unprobed', reason_code: null, observed_at: entry.observed_at, expires_at: entry.expires_at, fresh: false };
+  return { ...entry, fresh: true };
+}
+
+export function createProviderHealthStore({ clock = () => Date.now(), ttls = {}, maxEntries = 256 } = {}) {
+  const records = new Map();
+  const limits = { ...DEFAULT_TTLS };
+  for (const state of PROVIDER_HEALTH_STATES) {
+    if (Number.isFinite(ttls[state]) && ttls[state] >= 0) limits[state] = Math.min(ttls[state], 24 * 60 * 60 * 1000);
+  }
+  const boundedMax = Number.isInteger(maxEntries) && maxEntries > 0 ? Math.min(maxEntries, 2048) : 256;
+
+  const get = (provider, model) => {
+    const key = providerKey(provider, model);
+    if (!key) return { provider: text(provider), model: text(model), state: 'unprobed', reason_code: null, observed_at: null, expires_at: null, fresh: false };
+    const entry = records.get(key);
+    const current = view(entry, clock());
+    if (entry && !current.fresh) records.delete(key);
+    return { provider: text(provider), model: text(model), ...current };
+  };
+
+  const record = (provider, model, result = {}) => {
+    const key = providerKey(provider, model);
+    if (!key) return null;
+    const now = clock();
+    const observed = boundedTimestamp(result.observed_at, now);
+    const previous = records.get(key);
+    let classified;
+    if (result.ok === true) classified = { state: 'callable', reason_code: REASON_CODES.callable };
+    else if (PROVIDER_HEALTH_STATES.includes(result.state) && result.state !== 'unprobed') classified = { state: result.state, reason_code: REASON_CODES[result.state] ?? null };
+    else classified = classifyProviderError(result.error ?? result);
+    if (previous && previous.observed_at > observed) return get(provider, model);
+    if (previous && previous.observed_at === observed) {
+      const previousFailure = previous.state !== 'callable';
+      const incomingFailure = classified.state !== 'callable';
+      if (previousFailure && !incomingFailure) return get(provider, model);
+      if (previousFailure && incomingFailure && String(previous.state).localeCompare(String(classified.state)) <= 0) return get(provider, model);
+    }
+    const expires = observed + limits[classified.state];
+    records.set(key, {
+      provider: text(provider), model: text(model), ...classified,
+      observed_at: observed, expires_at: expires,
+    });
+    while (records.size > boundedMax) {
+      const oldest = [...records.entries()].sort((a, b) => a[1].observed_at - b[1].observed_at)[0]?.[0];
+      if (!oldest) break;
+      records.delete(oldest);
+    }
+    return get(provider, model);
+  };
+
+  const list = () => [...records.values()].map((entry) => view(entry, clock())).filter((entry) => entry.fresh).slice(0, boundedMax);
+
+  return { get, record, list, ttls: { ...limits }, maxEntries: boundedMax };
+}

package/src/readiness-matrix.mjs

@@ -13,11 +13,11 @@ export const READINESS_REASON_CODES = Object.freeze({
   HUB_INCOMPATIBLE: 'HUB_INCOMPATIBLE',
   PROVIDER_CATALOG_RESOLVED: 'PROVIDER_CATALOG_RESOLVED',
   PROVIDER_CATALOG_UNAVAILABLE: 'PROVIDER_CATALOG_UNAVAILABLE',
-  PROVIDER_CATALOG_HEALTH_WARNING: 'PROVIDER_CATALOG_HEALTH_WARNING',
-  PROVIDER_CATALOG_NOT_REQUIRED: 'PROVIDER_CATALOG_NOT_REQUIRED',
-  PROVIDER_LIFECYCLE_CONSISTENT: 'PROVIDER_LIFECYCLE_CONSISTENT',
-  PROVIDER_LIFECYCLE_INCONSISTENT: 'PROVIDER_LIFECYCLE_INCONSISTENT',
-  PROVIDER_INVENTORY_UNAVAILABLE: 'PROVIDER_INVENTORY_UNAVAILABLE',
+  PROVIDER_CATALOG_HEALTH_WARNING: 'PROVIDER_CATALOG_HEALTH_WARNING',
+  PROVIDER_CATALOG_NOT_REQUIRED: 'PROVIDER_CATALOG_NOT_REQUIRED',
+  PROVIDER_LIFECYCLE_CONSISTENT: 'PROVIDER_LIFECYCLE_CONSISTENT',
+  PROVIDER_LIFECYCLE_INCONSISTENT: 'PROVIDER_LIFECYCLE_INCONSISTENT',
+  PROVIDER_INVENTORY_UNAVAILABLE: 'PROVIDER_INVENTORY_UNAVAILABLE',
   PROVIDER_MODE_UNKNOWN: 'PROVIDER_MODE_UNKNOWN',
   NO_CI_EVIDENCE: 'NO_CI_EVIDENCE',
   NO_EXECUTION_EVIDENCE: 'NO_EXECUTION_EVIDENCE',
@@ -29,16 +29,18 @@ const TARGET_ROWS = Object.freeze([
   ['linux_deterministic', 'ci'],
   ['windows_regressions', 'ci'],
   ['macos_smoke', 'ci'],
-  ['hub_compatibility', 'live-runtime'],
-  ['provider_catalog', 'live-runtime'],
-  ['model_execution', 'real-execution'],
-  ['worker_primary_callable', 'real-execution'],
-  ['worker_escalation_callable', 'real-execution'],
-  ['reviewer_primary_callable', 'real-execution'],
-  ['provider_lifecycle_consistent', 'live-runtime'],
-  ['deepseek_flash', 'real-execution'],
-  ['deepseek_pro', 'real-execution'],
-  ['reviewer_pipeline', 'real-execution'],
+  ['hub_compatibility', 'live-runtime'],
+  ['provider_catalog', 'live-runtime'],
+  ['provider_health', 'live-runtime'],
+  ['reviewer_health', 'live-runtime'],
+  ['model_execution', 'real-execution'],
+  ['worker_primary_callable', 'real-execution'],
+  ['worker_escalation_callable', 'real-execution'],
+  ['reviewer_primary_callable', 'real-execution'],
+  ['provider_lifecycle_consistent', 'live-runtime'],
+  ['deepseek_flash', 'real-execution'],
+  ['deepseek_pro', 'real-execution'],
+  ['reviewer_pipeline', 'real-execution'],
   ['cancellation_timeout_escalation', 'real-execution'],
   ['standalone_official', 'real-execution'],
 ]);
@@ -71,6 +73,9 @@ function normalizeEvidence(row, evidence) {
     ...(typeof evidence.evidence_ref === 'string' && evidence.evidence_ref.trim()
       ? { evidence_ref: evidence.evidence_ref.trim() }
       : {}),
+    ...(typeof evidence.detail_code === 'string' && /^[A-Z][A-Z0-9_]{0,127}$/u.test(evidence.detail_code)
+      ? { detail_code: evidence.detail_code }
+      : {}),
   };
 }
 

package/src/runtime-identity-contract.mjs

@@ -0,0 +1,34 @@
+// Browser-safe runtime identity primitives shared by the Hub, extension
+// contract and client.  Do not coerce missing values: an incomplete identity
+// is never evidence of the native 3210 Crew runtime.
+
+export const PRODUCTION_EXECUTION_PLANE = 'hub-3210';
+export const PRODUCTION_PROFILE = 'dsh-crew';
+export const PRODUCTION_LISTEN_PORT = 3210;
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+export function isCompleteRuntimeIdentity(identity) {
+  return Boolean(identity && typeof identity === 'object'
+    && nonEmpty(identity.execution_plane)
+    && nonEmpty(identity.profile)
+    && Number.isInteger(identity.listen_port) && identity.listen_port > 0
+    && nonEmpty(identity.runtime_id));
+}
+
+export function sameCompleteRuntimeIdentity(left, right) {
+  return isCompleteRuntimeIdentity(left) && isCompleteRuntimeIdentity(right)
+    && left.execution_plane === right.execution_plane
+    && left.profile === right.profile
+    && left.listen_port === right.listen_port
+    && left.runtime_id === right.runtime_id;
+}
+
+export function isExactNativeCrewIdentity(identity) {
+  return isCompleteRuntimeIdentity(identity)
+    && identity.execution_plane === PRODUCTION_EXECUTION_PLANE
+    && identity.profile === PRODUCTION_PROFILE
+    && identity.listen_port === PRODUCTION_LISTEN_PORT;
+}

package/src/runtime-identity.mjs

@@ -17,16 +17,26 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import {
+  PRODUCTION_EXECUTION_PLANE,
+  PRODUCTION_PROFILE,
+  PRODUCTION_LISTEN_PORT,
+} from './runtime-identity-contract.mjs';
+export {
+  PRODUCTION_EXECUTION_PLANE,
+  PRODUCTION_PROFILE,
+  PRODUCTION_LISTEN_PORT,
+  isCompleteRuntimeIdentity,
+  sameCompleteRuntimeIdentity,
+  isExactNativeCrewIdentity,
+} from './runtime-identity-contract.mjs';
 
 // Production Crew execution is intentionally bound to the isolated 3210 Hub.
 // These fields are public provenance only; no credential or session secret is
 // included in the identity contract.
-export const PRODUCTION_EXECUTION_PLANE = 'hub-3210';
-export const PRODUCTION_PROFILE = 'dsh-crew';
-export const PRODUCTION_LISTEN_PORT = 3210;
 const RUNTIME_ID = randomUUID();
 
-export const RUNTIME_VERSION = '1.1.1';
+export const RUNTIME_VERSION = '1.2.0-rc.4';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([