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

package/src/runtime-readiness-snapshot.mjs

@@ -1,87 +1,285 @@
-// Single, bounded readiness projection shared by the Hub extension surface,
-// MCP diagnostics and the client. It consumes already-collected evidence and
-// never performs I/O or carries raw task/result/error/credential content.
-
-const MAX_HEALTH = 128;
-
-function text(value) { return typeof value === 'string' && value.trim() ? value.trim() : null; }
-
-function projectRuntime(runtime) {
-  if (!runtime || typeof runtime !== 'object') return null;
-  return {
-    execution_plane: text(runtime.execution_plane),
-    profile: text(runtime.profile),
-    listen_port: Number.isFinite(Number(runtime.listen_port)) ? Number(runtime.listen_port) : null,
-    runtime_id: text(runtime.runtime_id),
-  };
-}
-
-function projectSelection(value) {
-  if (!value || typeof value !== 'object') return null;
-  const provider = text(value.provider);
-  const model = text(value.model);
-  if (!provider || !model) return null;
-  return { provider, model, ...(text(value.source) ? { source: text(value.source) } : {}) };
-}
-
-function projectHealth(entry) {
-  if (!entry || typeof entry !== 'object') return null;
-  const provider = text(entry.provider);
-  const model = text(entry.model);
-  const state = text(entry.state);
-  if (!provider || !model || !state) return null;
-  return {
-    provider,
-    model,
-    state,
-    ...(text(entry.reason_code) ? { reason_code: text(entry.reason_code) } : {}),
-    ...(Number.isFinite(entry.observed_at) ? { observed_at: entry.observed_at } : {}),
-    ...(Number.isFinite(entry.expires_at) ? { expires_at: entry.expires_at } : {}),
-    fresh: entry.fresh === true,
-  };
-}
-
-function matrixRow(matrix, id) {
-  return Array.isArray(matrix?.rows) ? matrix.rows.find((row) => row?.id === id) ?? null : null;
-}
-
-function projectWorkspace(workspace) {
-  if (!workspace || typeof workspace !== 'object') return null;
-  return {
-    ...(text(workspace.status) ? { status: text(workspace.status) } : {}),
-    ...(text(workspace.reason_code) ? { reason_code: text(workspace.reason_code) } : {}),
-  };
-}
-
-export function buildRuntimeReadinessSnapshot({
-  runtime = null,
-  readinessMatrix = null,
-  selections = {},
-  health = [],
-  jobs = [],
-  workspace = null,
-} = {}) {
-  const projectedHealth = (Array.isArray(health) ? health : []).map(projectHealth).filter(Boolean).slice(0, MAX_HEALTH);
-  const projectedJobs = Array.isArray(jobs) ? jobs : [];
-  const verified = projectedJobs.filter((job) => job?.status === 'done' && job?.task_status === 'success' && job?.delivery_complete === true).length;
-  const workerJobs = projectedJobs.filter((job) => job?.role === 'worker').length;
-  const reviewerJobs = projectedJobs.filter((job) => job?.role === 'reviewer').length;
-  const workerSelection = projectSelection(selections.worker ?? selections.flash);
-  const reviewerSelection = projectSelection(selections.reviewer ?? selections.pro);
-  return {
-    schema_version: 1,
-    runtime: projectRuntime(runtime),
-    readiness_matrix: readinessMatrix && typeof readinessMatrix === 'object' ? structuredClone(readinessMatrix) : null,
-    provider_lifecycle: matrixRow(readinessMatrix, 'provider_lifecycle_consistent'),
-    health: projectedHealth,
-    worker: { selected: workerSelection, health: projectedHealth.filter((entry) => entry.provider === workerSelection?.provider && entry.model === workerSelection?.model) },
-    reviewer: { selected: reviewerSelection, health: projectedHealth.filter((entry) => entry.provider === reviewerSelection?.provider && entry.model === reviewerSelection?.model) },
-    historical_evidence: {
-      job_count: projectedJobs.length,
-      verified_job_count: verified,
-      worker_job_count: workerJobs,
-      reviewer_job_count: reviewerJobs,
-    },
-    workspace: projectWorkspace(workspace),
-  };
-}
+// Single, bounded readiness projection shared by the Hub extension surface,
+// MCP diagnostics and the client. It consumes already-collected evidence and
+// never performs I/O or carries raw task/result/error/credential content.
+
+import { isCompleteRuntimeIdentity, isExactNativeCrewIdentity, sameCompleteRuntimeIdentity } from './runtime-identity-contract.mjs';
+import { MODEL_CALLABILITY_SCHEMA_VERSION, validateModelCallabilityV2 } from './model-callability-contract.mjs';
+
+const MAX_HEALTH = 128;
+const DEFAULT_EXECUTION_EVIDENCE_TTL_MS = 5 * 60 * 1000;
+const MIN_EXECUTION_EVIDENCE_TTL_MS = 1_000;
+const MAX_EXECUTION_EVIDENCE_TTL_MS = 24 * 60 * 60 * 1000;
+
+function text(value) { return typeof value === 'string' && value.trim() ? value.trim() : null; }
+
+function projectRuntime(runtime) {
+  if (!runtime || typeof runtime !== 'object') return null;
+  return {
+    execution_plane: text(runtime.execution_plane),
+    profile: text(runtime.profile),
+    listen_port: Number.isInteger(runtime.listen_port) ? runtime.listen_port : null,
+    runtime_id: text(runtime.runtime_id),
+  };
+}
+
+function runtimeIdentity(runtime) {
+  return isExactNativeCrewIdentity(runtime)
+    ? {
+        execution_plane: runtime.execution_plane,
+        profile: runtime.profile,
+        listen_port: runtime.listen_port,
+        runtime_id: runtime.runtime_id,
+      }
+    : null;
+}
+
+function projectSelection(value) {
+  if (!value || typeof value !== 'object') return null;
+  const provider = text(value.provider);
+  const model = text(value.model);
+  if (!provider || !model) return null;
+  return { provider, model, ...(text(value.source) ? { source: text(value.source) } : {}) };
+}
+
+function projectHealth(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const provider = text(entry.provider);
+  const model = text(entry.model);
+  const state = text(entry.state);
+  if (!provider || !model || !state) return null;
+  return {
+    provider,
+    model,
+    state,
+    ...(text(entry.reason_code) ? { reason_code: text(entry.reason_code) } : {}),
+    ...(Number.isFinite(entry.observed_at) ? { observed_at: entry.observed_at } : {}),
+    ...(Number.isFinite(entry.expires_at) ? { expires_at: entry.expires_at } : {}),
+    fresh: entry.fresh === true,
+  };
+}
+
+function matrixRow(matrix, id) {
+  return Array.isArray(matrix?.rows) ? matrix.rows.find((row) => row?.id === id) ?? null : null;
+}
+
+function projectWorkspace(workspace) {
+  if (!workspace || typeof workspace !== 'object') return null;
+  return {
+    ...(text(workspace.status) ? { status: text(workspace.status) } : {}),
+    ...(text(workspace.reason_code) ? { reason_code: text(workspace.reason_code) } : {}),
+  };
+}
+
+function routeKey(value) {
+  return value?.provider && value?.model ? `${value.provider}\u0000${value.model}` : null;
+}
+
+function normalizeExecutionEvidenceTtl(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < MIN_EXECUTION_EVIDENCE_TTL_MS) return DEFAULT_EXECUTION_EVIDENCE_TTL_MS;
+  return Math.min(Math.floor(parsed), MAX_EXECUTION_EVIDENCE_TTL_MS);
+}
+
+function projectModelRole({ role, selected, health, jobs, runtime, now, executionEvidenceTtlMs, enabled }) {
+  if (enabled === false) return { state: 'NOT_APPLICABLE', reason_code: 'ROLE_DISABLED', selected: selected ?? null, last_success: null };
+  const route = routeKey(selected);
+  if (!route || !isExactNativeCrewIdentity(runtime)) return { state: 'UNKNOWN', reason_code: 'MODEL_ROUTE_UNAVAILABLE', selected: selected ?? null, last_success: null };
+  const matchingHealth = (Array.isArray(health) ? health : [])
+    .filter((entry) => routeKey(entry) === route)
+    .sort((left, right) => {
+      const observedDelta = (Number(right?.observed_at) || 0) - (Number(left?.observed_at) || 0);
+      if (observedDelta !== 0) return observedDelta;
+      if (left?.state === 'callable' && right?.state !== 'callable') return 1;
+      if (left?.state !== 'callable' && right?.state === 'callable') return -1;
+      return 0;
+    })[0];
+  const expiresAt = Number.isFinite(matchingHealth?.expires_at) ? matchingHealth.expires_at : null;
+  const observedAt = Number.isFinite(matchingHealth?.observed_at) ? matchingHealth.observed_at : null;
+  if (matchingHealth) {
+    if (observedAt === null || observedAt > now || expiresAt === null || expiresAt <= now
+      || expiresAt - observedAt > MAX_EXECUTION_EVIDENCE_TTL_MS) {
+      return { state: 'STALE', reason_code: 'PROVIDER_HEALTH_STALE_OR_INVALID', selected, observed_at: observedAt, expires_at: expiresAt, source: 'provider_health', last_success: null };
+    }
+  }
+  const healthCurrent = matchingHealth && matchingHealth.fresh === true;
+  if (healthCurrent && matchingHealth.state !== 'callable') {
+    return { state: 'NOT_CALLABLE', reason_code: matchingHealth.reason_code ?? 'PROVIDER_ROUTE_UNCALLABLE', selected, observed_at: matchingHealth.observed_at ?? null, expires_at: expiresAt, source: 'provider_health', last_success: null };
+  }
+  if (healthCurrent && matchingHealth.state === 'callable') {
+    return { state: 'CALLABLE', reason_code: matchingHealth.reason_code ?? 'PROVIDER_CALLABLE', selected, observed_at: matchingHealth.observed_at ?? null, expires_at: expiresAt, source: 'provider_health', last_success: null };
+  }
+  const completed = (Array.isArray(jobs) ? jobs : [])
+    .filter((job) => job?.role === role && job?.provider === selected.provider && job?.model === selected.model
+      && job?.status === 'done' && job?.task_status === 'success'
+      && sameCompleteRuntimeIdentity(job.execution_context, runtime))
+    .map((job) => ({ job, endedAt: Date.parse(job.endedAt ?? '') }))
+    .filter(({ endedAt }) => Number.isFinite(endedAt))
+    .sort((a, b) => b.endedAt - a.endedAt)[0];
+  if (completed) {
+    const expires = completed.endedAt + executionEvidenceTtlMs;
+    const lastSuccess = { observed_at: completed.endedAt, expires_at: expires, job_id: completed.job.id };
+    if (completed.endedAt > now) return { state: 'STALE', reason_code: 'EXECUTION_EVIDENCE_FUTURE_DATED', selected, observed_at: completed.endedAt, expires_at: expires, source: 'execution', last_success: lastSuccess };
+    if (expires > now) return { state: 'CALLABLE', reason_code: 'RECENT_EXECUTION_PASSED', selected, observed_at: completed.endedAt, expires_at: expires, source: 'execution', last_success: lastSuccess };
+    return { state: 'STALE', reason_code: 'EXECUTION_EVIDENCE_EXPIRED', selected, observed_at: completed.endedAt, expires_at: expires, source: 'execution', last_success: lastSuccess };
+  }
+  return { state: 'UNKNOWN', reason_code: 'NO_CURRENT_MODEL_EVIDENCE', selected, last_success: null };
+}
+
+export function projectModelCallability({ runtime = null, selections = {}, health = [], health_status = 'AVAILABLE', jobs = [], now = Date.now(), execution_evidence_ttl_ms = DEFAULT_EXECUTION_EVIDENCE_TTL_MS, enabled_roles = {} } = {}) {
+  const ttl = normalizeExecutionEvidenceTtl(execution_evidence_ttl_ms);
+  const enabledRoles = {
+    worker: enabled_roles?.worker !== false,
+    reviewer: enabled_roles?.reviewer !== false,
+  };
+  const roles = {
+    worker: projectModelRole({ role: 'worker', selected: selections.worker ?? selections.flash, health, jobs, runtime, now, executionEvidenceTtlMs: ttl, enabled: enabledRoles.worker }),
+    reviewer: projectModelRole({ role: 'reviewer', selected: selections.reviewer ?? selections.pro, health, jobs, runtime, now, executionEvidenceTtlMs: ttl, enabled: enabledRoles.reviewer }),
+  };
+  if (health_status !== 'AVAILABLE') {
+    for (const [name, enabled] of Object.entries(enabledRoles)) {
+      if (enabled) roles[name] = { ...roles[name], state: 'UNKNOWN', reason_code: 'PROVIDER_HEALTH_UNAVAILABLE', source: 'provider_health' };
+    }
+  }
+  const states = Object.entries(roles).filter(([name]) => enabledRoles[name]).map(([, role]) => role.state);
+  const overall = states.length === 0 ? 'UNKNOWN'
+    : states.includes('NOT_CALLABLE') ? 'NOT_CALLABLE'
+      : states.every((state) => state === 'CALLABLE') ? 'CALLABLE'
+        : states.some((state) => state === 'STALE') ? 'STALE' : 'UNKNOWN';
+  const expirations = Object.values(roles)
+    .map((role) => role?.expires_at)
+    .filter((value) => Number.isFinite(value));
+  return {
+    schema_version: MODEL_CALLABILITY_SCHEMA_VERSION,
+    captured_at: now,
+    expires_at: expirations.length ? Math.min(...expirations) : null,
+    current_runtime_id: runtime?.runtime_id ?? null,
+    runtime_identity: runtimeIdentity(runtime),
+    execution_evidence_ttl_ms: ttl,
+    enabled_roles: enabledRoles,
+    overall,
+    roles,
+  };
+}
+
+export function buildRuntimeReadinessSnapshot({
+  runtime = null,
+  readinessMatrix = null,
+  selections = {},
+  health = [],
+  health_status = null,
+  jobs = [],
+  workspace = null,
+  enabled_roles = {},
+  now = Date.now(),
+} = {}) {
+  const healthObservations = Array.isArray(health) ? health : (Array.isArray(health?.observations) ? health.observations : []);
+  const resolvedHealthStatus = health_status
+    ?? (health && !Array.isArray(health) ? health.status : null)
+    ?? (Array.isArray(health) && health.length > 0 ? 'AVAILABLE' : 'UNKNOWN');
+  const projectedHealthAll = healthObservations.map(projectHealth).filter(Boolean);
+  const projectedJobs = Array.isArray(jobs) ? jobs : [];
+  const verified = projectedJobs.filter((job) => job?.status === 'done' && job?.task_status === 'success' && job?.delivery_complete === true).length;
+  const workerJobs = projectedJobs.filter((job) => job?.role === 'worker').length;
+  const reviewerJobs = projectedJobs.filter((job) => job?.role === 'reviewer').length;
+  const workerSelection = projectSelection(selections.worker ?? selections.flash);
+  const reviewerSelection = projectSelection(selections.reviewer ?? selections.pro);
+  const selectedRoutes = [workerSelection, reviewerSelection].filter(Boolean);
+  const selectedHealth = selectedRoutes.map((selection) => projectedHealthAll
+    .filter((entry) => entry.provider === selection.provider && entry.model === selection.model)
+    .sort((left, right) => (right.observed_at ?? 0) - (left.observed_at ?? 0))[0]).filter(Boolean);
+  const selectedKeys = new Set(selectedHealth.map((entry) => `${entry.provider}\u0000${entry.model}`));
+  const projectedHealth = [...selectedHealth, ...projectedHealthAll
+    .filter((entry) => !selectedKeys.has(`${entry.provider}\u0000${entry.model}`))]
+    .slice(0, MAX_HEALTH);
+  const modelCallability = projectModelCallability({ runtime, selections: { worker: workerSelection, reviewer: reviewerSelection }, health: projectedHealthAll, health_status: resolvedHealthStatus, jobs: projectedJobs, enabled_roles, now });
+  return {
+    schema_version: 1,
+    captured_at: now,
+    expires_at: modelCallability.expires_at,
+    health_status: resolvedHealthStatus,
+    runtime: projectRuntime(runtime),
+    runtime_identity: runtimeIdentity(runtime),
+    readiness_matrix: readinessMatrix && typeof readinessMatrix === 'object' ? structuredClone(readinessMatrix) : null,
+    provider_lifecycle: matrixRow(readinessMatrix, 'provider_lifecycle_consistent'),
+    health: projectedHealth,
+    worker: { selected: workerSelection, health: projectedHealth.filter((entry) => entry.provider === workerSelection?.provider && entry.model === workerSelection?.model) },
+    reviewer: { selected: reviewerSelection, health: projectedHealth.filter((entry) => entry.provider === reviewerSelection?.provider && entry.model === reviewerSelection?.model) },
+    historical_evidence: {
+      job_count: projectedJobs.length,
+      verified_job_count: verified,
+      worker_job_count: workerJobs,
+      reviewer_job_count: reviewerJobs,
+    },
+    workspace: projectWorkspace(workspace),
+    model_callability: modelCallability,
+  };
+}
+
+/** Re-project a Hub snapshot when the MCP session changes role enablement. */
+export function reprojectRuntimeModelCallability(snapshot, { enabled_roles = {}, now = Date.now() } = {}) {
+  if (!snapshot || typeof snapshot !== 'object') return null;
+  const sourceProjection = snapshot.model_callability;
+  const sourceValidation = validateModelCallabilityV2({
+    projection: sourceProjection,
+    runtime: snapshot.runtime,
+    expectedEnabledRoles: sourceProjection?.enabled_roles,
+    expectedSelections: { worker: snapshot.worker?.selected ?? null, reviewer: snapshot.reviewer?.selected ?? null },
+    now,
+  });
+  if (!sourceValidation.ok) {
+    return projectModelCallability({
+      runtime: snapshot.runtime,
+      selections: { worker: snapshot.worker?.selected, reviewer: snapshot.reviewer?.selected },
+      health: [],
+      health_status: 'UNAVAILABLE',
+      jobs: [],
+      enabled_roles,
+      now,
+    });
+  }
+  const roles = {};
+  for (const role of ['worker', 'reviewer']) {
+    if (enabled_roles?.[role] === false) {
+      roles[role] = { state: 'NOT_APPLICABLE', reason_code: 'ROLE_DISABLED', selected: null, last_success: null };
+    } else if (sourceProjection.enabled_roles?.[role] === true) {
+      roles[role] = structuredClone(sourceProjection.roles[role]);
+    } else {
+      roles[role] = { state: 'UNKNOWN', reason_code: 'ROLE_EVIDENCE_NOT_ENABLED', selected: snapshot[role]?.selected ?? null, last_success: null };
+    }
+  }
+  const activeStates = Object.entries(roles).filter(([role]) => enabled_roles?.[role] === true).map(([, role]) => role.state);
+  const overall = activeStates.includes('NOT_CALLABLE') ? 'NOT_CALLABLE'
+    : activeStates.length > 0 && activeStates.every((state) => state === 'CALLABLE') ? 'CALLABLE'
+      : activeStates.includes('STALE') ? 'STALE' : 'UNKNOWN';
+  const expirations = Object.values(roles).map((role) => role?.expires_at).filter((value) => Number.isFinite(value));
+  const projected = {
+    ...structuredClone(sourceProjection),
+    captured_at: now,
+    enabled_roles: { worker: enabled_roles.worker === true, reviewer: enabled_roles.reviewer === true },
+    roles,
+    overall,
+    expires_at: expirations.length ? Math.min(...expirations) : null,
+  };
+  const validation = validateModelCallabilityV2({
+    projection: projected,
+    runtime: snapshot.runtime,
+    expectedEnabledRoles: projected.enabled_roles,
+    expectedSelections: {
+      worker: enabled_roles.worker === true ? snapshot.worker?.selected ?? null : null,
+      reviewer: enabled_roles.reviewer === true ? snapshot.reviewer?.selected ?? null : null,
+    },
+    now,
+  });
+  if (!validation.ok) {
+    return projectModelCallability({
+      runtime: snapshot.runtime,
+      selections: { worker: snapshot.worker?.selected, reviewer: snapshot.reviewer?.selected },
+      health: [],
+      health_status: 'UNAVAILABLE',
+      jobs: [],
+      enabled_roles,
+      now,
+    });
+  }
+  return projected;
+}

package/src/server.mjs

@@ -9,8 +9,8 @@ import { hubCompatibilityMessage, resolveHubExecutionMode } from './hub-compatib
 import { RUNTIME_VERSION, getHubRuntimeIdentity } from './runtime-identity.mjs';
 import { resolveWorkerModel } from './model-routing.mjs';
 import { runtimeActivationMetadata } from './runtime-controls.mjs';
-import { buildConfigReadinessMatrix } from './config-readiness.mjs';
-import { buildRuntimeReadinessSnapshot } from './runtime-readiness-snapshot.mjs';
+import { buildConfigReadinessMatrix } from './config-readiness.mjs';
+import { buildRuntimeReadinessSnapshot, reprojectRuntimeModelCallability } from './runtime-readiness-snapshot.mjs';
 import { classifyFailure, classifyFailureCode } from './failure-classification.mjs';
 import {
   normalizeGlobalConfig,
@@ -57,9 +57,9 @@ const constraintsSchema = z.object({
 // Initial values come from the global config (~/.config/dsh-crew/config.json,
 // edited on the DSH settings page); dsh_worker_config overrides per session.
 // All dispatch decisions (dsh_run_worker AND dsh_spawn_worker, hub AND
-// production dispatches go through the 3210-only policy resolver in
-// src/policy.mjs; the historical standalone path is retained only for
-// read/migration compatibility and is never selected for execution.
+// production dispatches go through the 3210-only policy resolver in
+// src/policy.mjs; the historical standalone path is retained only for
+// read/migration compatibility and is never selected for execution.
 import { readGlobalConfig } from './install/install.mjs';
 const initialGlobalConfig = normalizeGlobalConfig(readGlobalConfig());
 const legacyDefaults = deriveLegacyConfig(initialGlobalConfig);
@@ -68,7 +68,7 @@ const sessionConfig = {
   enabled: true,
   default_tier: legacyDefaults.default_tier,
   default_effort: legacyDefaults.default_effort,
-  mode: legacyDefaults.mode === 'standalone' ? 'hub' : legacyDefaults.mode, // auto | hub; legacy standalone is migrated to hub
+  mode: legacyDefaults.mode === 'standalone' ? 'hub' : legacyDefaults.mode, // auto | hub; legacy standalone is migrated to hub
   default_timeout_seconds: legacyDefaults.default_timeout_seconds,
   tier_policy: undefined,
   escalate_on_failure: legacyDefaults.escalate_on_failure,
@@ -86,7 +86,7 @@ function resetSessionConfig() {
     enabled: true,
     default_tier: legacyDefaults.default_tier,
     default_effort: legacyDefaults.default_effort,
-    mode: legacyDefaults.mode === 'standalone' ? 'hub' : legacyDefaults.mode,
+    mode: legacyDefaults.mode === 'standalone' ? 'hub' : legacyDefaults.mode,
     default_timeout_seconds: legacyDefaults.default_timeout_seconds,
     tier_policy: undefined,
     escalate_on_failure: legacyDefaults.escalate_on_failure,
@@ -145,9 +145,9 @@ function dispatchDisabled() {
   });
 }
 
-async function resolveMode() {
-  const status = await hubStatus();
-  const decision = resolveHubExecutionMode(sessionConfig.mode, status, { productionOnly: true });
+async function resolveMode() {
+  const status = await hubStatus();
+  const decision = resolveHubExecutionMode(sessionConfig.mode, status, { productionOnly: true });
   if (!decision.ok) {
     throw Object.assign(new Error(decision.error), {
       code: decision.code,
@@ -277,7 +277,7 @@ server.registerTool('dsh_worker_config', {
     enabled: z.boolean().optional().describe('false = refuse all worker dispatch this session'),
     default_tier: z.enum(['flash', 'pro']).optional(),
     default_effort: z.enum(['off', 'high', 'max']).optional(),
-    mode: z.enum(['auto', 'hub']).optional().describe('Execution mode. Production dispatch always uses the isolated 3210 Crew Harness; standalone is retained only as a legacy read/migration value.'),
+    mode: z.enum(['auto', 'hub']).optional().describe('Execution mode. Production dispatch uses the official DeepSeek Harness dsh-crew profile on 3210 with the DSH Crew plugin loaded; standalone is retained only as a legacy read/migration value.'),
     default_timeout_seconds: z.number().int().positive().max(7200).optional(),
     tier_policy: z.enum(['auto', 'flash-only', 'pro-only']).optional().describe('session hard clamp: flash-only / pro-only pin every dispatch to one tier'),
     escalate_on_failure: z.boolean().optional().describe('allow an unverified worker attempt to retry through the stronger model policy (applies to run and spawn)'),
@@ -312,6 +312,24 @@ const SAFE_GLOBAL_KEYS = [
   'preset_flash', 'preset_pro',
 ];
 
+function sameHubRuntimeIdentity(status, extension, snapshot) {
+  const runtime = extension?.runtime;
+  const projected = snapshot?.runtime;
+  return status?.compatible === true
+    && extension?.schema_version === 1
+    && extension?.kind === 'dsh-crew-extension'
+    && snapshot?.schema_version === 1
+    && runtime?.runtime_id === status.runtime_id
+    && runtime?.protocol_version === status.protocol_version
+    && runtime?.execution_plane === status.execution_plane
+    && runtime?.profile === status.profile
+    && runtime?.listen_port === status.listen_port
+    && projected?.runtime_id === runtime.runtime_id
+    && projected?.execution_plane === runtime.execution_plane
+    && projected?.profile === runtime.profile
+    && projected?.listen_port === runtime.listen_port;
+}
+
 async function buildConfigReport() {
   const globalConfig = currentGlobalConfig();
   const legacy = deriveLegacyConfig(globalConfig);
@@ -324,19 +342,27 @@ async function buildConfigReport() {
   const mainAgentMode = sessionConfig.main_agent_mode ?? globalConfig.main_agent_mode;
   const runtimeControls = workflowRuntime.refreshRuntimeControls();
   const activationBoundaries = globalConfig.config_activation ?? runtimeActivationMetadata();
-  const hubCompatibility = await hubStatus({ force: true });
+  const hubCompatibility = await hubStatus({ force: true, base: globalConfig.hub_url });
   let effectiveWorkerProvider = null;
   let effectiveWorkerSelection = { flash: null, pro: null };
   let providerResolutionError;
-  let providerCatalogChecked = false;
-  let providerCatalogBody = null;
-  let providerInventoryChecked = false;
-  let providerInventoryBody = null;
-  let providerHealthChecked = false;
-  let providerHealthBody = null;
-  let hubJobsChecked = false;
-  let hubJobsBody = null;
+  let providerCatalogChecked = false;
+  let providerCatalogBody = null;
+  let hubExtension = null;
+  let hubReadinessSnapshot = null;
   const workerProviderMode = globalConfig.worker_provider_mode ?? 'deepseek-official';
+  if (hubCompatibility.compatible) {
+    try {
+      const extensionRes = await fetch(`${globalConfig.hub_url}/_dsh/dsh-crew/extension`, { signal: AbortSignal.timeout(800) });
+      const extensionBody = await extensionRes.json();
+      const candidateExtension = extensionBody?.extension;
+      const candidateSnapshot = candidateExtension?.readiness_snapshot;
+      if (extensionRes.ok && extensionBody?.ok === true && sameHubRuntimeIdentity(hubCompatibility, candidateExtension, candidateSnapshot)) {
+        hubExtension = candidateExtension;
+        hubReadinessSnapshot = candidateSnapshot;
+      }
+    } catch { /* canonical Hub readiness remains unavailable; fallback stays conservative */ }
+  }
   if (workerProviderMode === 'deepseek-official') {
     effectiveWorkerSelection = {
       flash: { provider: 'deepseek-official', model: 'deepseek-v4-flash', source: 'legacy-strict' },
@@ -369,61 +395,45 @@ async function buildConfigReport() {
   } else if (hubCompatibility.reachable) {
     providerResolutionError = hubCompatibilityMessage(hubCompatibility);
   }
-  if (hubCompatibility.compatible) {
-    try {
-      providerInventoryChecked = true;
-      const inventoryRes = await fetch(`${globalConfig.hub_url}/_dsh/dsh-crew/providers`, { signal: AbortSignal.timeout(800) });
-      providerInventoryBody = inventoryRes.ok
-        ? await inventoryRes.json()
-        : { ok: false, code: 'PROVIDER_INVENTORY_UNAVAILABLE' };
-    } catch {
-      providerInventoryChecked = true;
-      providerInventoryBody = { ok: false, code: 'PROVIDER_INVENTORY_UNAVAILABLE' };
-    }
-  }
-  if (hubCompatibility.compatible) {
-    try {
-      providerHealthChecked = true;
-      const healthRes = await fetch(`${globalConfig.hub_url}/_dsh/dsh-crew/provider-health`, { signal: AbortSignal.timeout(800) });
-      providerHealthBody = healthRes.ok ? await healthRes.json() : { ok: false, code: 'PROVIDER_HEALTH_UNAVAILABLE' };
-    } catch {
-      providerHealthChecked = true;
-      providerHealthBody = { ok: false, code: 'PROVIDER_HEALTH_UNAVAILABLE' };
-    }
-  }
-  if (hubCompatibility.compatible) {
-    try {
-      hubJobsChecked = true;
-      const jobsRes = await fetch(`${globalConfig.hub_url}/_dsh/dsh-crew/jobs`, { signal: AbortSignal.timeout(800) });
-      hubJobsBody = await jobsRes.json();
-    } catch {
-      hubJobsChecked = true;
-    }
-  }
-  effectiveWorkerProvider = effectiveWorkerSelection.flash?.provider ?? null;
-  const readinessMatrix = buildConfigReadinessMatrix({
+  if (hubReadinessSnapshot?.worker?.selected) effectiveWorkerSelection.worker = hubReadinessSnapshot.worker.selected;
+  if (hubReadinessSnapshot?.reviewer?.selected) effectiveWorkerSelection.reviewer = hubReadinessSnapshot.reviewer.selected;
+  effectiveWorkerProvider = effectiveWorkerSelection.worker?.provider ?? effectiveWorkerSelection.flash?.provider ?? null;
+  const fallbackReadinessMatrix = buildConfigReadinessMatrix({
     hubCompatibility,
     workerProviderMode,
-    providerCatalogChecked,
-    providerCatalogBody,
-    providerInventoryChecked,
-    providerInventoryBody,
-    providerHealthChecked,
-    providerHealthBody,
-    hubJobsChecked,
-    hubJobsBody,
+    providerCatalogChecked,
+    providerCatalogBody,
   });
+  const readinessMatrix = hubReadinessSnapshot?.readiness_matrix ?? fallbackReadinessMatrix;
   const roleProfiles = loadRoleProfiles();
-  const workspaceReadiness = await assessWorkspaceReadiness({ cwd: process.cwd() });
-  const readinessSnapshot = buildRuntimeReadinessSnapshot({
-    runtime: getHubRuntimeIdentity(),
-    readinessMatrix,
-    selections: { worker: effectiveWorkerSelection.worker ?? effectiveWorkerSelection.flash, reviewer: effectiveWorkerSelection.reviewer ?? effectiveWorkerSelection.pro },
-    health: providerHealthBody?.health,
-    jobs: hubJobsBody?.jobs,
-    workspace: workspaceReadiness,
-  });
-  const extensionContract = buildExtensionContract({
+  const workspaceReadiness = await assessWorkspaceReadiness({ cwd: process.cwd() });
+  const enabledRoles = {
+    worker: sessionConfig.enabled !== false && globalConfig.subagents_enabled !== false && globalConfig.worker_state !== 'disabled',
+    reviewer: sessionConfig.enabled !== false && globalConfig.subagents_enabled !== false && globalConfig.review_state !== 'disabled',
+  };
+  const readinessSnapshot = hubReadinessSnapshot
+    ? (() => {
+        const snapshot = {
+          ...structuredClone(hubReadinessSnapshot),
+          readiness_matrix: readinessMatrix,
+          workspace: {
+            status: workspaceReadiness.status ?? (workspaceReadiness.ok === true ? 'READY' : 'UNAVAILABLE'),
+            reason_code: workspaceReadiness.reason_code ?? workspaceReadiness.code ?? 'WORKSPACE_NOT_CHECKED',
+          },
+        };
+        const modelCallability = reprojectRuntimeModelCallability(snapshot, { enabled_roles });
+        return modelCallability ? { ...snapshot, model_callability: modelCallability } : snapshot;
+      })()
+    : buildRuntimeReadinessSnapshot({
+        runtime: getHubRuntimeIdentity(),
+        readinessMatrix,
+      selections: { worker: effectiveWorkerSelection.worker ?? effectiveWorkerSelection.flash, reviewer: effectiveWorkerSelection.reviewer ?? effectiveWorkerSelection.pro },
+      health_status: 'UNAVAILABLE',
+      workspace: workspaceReadiness,
+        enabled_roles: enabledRoles,
+      });
+  const extensionRuntime = hubExtension?.runtime ?? getHubRuntimeIdentity();
+  const extensionContract = buildExtensionContract({
     config: {
       ...globalConfig,
       subagents_enabled: sessionConfig.enabled !== false && globalConfig.subagents_enabled !== false,
@@ -431,11 +441,11 @@ async function buildConfigReport() {
       review_state: globalConfig.review_state,
       escalate_on_failure: sessionConfig.escalate_on_failure ?? legacy.escalate_on_failure,
     },
-    readinessMatrix,
-    readinessSnapshot,
+    readinessMatrix,
+    readinessSnapshot,
     workspace: workspaceReadiness,
     profiles: roleProfiles,
-    runtime: getHubRuntimeIdentity(),
+    runtime: extensionRuntime,
   });
   return {
     enabled: sessionConfig.enabled,
@@ -474,8 +484,8 @@ async function buildConfigReport() {
     global_defaults: Object.fromEntries(SAFE_GLOBAL_KEYS.map((k) => [k, globalConfig[k]])),
     runtime_controls: runtimeControls,
     activation_boundaries: activationBoundaries,
-    readiness_matrix: readinessMatrix,
-    readiness_snapshot: readinessSnapshot,
+    readiness_matrix: readinessMatrix,
+    readiness_snapshot: readinessSnapshot,
     role_profiles: roleProfiles,
     extension_contract: extensionContract,
     hub_reachable: hubCompatibility.reachable,

package/src/standalone-sdk.mjs

@@ -0,0 +1,23 @@
+/** Keep Hub-only MCP clients independent of optional standalone host peers. */
+export function createStandaloneHarness(options, { load = () => import('@deepseek-ai/dsh-sdk-client') } = {}) {
+  let loading;
+  let harness;
+  let closed = false;
+  return {
+    async run(...args) {
+      if (closed) throw Error('standalone job cancelled before startup');
+      loading ??= load().catch(error => {
+        if (error?.code !== 'ERR_MODULE_NOT_FOUND' && error?.code !== 'MODULE_NOT_FOUND') throw error;
+        throw Object.assign(new Error('Standalone DSH SDK is unavailable. Repair the Crew-owned installation before using standalone mode; Hub mode does not require this SDK.'), { code: 'STANDALONE_SDK_UNAVAILABLE' });
+      });
+      const { DeepSeekHarness } = await loading;
+      if (closed) throw Error('standalone job cancelled before startup');
+      harness ??= new DeepSeekHarness(options);
+      return harness.run(...args);
+    },
+    async close() {
+      closed = true;
+      if (harness) await harness.close();
+    },
+  };
+}