@pellux/goodvibes-agent 1.2.0 → 1.4.1

package/src/tools/agent-harness-model-provider-health.ts

@@ -6,68 +6,133 @@ import { readBoolean, readFiniteNumber, readRecord, readString, safeIso } from '
 function readPotentialProviderHealthSnapshot(source: unknown): unknown {
   if (!source || typeof source !== 'object') return null;
   const record = source as Record<string, unknown>;
-  const directSnapshot = typeof record.getSnapshot === 'function'
-    ? (record.getSnapshot as () => unknown)()
-    : null;
+  const directSnapshot = ['getSnapshot', 'snapshot', 'list', 'listProviders', 'listRoutes', 'listHealth']
+    .map((method) => {
+      const fn = record[method];
+      if (typeof fn !== 'function') return null;
+      const result = (fn as () => unknown).call(record);
+      return result instanceof Promise ? null : result;
+    })
+    .find((result) => result !== null);
   return directSnapshot ?? record.snapshot ?? record.data ?? record.state ?? source;
 }
 
+const PROVIDER_HEALTH_SECRET_PATTERNS: readonly [RegExp, string][] = [
+  [/("?\b(?:api[-_]?key|apikey|token|secret|password|passwd|credential|authorization)\b"?\s*:\s*)("[^"]*"|'[^']*'|[^\s,}]+)/gi, '$1"<redacted>"'],
+  [/\b([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTHORIZATION|BEARER)[A-Z0-9_]*)=("[^"]*"|'[^']*'|[^\s]+)/gi, '$1=<redacted>'],
+  [/(\b(?:token|secret|password|passwd|api[-_]?key|apikey|authorization|credential)\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,}]+)/gi, '$1<redacted>'],
+  [/(Authorization:\s*Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, '$1<redacted>'],
+];
+
+function redactProviderHealthText(value: string): string {
+  return PROVIDER_HEALTH_SECRET_PATTERNS.reduce((text, [pattern, replacement]) => text.replace(pattern, replacement), value);
+}
+
+function entryWithKey(key: unknown, entry: unknown): Record<string, unknown> {
+  const record = readRecord(entry);
+  const textKey = readString(key);
+  if (!textKey) return record;
+  const looksLikeRoute = textKey.includes(':') || textKey.includes('/');
+  return {
+    ...record,
+    ...(looksLikeRoute ? { modelRouteId: readString(record.modelRouteId) || readString(record.routeId) || textKey } : {}),
+    providerId: readString(record.providerId) || readString(record.provider) || (looksLikeRoute ? readString(record.providerId) : textKey),
+  };
+}
+
+function looksLikeProviderHealthRecord(record: Record<string, unknown>): boolean {
+  return Boolean(
+    readString(record.providerId)
+      || readString(record.provider)
+      || readString(record.modelRouteId)
+      || readString(record.routeId)
+      || readString(record.registryKey)
+      || readString(record.status)
+      || readFiniteNumber(record.avgLatencyMs) !== undefined
+      || Object.keys(readRecord(record.stats)).length > 0,
+  );
+}
+
 function providerHealthCandidatesFromSnapshot(snapshot: unknown): readonly Record<string, unknown>[] {
   if (!snapshot || typeof snapshot !== 'object') return [];
   if (snapshot instanceof Map) {
-    return [...snapshot.entries()].map(([key, entry]) => {
-      const record = readRecord(entry);
-      return { ...record, providerId: readString(record.providerId) || readString(key) };
-    });
+    return [...snapshot.entries()].map(([key, entry]) => entryWithKey(key, entry));
   }
   const record = readRecord(snapshot);
-  const providers = record.providers;
-  const entries = record.entries;
-  if (providers instanceof Map) {
-    return [...providers.entries()].map(([key, entry]) => {
-      const providerRecord = readRecord(entry);
-      return { ...providerRecord, providerId: readString(providerRecord.providerId) || readString(key) };
-    });
-  }
-  if (Array.isArray(providers)) {
-    return providers.map((entry) => readRecord(entry));
-  }
-  if (providers && typeof providers === 'object') {
-    return Object.entries(providers as Record<string, unknown>).map(([key, entry]) => {
-      const providerRecord = readRecord(entry);
-      return { ...providerRecord, providerId: readString(providerRecord.providerId) || key };
-    });
-  }
-  if (entries instanceof Map) {
-    return [...entries.entries()].map(([key, entry]) => {
-      const entryRecord = readRecord(entry);
-      return { ...entryRecord, providerId: readString(entryRecord.providerId) || readString(key) };
-    });
+  for (const key of ['providers', 'providerHealth', 'routes', 'modelRoutes', 'routeHealth', 'providerRoutes', 'records', 'items', 'entries', 'health']) {
+    const value = record[key];
+    if (value instanceof Map) return [...value.entries()].map(([entryKey, entry]) => entryWithKey(entryKey, entry));
+    if (Array.isArray(value)) return value.map((entry) => readRecord(entry));
+    const valueRecord = readRecord(value);
+    if (Object.keys(valueRecord).length > 0) return Object.entries(valueRecord).map(([entryKey, entry]) => entryWithKey(entryKey, entry));
   }
-  if (Array.isArray(entries)) {
-    return entries.map((entry) => readRecord(entry));
-  }
-  return [];
+  return looksLikeProviderHealthRecord(record) ? [record] : [];
 }
 
-function providerHealthCandidateId(candidate: Record<string, unknown>): string {
+function providerHealthCandidateProviderId(candidate: Record<string, unknown>): string {
   return readString(candidate.providerId)
-    || readString(candidate.id)
     || readString(candidate.provider)
-    || readString(candidate.name);
+    || readString(candidate.providerName)
+    || (readString(candidate.id).includes(':') ? '' : readString(candidate.id));
+}
+
+function providerHealthCandidateRouteId(candidate: Record<string, unknown>): string {
+  return readString(candidate.modelRouteId)
+    || readString(candidate.registryKey)
+    || readString(candidate.routeId)
+    || readString(candidate.modelRoute)
+    || (readString(candidate.id).includes(':') ? readString(candidate.id) : '');
+}
+
+function providerHealthCandidateMatchesProvider(candidate: Record<string, unknown>, providerId: string): boolean {
+  return providerHealthCandidateProviderId(candidate) === providerId;
 }
 
 function providerHealthRecordStats(candidate: Record<string, unknown>): Record<string, unknown> {
   return readRecord(candidate.stats);
 }
 
+function providerHealthRecordRateLimit(candidate: Record<string, unknown>): Record<string, unknown> {
+  return readRecord(candidate.rateLimit);
+}
+
+function providerHealthRecordErrors(candidate: Record<string, unknown>): Record<string, unknown> {
+  return readRecord(candidate.errors);
+}
+
+function isoFromUnknown(value: unknown): string | null {
+  const numeric = readFiniteNumber(value);
+  if (numeric !== undefined) return safeIso(numeric);
+  const text = readString(value);
+  if (!text) return null;
+  const parsed = Date.parse(text);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function firstTimestamp(values: readonly unknown[]): string | null {
+  for (const value of values) {
+    const timestamp = isoFromUnknown(value);
+    if (timestamp) return timestamp;
+  }
+  return null;
+}
+
 function providerHealthTimestamp(candidate: Record<string, unknown>, stats: Record<string, unknown>, key: string): string | null {
-  return safeIso(readFiniteNumber(candidate[key]) ?? readFiniteNumber(stats[key]));
+  return firstTimestamp([candidate[key], stats[key]]);
+}
+
+function nestedNumber(candidate: Record<string, unknown>, stats: Record<string, unknown>, nested: Record<string, unknown>, keys: readonly string[]): number | undefined {
+  for (const key of keys) {
+    const value = readFiniteNumber(candidate[key]) ?? readFiniteNumber(stats[key]) ?? readFiniteNumber(nested[key]);
+    if (value !== undefined) return value;
+  }
+  return undefined;
 }
 
-export function readProviderHealthSignal(context: CommandContext, providerId: string): ModelProviderHealthSignal {
+export function readProviderHealthSignal(context: CommandContext, providerId: string, modelRouteId?: string): ModelProviderHealthSignal {
   const base: Omit<ModelProviderHealthSignal, 'status' | 'daemonPublication' | 'agentConsumption' | 'missingSignals' | 'policy'> = {
     providerId,
+    ...(modelRouteId ? { modelRouteId } : {}),
     sdkContract: {
       providerHealthTypes: 'available',
       importSurface: '@pellux/goodvibes-sdk/platform/runtime/ui',
@@ -77,10 +142,17 @@ export function readProviderHealthSignal(context: CommandContext, providerId: st
   const policy = 'Provider health is live route-condition evidence. Local benchmark artifacts remain separate task-fit evidence and must not be treated as provider-health publication.';
   const platform = context.platform as unknown as Record<string, unknown>;
   const readModels = readRecord(platform.readModels);
+  const clients = readRecord(context.clients as unknown as Record<string, unknown>);
+  const operator = readRecord(clients.operator);
   const sourceEntries: readonly { readonly path: string; readonly source: unknown }[] = [
     { path: 'context.platform.readModels.providerHealth', source: readModels.providerHealth },
     { path: 'context.platform.readModels.providersHealth', source: readModels.providersHealth },
+    { path: 'context.platform.readModels.modelRouteHealth', source: readModels.modelRouteHealth },
+    { path: 'context.platform.readModels.routeHealth', source: readModels.routeHealth },
+    { path: 'context.platform.readModels.models.providerHealth', source: readRecord(readModels.models).providerHealth },
+    { path: 'context.platform.readModels.models.routeHealth', source: readRecord(readModels.models).routeHealth },
     { path: 'context.platform.providerHealth', source: platform.providerHealth },
+    { path: 'context.clients.operator.providerHealth', source: operator.providerHealth },
   ];
 
   for (const entry of sourceEntries) {
@@ -88,7 +160,10 @@ export function readProviderHealthSignal(context: CommandContext, providerId: st
     try {
       const snapshot = readPotentialProviderHealthSnapshot(entry.source);
       const candidates = providerHealthCandidatesFromSnapshot(snapshot);
-      const candidate = candidates.find((item) => providerHealthCandidateId(item) === providerId);
+      const candidate = (modelRouteId
+        ? candidates.find((item) => providerHealthCandidateRouteId(item) === modelRouteId)
+        : undefined)
+        ?? candidates.find((item) => providerHealthCandidateMatchesProvider(item, providerId));
       if (!candidate) {
         return {
           ...base,
@@ -109,10 +184,24 @@ export function readProviderHealthSignal(context: CommandContext, providerId: st
       }
 
       const stats = providerHealthRecordStats(candidate);
+      const rateLimit = providerHealthRecordRateLimit(candidate);
+      const errors = providerHealthRecordErrors(candidate);
       const avgLatencyMs = readFiniteNumber(candidate.avgLatencyMs) ?? readFiniteNumber(stats.avgLatencyMs);
       const minLatencyMs = readFiniteNumber(candidate.minLatencyMs) ?? readFiniteNumber(stats.minLatencyMs);
       const maxLatencyMs = readFiniteNumber(candidate.maxLatencyMs) ?? readFiniteNumber(candidate.p95LatencyMs) ?? readFiniteNumber(stats.maxLatencyMs);
       const healthStatus = readString(candidate.status) || 'unknown';
+      const rateLimitRemaining = nestedNumber(candidate, stats, rateLimit, ['rateLimitRemaining', 'remaining', 'requestsRemaining']);
+      const rateLimitLimit = nestedNumber(candidate, stats, rateLimit, ['rateLimitLimit', 'limit', 'requestsLimit']);
+      const rateLimitResetAt = firstTimestamp([candidate.rateLimitResetAt, stats.rateLimitResetAt, rateLimit.resetAt, rateLimit.resetsAt]);
+      const lastErrorAt = firstTimestamp([candidate.lastErrorAt, stats.lastErrorAt, errors.lastErrorAt]);
+      const lastErrorMessage = readString(candidate.lastErrorMessage)
+        || readString(stats.lastErrorMessage)
+        || readString(errors.lastErrorMessage)
+        || readString(errors.message);
+      const errorRate = nestedNumber(candidate, stats, errors, ['errorRate', 'recentErrorRate']);
+      const consecutiveErrors = nestedNumber(candidate, stats, errors, ['consecutiveErrors', 'failureStreak']);
+      const hasRateLimitPosture = rateLimitRemaining !== undefined || rateLimitLimit !== undefined || rateLimitResetAt !== null;
+      const hasErrorPosture = lastErrorAt !== null || lastErrorMessage || errorRate !== undefined || consecutiveErrors !== undefined;
       return {
         ...base,
         status: 'record-found',
@@ -126,6 +215,8 @@ export function readProviderHealthSignal(context: CommandContext, providerId: st
           readModelPath: entry.path,
           evidence: 'Agent consumed the published provider-health record for exact model-route readiness.',
         },
+        sourceRecordId: readString(candidate.recordId) || readString(candidate.id) || providerHealthCandidateRouteId(candidate) || providerHealthCandidateProviderId(candidate),
+        ...(providerHealthCandidateRouteId(candidate) ? { modelRouteId: providerHealthCandidateRouteId(candidate) } : {}),
         healthStatus,
         isConfigured: readBoolean(candidate.isConfigured),
         isActive: readBoolean(candidate.isActive),
@@ -133,14 +224,20 @@ export function readProviderHealthSignal(context: CommandContext, providerId: st
         minLatencyMs,
         maxLatencyMs,
         lastSuccessAt: providerHealthTimestamp(candidate, stats, 'lastSuccessAt'),
-        lastErrorAt: providerHealthTimestamp(candidate, stats, 'lastErrorAt'),
-        lastErrorMessage: readString(candidate.lastErrorMessage) || readString(stats.lastErrorMessage) || undefined,
+        lastErrorAt,
+        lastErrorMessage: lastErrorMessage ? previewHarnessText(redactProviderHealthText(lastErrorMessage), 160) : undefined,
+        errorRate,
+        consecutiveErrors,
         lastCheckedAt: providerHealthTimestamp(candidate, stats, 'lastCheckedAt'),
-        rateLimitResetAt: providerHealthTimestamp(candidate, stats, 'rateLimitResetAt'),
+        rateLimitResetAt,
+        rateLimitRemaining,
+        rateLimitLimit,
         missingSignals: [
           ...(avgLatencyMs === undefined ? ['Provider-health record did not include average latency.'] : []),
           ...(minLatencyMs === undefined ? ['Provider-health record did not include minimum latency.'] : []),
           ...(maxLatencyMs === undefined ? ['Provider-health record did not include maximum or p95 latency.'] : []),
+          ...(hasRateLimitPosture ? [] : ['Provider-health record did not include rate-limit posture.']),
+          ...(hasErrorPosture ? [] : ['Provider-health record did not include error posture.']),
         ],
         policy,
       };

package/src/tools/agent-harness-model-readiness.ts

@@ -3,7 +3,7 @@ import type { CommandContext } from '../input/command-registry.ts';
 import { previewHarnessText } from './agent-harness-text.ts';
 import { readProviderHealthSignal } from './agent-harness-model-provider-health.ts';
 import { localStackFor } from './agent-harness-local-model-endpoints.ts';
-import type { LocalModelBenchmarkEvidence, LocalModelDetection, LocalModelHardwareProfile, LocalModelRecipe, LocalModelRecipeFit, ModelCandidate, ModelReadinessDimension, ModelReadinessScore, ModelRouteReadinessScore, ModelProviderHealthSignal } from './agent-harness-model-routing-types.ts';
+import type { LocalModelBenchmarkEvidence, LocalModelBenchmarkRouteLatency, LocalModelDetection, LocalModelHardwareProfile, LocalModelRecipe, LocalModelRecipeFit, ModelCandidate, ModelReadinessDimension, ModelReadinessScore, ModelRouteReadinessScore, ModelProviderHealthSignal } from './agent-harness-model-routing-types.ts';
 import { readRecord } from './agent-harness-model-routing-utils.ts';
 
 export function localRecipeStackId(recipe: LocalModelRecipe): string {
@@ -169,6 +169,7 @@ export function latencyScore(
   local: boolean,
   benchmarkCompositeScore: number | null | undefined,
   providerHealth: ModelProviderHealthSignal,
+  localBenchmarkLatency: LocalModelBenchmarkRouteLatency | null | undefined,
 ): ModelReadinessDimension {
   const liveLatency = providerHealth.status === 'record-found' ? providerHealth.avgLatencyMs : undefined;
   if (liveLatency !== undefined) {
@@ -196,6 +197,24 @@ export function latencyScore(
     };
   }
 
+  if (localBenchmarkLatency && localBenchmarkLatency.status !== 'failed') {
+    const latency = localBenchmarkLatency.latencyMs;
+    const score = latency <= 750
+      ? 93
+      : latency <= 1500
+        ? 84
+        : latency <= 3000
+          ? 70
+          : 54;
+    return {
+      id: 'latency',
+      label: 'Latency',
+      score,
+      weight: 20,
+      summary: `Measured local benchmark latency is ${latency} ms from ${localBenchmarkLatency.artifactId}${localBenchmarkLatency.comparisonId ? ` (${localBenchmarkLatency.comparisonId})` : ''}.`,
+    };
+  }
+
   const score = local
     ? 55
     : benchmarkCompositeScore != null
@@ -222,9 +241,9 @@ export function weightedReadiness(dimensions: readonly ModelReadinessDimension[]
 
 export function modelReadinessScore(context: CommandContext, model: ModelCandidate): ModelRouteReadinessScore {
   const local = isLocalCandidate([model.providerId, model.registryKey, model.modelId, model.displayName]);
-  const providerHealth = readProviderHealthSignal(context, model.providerId);
+  const providerHealth = readProviderHealthSignal(context, model.providerId, model.registryKey);
   const dimensions: readonly ModelReadinessDimension[] = [
-    latencyScore(local, model.benchmarkCompositeScore, providerHealth),
+    latencyScore(local, model.benchmarkCompositeScore, providerHealth, model.localBenchmarkLatency),
     contextWindowScore(model.contextWindow),
     toolSupportScore(model.capabilities),
     visionScore(model.capabilities),
@@ -233,9 +252,10 @@ export function modelReadinessScore(context: CommandContext, model: ModelCandida
   ];
   const score = weightedReadiness(dimensions);
   const hasLiveLatency = providerHealth.status === 'record-found' && providerHealth.avgLatencyMs !== undefined;
+  const hasBenchmarkLatency = Boolean(model.localBenchmarkLatency && model.localBenchmarkLatency.status !== 'failed');
   const missingSignals = [
     ...providerHealth.missingSignals,
-    ...(hasLiveLatency ? [] : ['No live latency benchmark has been recorded for this Agent route.']),
+    ...(hasLiveLatency || hasBenchmarkLatency ? [] : ['No live latency benchmark has been recorded for this Agent route.']),
     ...(model.contextWindow == null ? ['Context-window metadata is missing.'] : []),
     ...(capabilityEnabled(model.capabilities, 'toolCalling') == null ? ['Tool-calling support is unknown.'] : []),
     ...(capabilityEnabled(model.capabilities, 'multimodal') == null ? ['Vision support is unknown.'] : []),
@@ -246,6 +266,8 @@ export function modelReadinessScore(context: CommandContext, model: ModelCandida
     level: modelReadinessLevel(score),
     confidence: providerHealth.status === 'record-found' && missingSignals.length === 0
       ? 'provider-health-backed'
+      : hasBenchmarkLatency && missingSignals.length === 0
+        ? 'measured'
       : missingSignals.length === 0
         ? 'metadata-backed'
         : 'estimated',
@@ -253,9 +275,13 @@ export function modelReadinessScore(context: CommandContext, model: ModelCandida
     missingSignals,
     providerHealth,
     nextStep: local
-      ? 'Run the local benchmark prompt before making this route the default.'
+      ? hasBenchmarkLatency
+        ? `Review local benchmark latency evidence ${model.localBenchmarkLatency?.artifactId}, then use a separate confirmed apply/update route only if the user wants this route as default.`
+        : 'Run the local benchmark prompt before making this route the default.'
       : providerHealth.status === 'record-found'
         ? 'Use provider-health-backed route posture for triage; run a task-specific comparison before changing the default model.'
+        : hasBenchmarkLatency
+          ? `Review benchmark latency evidence ${model.localBenchmarkLatency?.artifactId}; wait for daemon provider-health publication for live status, rate-limit, and error posture before changing defaults.`
         : 'Use this score for routing triage; wait for daemon provider-health publication or run a task-specific comparison before changing the default model.',
   };
 }

package/src/tools/agent-harness-model-routing-types.ts

@@ -31,6 +31,7 @@ export interface ModelCandidate {
   readonly tier?: string;
   readonly benchmarkCompositeScore?: number | null;
   readonly benchmarkQualityTier?: string;
+  readonly localBenchmarkLatency?: LocalModelBenchmarkRouteLatency | null;
   readonly pinned: boolean;
 }
 
@@ -92,6 +93,8 @@ export interface ModelReadinessDimension {
 export interface ModelProviderHealthSignal {
   readonly status: 'not-reachable-in-command-context' | 'read-model-empty' | 'read-model-error' | 'record-found';
   readonly providerId: string;
+  readonly modelRouteId?: string;
+  readonly sourceRecordId?: string;
   readonly sdkContract: {
     readonly providerHealthTypes: 'available';
     readonly importSurface: string;
@@ -116,8 +119,12 @@ export interface ModelProviderHealthSignal {
   readonly lastSuccessAt?: string | null;
   readonly lastErrorAt?: string | null;
   readonly lastErrorMessage?: string;
+  readonly errorRate?: number;
+  readonly consecutiveErrors?: number;
   readonly lastCheckedAt?: string | null;
   readonly rateLimitResetAt?: string | null;
+  readonly rateLimitRemaining?: number;
+  readonly rateLimitLimit?: number;
   readonly missingSignals: readonly string[];
   readonly policy: string;
 }
@@ -157,6 +164,20 @@ export interface LocalModelBenchmarkWinner {
   readonly applyRoute: string;
 }
 
+export interface LocalModelBenchmarkRouteLatency {
+  readonly registryKey: string;
+  readonly providerId: string;
+  readonly modelId: string;
+  readonly displayName: string;
+  readonly blindId: string;
+  readonly latencyMs: number;
+  readonly status: string;
+  readonly artifactId: string;
+  readonly comparisonId: string | null;
+  readonly createdAt: string | null;
+  readonly reviewRoute: string;
+}
+
 export interface LocalModelBenchmarkEvidence {
   readonly status: 'unavailable' | 'unmeasured' | 'comparison-saved' | 'reviewed-winner';
   readonly comparisonCount: number;
@@ -165,6 +186,7 @@ export interface LocalModelBenchmarkEvidence {
   readonly hiddenJudgmentCount: number;
   readonly winnerStacks: readonly string[];
   readonly winnerModels: readonly LocalModelBenchmarkWinner[];
+  readonly routeLatencies: readonly LocalModelBenchmarkRouteLatency[];
   readonly summary: string;
   readonly confidence: 'estimated' | 'measured';
 }
@@ -188,6 +210,7 @@ export interface LocalModelServerEndpoint {
   readonly refreshRoute: string;
   readonly addProviderRoute: string | null;
   readonly notes: readonly string[];
+  readonly servingDiagnostics?: LocalModelServerServingDiagnostics;
   readonly diagnostics?: {
     readonly liveProbe: 'not-run';
     readonly successCriteria: readonly string[];
@@ -197,6 +220,43 @@ export interface LocalModelServerEndpoint {
   };
 }
 
+export interface LocalModelServerServingDiagnostics {
+  readonly status: 'ready' | 'attention' | 'blocked' | 'unknown';
+  readonly source: string;
+  readonly summary: string;
+  readonly schemaStatus?: 'certified' | 'legacy';
+  readonly schemaVersion?: string;
+  readonly provenance?: readonly string[];
+  readonly publicationGuarantee?: string;
+  readonly publisher?: string;
+  readonly serverVersion?: string;
+  readonly loadedModelCount?: number;
+  readonly loadedModels: readonly string[];
+  readonly contextWindowTokens?: number;
+  readonly toolSupport?: boolean;
+  readonly resourcePressure: 'low' | 'moderate' | 'high' | 'unknown';
+  readonly resourceSummary?: string;
+  readonly lastCheckedAt?: string | null;
+  readonly startReceiptId?: string;
+  readonly repairReceiptId?: string;
+  readonly receiptStatus?: string;
+  readonly startRoute?: string;
+  readonly repairRoute?: string;
+  readonly inspectRoute: string;
+  readonly missingSignals: readonly string[];
+  readonly policy: string;
+}
+
+export interface LocalModelServerDiagnosticsPublication {
+  readonly status: 'not-published' | 'published-read-model' | 'read-model-empty' | 'read-model-error';
+  readonly requiredPaths: readonly string[];
+  readonly sourcePaths: readonly string[];
+  readonly recordCount: number;
+  readonly matchedEndpointCount: number;
+  readonly missingSignals: readonly string[];
+  readonly policy: string;
+}
+
 export interface LocalModelServerDefaultEndpoint {
   readonly id: string;
   readonly label: string;
@@ -215,6 +275,7 @@ export interface LocalModelServerHealthMap {
   readonly returnedEndpoints: number;
   readonly endpoints: readonly LocalModelServerEndpoint[];
   readonly suggestedDefaults: readonly LocalModelServerDefaultEndpoint[];
+  readonly daemonDiagnostics: LocalModelServerDiagnosticsPublication;
   readonly nextActions: readonly string[];
   readonly policy: string;
 }

package/src/tools/agent-harness-model-routing.ts

@@ -4,14 +4,16 @@ import type { CommandContext } from '../input/command-registry.ts';
 import { requireProviderApi } from '../input/commands/runtime-services.ts';
 import { previewHarnessText } from './agent-harness-text.ts';
 import { localModelCookbook } from './agent-harness-local-model-cookbook.ts';
-import { collectLocalServerEndpointCandidates, describeLocalServerEndpoint, localModelDetection, localModelServerHealthMap, runLocalModelServerSmoke } from './agent-harness-local-model-endpoints.ts';
+import { localBenchmarkRouteLatencyMap } from './agent-harness-local-model-benchmarks.ts';
+import { localModelDetection, localModelServerEndpoints, localModelServerHealthMap } from './agent-harness-local-model-endpoints.ts';
+import { runLocalModelServerSmoke } from './agent-harness-local-model-smoke.ts';
 import { localHardwareProfile, modelReadinessScore } from './agent-harness-model-readiness.ts';
 import { contextWindowFor, loadModels, listProviderIds, modelBenchmarkCompositeScore, modelBenchmarkQualityTier, modelCapabilities, modelCurrent, modelDisplayName, modelModelId, modelProviderId, modelReasoning, modelRegistryKey, modelTier, readConfig, readProviderApi } from './agent-harness-model-catalog.ts';
 import type { AgentHarnessModelRoutingArgs, LocalModelServerEndpoint, ModelCandidate, ModelProviderHealthSignal, ModelRouteLookupSource, ModelRouteResolution, RouteCandidate } from './agent-harness-model-routing-types.ts';
 import { readLimit, readString } from './agent-harness-model-routing-utils.ts';
 export type { AgentHarnessModelRoutingArgs } from './agent-harness-model-routing-types.ts';
 export { localModelCookbook } from './agent-harness-local-model-cookbook.ts';
-export { runLocalModelServerSmoke } from './agent-harness-local-model-endpoints.ts';
+export { runLocalModelServerSmoke } from './agent-harness-local-model-smoke.ts';
 
 async function readCurrentModel(context: CommandContext): Promise<unknown> {
   try {
@@ -21,6 +23,15 @@ async function readCurrentModel(context: CommandContext): Promise<unknown> {
   }
 }
 
+function attachLocalBenchmarkLatencies(context: CommandContext, models: readonly ModelCandidate[]): readonly ModelCandidate[] {
+  const latencies = localBenchmarkRouteLatencyMap(context);
+  if (latencies.size === 0) return models;
+  return models.map((model) => ({
+    ...model,
+    localBenchmarkLatency: latencies.get(model.registryKey) ?? null,
+  }));
+}
+
 function routeCandidates(context: CommandContext): readonly RouteCandidate[] {
   return [
     {
@@ -238,7 +249,12 @@ function compactProviderHealthSignal(signal: ModelProviderHealthSignal): Record<
     daemonPublication: signal.daemonPublication,
     agentConsumption: signal.agentConsumption,
     ...(signal.healthStatus ? { healthStatus: signal.healthStatus } : {}),
+    ...(signal.modelRouteId ? { modelRouteId: signal.modelRouteId } : {}),
+    ...(signal.sourceRecordId ? { sourceRecordId: signal.sourceRecordId } : {}),
     ...(signal.avgLatencyMs !== undefined ? { avgLatencyMs: signal.avgLatencyMs } : {}),
+    ...(signal.rateLimitRemaining !== undefined ? { rateLimitRemaining: signal.rateLimitRemaining } : {}),
+    ...(signal.rateLimitResetAt ? { rateLimitResetAt: signal.rateLimitResetAt } : {}),
+    ...(signal.lastErrorMessage ? { lastErrorMessage: signal.lastErrorMessage } : {}),
     missingSignals: signal.missingSignals,
     policy: signal.policy,
   };
@@ -260,6 +276,7 @@ function describeModel(model: ModelCandidate, options: { readonly context: Comma
     tier: model.tier ?? null,
     benchmarkCompositeScore: model.benchmarkCompositeScore ?? null,
     benchmarkQualityTier: model.benchmarkQualityTier ?? null,
+    localBenchmarkLatency: model.localBenchmarkLatency ?? null,
     readinessScore: readiness.score,
     readinessLevel: readiness.level,
     readiness: options.includeParameters
@@ -330,10 +347,11 @@ function modelCandidateModelRoute(): string {
 }
 
 export async function modelRoutingCatalogStatus(context: CommandContext): Promise<Record<string, unknown>> {
-  const [models, providerIds] = await Promise.all([
+  const [rawModels, providerIds] = await Promise.all([
     loadModels(context),
     Promise.resolve(listProviderIds(context)),
   ]);
+  const models = attachLocalBenchmarkLatencies(context, rawModels);
   return {
     modes: ['model_routing', 'model_route'],
     status: readProviderApi(context) ? 'available' : 'degraded',
@@ -349,15 +367,20 @@ export async function modelRoutingCatalogStatus(context: CommandContext): Promis
 export async function modelRoutingSummary(context: CommandContext, args: AgentHarnessModelRoutingArgs): Promise<Record<string, unknown>> {
   const query = readString(args.query).toLowerCase();
   const includeParameters = args.includeParameters === true;
-  const [models, providerIds, currentModel] = await Promise.all([
+  const [rawModels, providerIds, currentModel] = await Promise.all([
     loadModels(context),
     Promise.resolve(listProviderIds(context)),
     readCurrentModel(context),
   ]);
+  const models = attachLocalBenchmarkLatencies(context, rawModels);
   const routes = routeCandidates(context);
   const filteredRoutes = routes.filter((route) => !query || routeSearchText(route).includes(query));
   const filteredModels = models.filter((model) => !query || modelSearchText(model).includes(query));
   const limit = readLimit(args.limit, 100);
+  const currentRegistryKey = currentModel ? modelRegistryKey(currentModel) : '';
+  const loadedCurrentModel = currentRegistryKey
+    ? models.find((model) => model.registryKey === currentRegistryKey || model.modelId === modelModelId(currentModel))
+    : null;
   return {
     status: readProviderApi(context) ? 'available' : 'degraded',
     current: {
@@ -378,6 +401,7 @@ export async function modelRoutingSummary(context: CommandContext, args: AgentHa
         tier: modelTier(currentModel),
         benchmarkCompositeScore: modelBenchmarkCompositeScore(currentModel),
         benchmarkQualityTier: modelBenchmarkQualityTier(currentModel),
+        localBenchmarkLatency: loadedCurrentModel?.localBenchmarkLatency ?? null,
         pinned: false,
       }, { context, includeParameters }) : null,
     },
@@ -410,9 +434,10 @@ export async function describeHarnessModelRoute(context: CommandContext, args: A
       usage: 'model_route requires modelRouteId, target, or query. Prefer models action:"status" to inspect route, model, and local endpoint ids.',
     };
   }
-  const [models] = await Promise.all([loadModels(context)]);
+  const [rawModels] = await Promise.all([loadModels(context)]);
+  const models = attachLocalBenchmarkLatencies(context, rawModels);
   const routes = routeCandidates(context);
-  const endpoints = collectLocalServerEndpointCandidates(context).map((endpoint) => describeLocalServerEndpoint(endpoint, true));
+  const endpoints = localModelServerEndpoints(context, true);
   const normalized = lookup.input.toLowerCase();
   const exactRoute = routes.find((route) => route.id === lookup.input);
   if (exactRoute) return { status: 'found', route: describeRoute(exactRoute, { context, includeParameters: true, lookup: { ...lookup, resolvedBy: 'route-id' } }) };

package/src/tools/agent-harness-pairing-posture.ts

@@ -7,6 +7,7 @@ import { buildAgentWorkspaceChannels } from '../input/agent-workspace-channels.t
 import { buildAgentWorkspaceVoiceMediaReadiness } from '../input/agent-workspace-voice-media.ts';
 import { requirePlatform, requireShellPaths } from '../input/commands/runtime-services.ts';
 import { browserControlPosture } from './agent-harness-browser-control.ts';
+import { certifiedDeviceLiveRecords, deviceLiveReadModelSnapshot } from './agent-harness-device-live-read-models.ts';
 import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessPairingArgs {
@@ -370,6 +371,10 @@ function queryRequestsWholeDeviceMap(query: string): boolean {
   return tokens.includes('device') && (tokens.includes('capability') || tokens.includes('capabilities') || tokens.includes('map'));
 }
 
+function liveDeviceEvidence(records: ReturnType<typeof certifiedDeviceLiveRecords>): Record<string, unknown> | undefined {
+  return records.length > 0 ? { certifiedLiveRecords: records.slice(0, 5) } : undefined;
+}
+
 function buildDeviceCapabilityMap(context: CommandContext): DeviceCapabilityMap {
   const state = pairingState(context);
   const hasToken = tokenPresent(state);
@@ -389,6 +394,9 @@ function buildDeviceCapabilityMap(context: CommandContext): DeviceCapabilityMap
   const enabledChannels = channels.filter((channel) => channel.enabled);
   const notificationWebhookCount = readConfigStringArray(context, 'notifications.webhookUrls').length;
   const browserPosture = browserControlPosture(context);
+  const liveDevice = deviceLiveReadModelSnapshot(context);
+  const sensorRecords = certifiedDeviceLiveRecords(liveDevice, 'camera-location-sensors', ['camera', 'location', 'screen', 'device command', 'sensor']);
+  const sensorReady = sensorRecords.length > 0;
   const ttsStatus: DeviceCapabilityStatus = voiceReadiness.selectedTtsProviderStatus === 'ready' && voiceReadiness.ttsVoiceConfigured
     ? 'ready'
     : voiceReadiness.selectedTtsProviderStatus === 'ready' || voiceReadiness.selectedTtsProviderStatus === 'registered'
@@ -575,22 +583,35 @@ function buildDeviceCapabilityMap(context: CommandContext): DeviceCapabilityMap
     },
     {
       id: 'camera-location-sensors',
-      label: 'Camera and location sensors',
+      label: 'Camera, screen, and location sensors',
       domain: 'device',
-      status: 'not-published',
-      userOutcome: 'Use phone camera or location only after the daemon/companion publishes permission-scoped records.',
-      summary: 'Camera and location sensor adapters are not published by the current Agent-visible SDK/daemon contract.',
-      nextStep: 'Inspect operator methods for newly published camera/location contracts before claiming device access.',
-      capabilities: ['camera permission posture', 'location permission posture', 'device sensor commands'],
-      modelRoute: 'host action:"methods" query:"camera location device"',
+      status: sensorReady ? 'ready' : 'not-published',
+      userOutcome: 'Use phone camera, screen, location, or local device commands only after the daemon/companion publishes permission-scoped records.',
+      summary: sensorReady
+        ? 'The SDK/daemon published certified permission-scoped camera, screen, location, or device-command capability records.'
+        : 'Camera, screen, location, and device-command adapters are not published by the current Agent-visible SDK/daemon contract.',
+      nextStep: sensorReady
+        ? 'Inspect the certified device record and use only its returned confirmed permission/control routes.'
+        : 'Inspect operator methods for newly published camera/location/screen contracts before claiming device access.',
+      capabilities: [
+        'camera permission posture',
+        'screen capture permission posture',
+        'location permission posture',
+        'local device command routes',
+        ...sensorRecords.flatMap((record) => record.capabilities),
+      ],
+      modelRoute: sensorRecords[0]?.modelRoute ?? 'host action:"methods" query:"camera location device"',
       setupRoutes: [
+        ...sensorRecords.slice(0, 3).map((record) => record.modelRoute),
         'host action:"methods" query:"camera location device"',
         'host action:"capabilities" includeParameters:true',
       ],
       evidence: {
-        publishedByCurrentAgentContract: false,
+        publishedByCurrentAgentContract: sensorReady,
+        liveDeviceRecords: liveDevice.capabilities.length,
+        ...liveDeviceEvidence(sensorRecords),
       },
-      policy: 'Agent reports unpublished device sensor APIs honestly instead of simulating camera or location access.',
+      policy: 'Agent reports unpublished device sensor APIs honestly and counts device access only when certified SDK/daemon permission-scoped records publish exact routes without raw payloads.',
     },
   ];
   capabilities.sort((left, right) => deviceStatusRank(left.status) - deviceStatusRank(right.status) || left.label.localeCompare(right.label));