@ran-sh/dsh-crew 1.9.0 → 1.10.0

package/src/provider-store-lock.mjs

@@ -1,67 +1,67 @@
-// Persistent token-fenced lock shared by every lifecycle operation that can
-// mutate the Harness profile/settings stores. A stale lock is reclaimed only
-// while a serialized claim is held; malformed metadata fails closed.
-
-import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, resolve as resolvePath } from 'node:path';
-
-function safeToken(value) { return typeof value === 'string' && /^[A-Za-z0-9-]{16,128}$/u.test(value); }
-function readOwner(file) {
-  try {
-    const owner = JSON.parse(readFileSync(file, 'utf8'));
-    if (!owner || typeof owner !== 'object' || Array.isArray(owner) || !Number.isInteger(owner.pid) || owner.pid <= 0 || !safeToken(owner.token)) return { ok: false, malformed: true };
-    return { ok: true, owner };
-  } catch { return { ok: false, malformed: true }; }
-}
-function processAlive(pid) {
-  try { process.kill(pid, 0); return true; } catch (error) { return error?.code === 'EPERM'; }
-}
-
-export async function acquireProviderStoreLock(file) {
-  if (typeof file !== 'string' || !file.trim()) throw Object.assign(new Error('provider store lock path is required'), { code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' });
-  const lockFile = resolvePath(file);
-  mkdirSync(dirname(lockFile), { recursive: true });
-  const claimFile = `${lockFile}.claim`;
-  const token = randomUUID();
-  let claimed = false;
-  try {
-    try { mkdirSync(claimFile); claimed = true; }
-    catch (error) { throw Object.assign(new Error('provider store lock is busy'), { code: error?.code === 'EEXIST' ? 'PROVIDER_STORE_LOCK_BUSY' : 'PROVIDER_STORE_LOCK_UNAVAILABLE' }); }
-    while (true) {
-      try {
-        writeFileSync(lockFile, JSON.stringify({ pid: process.pid, token, created_at: new Date().toISOString() }) + '\n', { flag: 'wx' });
-        return {
-          ok: true,
-          token,
-          release: async () => {
-            const current = readOwner(lockFile);
-            if (current.ok && current.owner.token === token) rmSync(lockFile, { force: true });
-          },
-        };
-      } catch (error) {
-        if (error?.code !== 'EEXIST') throw Object.assign(new Error('provider store lock is unavailable'), { code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' });
-        const current = readOwner(lockFile);
-        if (!current.ok) throw Object.assign(new Error('provider store lock metadata is invalid'), { code: 'PROVIDER_STORE_LOCK_BUSY' });
-        if (processAlive(current.owner.pid)) throw Object.assign(new Error('provider store lock is busy'), { code: 'PROVIDER_STORE_LOCK_BUSY' });
-        rmSync(lockFile, { force: true });
-      }
-    }
-  } finally { if (claimed) rmSync(claimFile, { recursive: true, force: true }); }
-}
-
-export async function recoverProviderStoreLock(file, { confirm = false } = {}) {
-  if (confirm !== true) return { ok: false, code: 'PROVIDER_STORE_LOCK_CONFIRM_REQUIRED' };
-  if (typeof file !== 'string' || !file.trim()) return { ok: false, code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' };
-  const lockFile = resolvePath(file);
-  const claimFile = `${lockFile}.claim`;
-  try { mkdirSync(dirname(lockFile), { recursive: true }); mkdirSync(claimFile); }
-  catch (error) { return { ok: false, code: error?.code === 'EEXIST' ? 'PROVIDER_STORE_LOCK_BUSY' : 'PROVIDER_STORE_LOCK_UNAVAILABLE' }; }
-  try {
-    if (!existsSync(lockFile)) return { ok: true, recovered: false };
-    const current = readOwner(lockFile);
-    if (current.ok && processAlive(current.owner.pid)) return { ok: false, code: 'PROVIDER_STORE_LOCK_BUSY' };
-    rmSync(lockFile, { force: true });
-    return { ok: true, recovered: true };
-  } finally { rmSync(claimFile, { recursive: true, force: true }); }
-}
+// Persistent token-fenced lock shared by every lifecycle operation that can
+// mutate the Harness profile/settings stores. A stale lock is reclaimed only
+// while a serialized claim is held; malformed metadata fails closed.
+
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, resolve as resolvePath } from 'node:path';
+
+function safeToken(value) { return typeof value === 'string' && /^[A-Za-z0-9-]{16,128}$/u.test(value); }
+function readOwner(file) {
+  try {
+    const owner = JSON.parse(readFileSync(file, 'utf8'));
+    if (!owner || typeof owner !== 'object' || Array.isArray(owner) || !Number.isInteger(owner.pid) || owner.pid <= 0 || !safeToken(owner.token)) return { ok: false, malformed: true };
+    return { ok: true, owner };
+  } catch { return { ok: false, malformed: true }; }
+}
+function processAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (error) { return error?.code === 'EPERM'; }
+}
+
+export async function acquireProviderStoreLock(file) {
+  if (typeof file !== 'string' || !file.trim()) throw Object.assign(new Error('provider store lock path is required'), { code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' });
+  const lockFile = resolvePath(file);
+  mkdirSync(dirname(lockFile), { recursive: true });
+  const claimFile = `${lockFile}.claim`;
+  const token = randomUUID();
+  let claimed = false;
+  try {
+    try { mkdirSync(claimFile); claimed = true; }
+    catch (error) { throw Object.assign(new Error('provider store lock is busy'), { code: error?.code === 'EEXIST' ? 'PROVIDER_STORE_LOCK_BUSY' : 'PROVIDER_STORE_LOCK_UNAVAILABLE' }); }
+    while (true) {
+      try {
+        writeFileSync(lockFile, JSON.stringify({ pid: process.pid, token, created_at: new Date().toISOString() }) + '\n', { flag: 'wx' });
+        return {
+          ok: true,
+          token,
+          release: async () => {
+            const current = readOwner(lockFile);
+            if (current.ok && current.owner.token === token) rmSync(lockFile, { force: true });
+          },
+        };
+      } catch (error) {
+        if (error?.code !== 'EEXIST') throw Object.assign(new Error('provider store lock is unavailable'), { code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' });
+        const current = readOwner(lockFile);
+        if (!current.ok) throw Object.assign(new Error('provider store lock metadata is invalid'), { code: 'PROVIDER_STORE_LOCK_BUSY' });
+        if (processAlive(current.owner.pid)) throw Object.assign(new Error('provider store lock is busy'), { code: 'PROVIDER_STORE_LOCK_BUSY' });
+        rmSync(lockFile, { force: true });
+      }
+    }
+  } finally { if (claimed) rmSync(claimFile, { recursive: true, force: true }); }
+}
+
+export async function recoverProviderStoreLock(file, { confirm = false } = {}) {
+  if (confirm !== true) return { ok: false, code: 'PROVIDER_STORE_LOCK_CONFIRM_REQUIRED' };
+  if (typeof file !== 'string' || !file.trim()) return { ok: false, code: 'PROVIDER_STORE_LOCK_UNAVAILABLE' };
+  const lockFile = resolvePath(file);
+  const claimFile = `${lockFile}.claim`;
+  try { mkdirSync(dirname(lockFile), { recursive: true }); mkdirSync(claimFile); }
+  catch (error) { return { ok: false, code: error?.code === 'EEXIST' ? 'PROVIDER_STORE_LOCK_BUSY' : 'PROVIDER_STORE_LOCK_UNAVAILABLE' }; }
+  try {
+    if (!existsSync(lockFile)) return { ok: true, recovered: false };
+    const current = readOwner(lockFile);
+    if (current.ok && processAlive(current.owner.pid)) return { ok: false, code: 'PROVIDER_STORE_LOCK_BUSY' };
+    rmSync(lockFile, { force: true });
+    return { ok: true, recovered: true };
+  } finally { rmSync(claimFile, { recursive: true, force: true }); }
+}

package/src/readiness-matrix.mjs

@@ -1,181 +1,181 @@
-// Conservative release/environment readiness matrix.
-//
-// A row is PASS only when the caller supplies direct evidence for that row.
-// Missing evidence is NOT_RUN, not an inferred success. Runtime observations
-// (Hub handshake / catalog read) are intentionally separate from execution
-// verification (real worker, reviewer, cancellation, timeout, etc.).
-
-export const READINESS_STATUSES = Object.freeze(['PASS', 'FAIL', 'BLOCKED', 'SKIP', 'NOT_RUN']);
-
-export const READINESS_REASON_CODES = Object.freeze({
-  LIVE_CHECK_PASSED: 'LIVE_CHECK_PASSED',
-  HUB_UNREACHABLE: 'HUB_UNREACHABLE',
-  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_MODE_UNKNOWN: 'PROVIDER_MODE_UNKNOWN',
-  NO_CI_EVIDENCE: 'NO_CI_EVIDENCE',
-  NO_EXECUTION_EVIDENCE: 'NO_EXECUTION_EVIDENCE',
-  CREDENTIAL_STATUS_NOT_PROBED: 'CREDENTIAL_STATUS_NOT_PROBED',
-  EVIDENCE_REPORTED: 'EVIDENCE_REPORTED',
-});
-
-const TARGET_ROWS = Object.freeze([
-  ['linux_deterministic', 'ci'],
-  ['windows_regressions', 'ci'],
-  ['macos_smoke', 'ci'],
-  ['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'],
-]);
-
-function baseRow(id, category, status, reasonCode, evidenceSource = 'none', extra = {}) {
-  return {
-    id,
-    category,
-    status,
-    reason_code: reasonCode,
-    evidence_source: evidenceSource,
-    ...extra,
-  };
-}
-
-function normalizeEvidence(row, evidence) {
-  if (!evidence || typeof evidence !== 'object') return row;
-  if (!READINESS_STATUSES.includes(evidence.status)) return row;
-  const reason = typeof evidence.reason_code === 'string' && evidence.reason_code.trim()
-    ? evidence.reason_code.trim()
-    : READINESS_REASON_CODES.EVIDENCE_REPORTED;
-  const source = typeof evidence.evidence_source === 'string' && evidence.evidence_source.trim()
-    ? evidence.evidence_source.trim()
-    : 'reported-evidence';
-  return {
-    ...row,
-    status: evidence.status,
-    reason_code: reason,
-    evidence_source: source,
-    ...(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 }
-      : {}),
-  };
-}
-
-function defaultRows() {
-  return Object.fromEntries(TARGET_ROWS.map(([id, category]) => {
-    const reason = category === 'ci'
-      ? READINESS_REASON_CODES.NO_CI_EVIDENCE
-      : id === 'standalone_official'
-        ? READINESS_REASON_CODES.CREDENTIAL_STATUS_NOT_PROBED
-        : READINESS_REASON_CODES.NO_EXECUTION_EVIDENCE;
-    return [id, baseRow(id, category, 'NOT_RUN', reason)];
-  }));
-}
-
-/**
- * Build a secret-free readiness matrix from direct runtime observations plus
- * optional trusted evidence supplied by a higher layer.
- *
- * `evidence` is deliberately inert metadata: this module never reads files,
- * credentials, GitHub, provider config, or the network on its own.
- */
-export function buildReadinessMatrix({
-  platform = process.platform,
-  hubCompatibility = null,
-  workerProviderMode = null,
-  providerCatalogChecked = false,
-  providerCatalogOk = false,
-  evidence = {},
-} = {}) {
-  const rows = defaultRows();
-
-  if (hubCompatibility?.compatible === true) {
-    rows.hub_compatibility = baseRow(
-      'hub_compatibility', 'live-runtime', 'PASS',
-      READINESS_REASON_CODES.LIVE_CHECK_PASSED, 'hub-handshake',
-      {
-        runtime_version: hubCompatibility.runtime_version ?? null,
-        protocol_version: hubCompatibility.protocol_version ?? null,
-      },
-    );
-  } else if (hubCompatibility?.reachable === true) {
-    rows.hub_compatibility = baseRow(
-      'hub_compatibility', 'live-runtime', 'FAIL',
-      READINESS_REASON_CODES.HUB_INCOMPATIBLE, 'hub-handshake',
-      { detail_code: hubCompatibility.code ?? null },
-    );
-  } else {
-    rows.hub_compatibility = baseRow(
-      'hub_compatibility', 'live-runtime', 'BLOCKED',
-      READINESS_REASON_CODES.HUB_UNREACHABLE, 'hub-handshake',
-      { detail_code: hubCompatibility?.code ?? null },
-    );
-  }
-
-  if (workerProviderMode == null) {
-    rows.provider_catalog = baseRow(
-      'provider_catalog', 'live-runtime', 'NOT_RUN',
-      READINESS_REASON_CODES.PROVIDER_MODE_UNKNOWN, 'none',
-    );
-  } else if (workerProviderMode === 'deepseek-official') {
-    rows.provider_catalog = baseRow(
-      'provider_catalog', 'live-runtime', 'SKIP',
-      READINESS_REASON_CODES.PROVIDER_CATALOG_NOT_REQUIRED, 'runtime-policy',
-    );
-  } else if (!hubCompatibility?.compatible) {
-    rows.provider_catalog = baseRow(
-      'provider_catalog', 'live-runtime', 'BLOCKED',
-      hubCompatibility?.reachable
-        ? READINESS_REASON_CODES.HUB_INCOMPATIBLE
-        : READINESS_REASON_CODES.HUB_UNREACHABLE,
-      'hub-handshake',
-      { detail_code: hubCompatibility?.code ?? null },
-    );
-  } else if (providerCatalogChecked && providerCatalogOk) {
-    rows.provider_catalog = baseRow(
-      'provider_catalog', 'live-runtime', 'PASS',
-      READINESS_REASON_CODES.PROVIDER_CATALOG_RESOLVED, 'harness-catalog',
-    );
-  } else if (providerCatalogChecked) {
-    rows.provider_catalog = baseRow(
-      'provider_catalog', 'live-runtime', 'FAIL',
-      READINESS_REASON_CODES.PROVIDER_CATALOG_UNAVAILABLE, 'harness-catalog',
-    );
-  }
-
-  for (const [id] of TARGET_ROWS) {
-    rows[id] = normalizeEvidence(rows[id], evidence?.[id]);
-  }
-
-  const ordered = TARGET_ROWS.map(([id]) => rows[id]);
-  const counts = Object.fromEntries(READINESS_STATUSES.map((status) => [
-    status,
-    ordered.filter((row) => row.status === status).length,
-  ]));
-
-  return {
-    schema_version: 1,
-    platform,
-    conservative: true,
-    summary: counts,
-    rows: ordered,
-  };
-}
+// Conservative release/environment readiness matrix.
+//
+// A row is PASS only when the caller supplies direct evidence for that row.
+// Missing evidence is NOT_RUN, not an inferred success. Runtime observations
+// (Hub handshake / catalog read) are intentionally separate from execution
+// verification (real worker, reviewer, cancellation, timeout, etc.).
+
+export const READINESS_STATUSES = Object.freeze(['PASS', 'FAIL', 'BLOCKED', 'SKIP', 'NOT_RUN']);
+
+export const READINESS_REASON_CODES = Object.freeze({
+  LIVE_CHECK_PASSED: 'LIVE_CHECK_PASSED',
+  HUB_UNREACHABLE: 'HUB_UNREACHABLE',
+  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_MODE_UNKNOWN: 'PROVIDER_MODE_UNKNOWN',
+  NO_CI_EVIDENCE: 'NO_CI_EVIDENCE',
+  NO_EXECUTION_EVIDENCE: 'NO_EXECUTION_EVIDENCE',
+  CREDENTIAL_STATUS_NOT_PROBED: 'CREDENTIAL_STATUS_NOT_PROBED',
+  EVIDENCE_REPORTED: 'EVIDENCE_REPORTED',
+});
+
+const TARGET_ROWS = Object.freeze([
+  ['linux_deterministic', 'ci'],
+  ['windows_regressions', 'ci'],
+  ['macos_smoke', 'ci'],
+  ['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'],
+]);
+
+function baseRow(id, category, status, reasonCode, evidenceSource = 'none', extra = {}) {
+  return {
+    id,
+    category,
+    status,
+    reason_code: reasonCode,
+    evidence_source: evidenceSource,
+    ...extra,
+  };
+}
+
+function normalizeEvidence(row, evidence) {
+  if (!evidence || typeof evidence !== 'object') return row;
+  if (!READINESS_STATUSES.includes(evidence.status)) return row;
+  const reason = typeof evidence.reason_code === 'string' && evidence.reason_code.trim()
+    ? evidence.reason_code.trim()
+    : READINESS_REASON_CODES.EVIDENCE_REPORTED;
+  const source = typeof evidence.evidence_source === 'string' && evidence.evidence_source.trim()
+    ? evidence.evidence_source.trim()
+    : 'reported-evidence';
+  return {
+    ...row,
+    status: evidence.status,
+    reason_code: reason,
+    evidence_source: source,
+    ...(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 }
+      : {}),
+  };
+}
+
+function defaultRows() {
+  return Object.fromEntries(TARGET_ROWS.map(([id, category]) => {
+    const reason = category === 'ci'
+      ? READINESS_REASON_CODES.NO_CI_EVIDENCE
+      : id === 'standalone_official'
+        ? READINESS_REASON_CODES.CREDENTIAL_STATUS_NOT_PROBED
+        : READINESS_REASON_CODES.NO_EXECUTION_EVIDENCE;
+    return [id, baseRow(id, category, 'NOT_RUN', reason)];
+  }));
+}
+
+/**
+ * Build a secret-free readiness matrix from direct runtime observations plus
+ * optional trusted evidence supplied by a higher layer.
+ *
+ * `evidence` is deliberately inert metadata: this module never reads files,
+ * credentials, GitHub, provider config, or the network on its own.
+ */
+export function buildReadinessMatrix({
+  platform = process.platform,
+  hubCompatibility = null,
+  workerProviderMode = null,
+  providerCatalogChecked = false,
+  providerCatalogOk = false,
+  evidence = {},
+} = {}) {
+  const rows = defaultRows();
+
+  if (hubCompatibility?.compatible === true) {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'PASS',
+      READINESS_REASON_CODES.LIVE_CHECK_PASSED, 'hub-handshake',
+      {
+        runtime_version: hubCompatibility.runtime_version ?? null,
+        protocol_version: hubCompatibility.protocol_version ?? null,
+      },
+    );
+  } else if (hubCompatibility?.reachable === true) {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'FAIL',
+      READINESS_REASON_CODES.HUB_INCOMPATIBLE, 'hub-handshake',
+      { detail_code: hubCompatibility.code ?? null },
+    );
+  } else {
+    rows.hub_compatibility = baseRow(
+      'hub_compatibility', 'live-runtime', 'BLOCKED',
+      READINESS_REASON_CODES.HUB_UNREACHABLE, 'hub-handshake',
+      { detail_code: hubCompatibility?.code ?? null },
+    );
+  }
+
+  if (workerProviderMode == null) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'NOT_RUN',
+      READINESS_REASON_CODES.PROVIDER_MODE_UNKNOWN, 'none',
+    );
+  } else if (workerProviderMode === 'deepseek-official') {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'SKIP',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_NOT_REQUIRED, 'runtime-policy',
+    );
+  } else if (!hubCompatibility?.compatible) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'BLOCKED',
+      hubCompatibility?.reachable
+        ? READINESS_REASON_CODES.HUB_INCOMPATIBLE
+        : READINESS_REASON_CODES.HUB_UNREACHABLE,
+      'hub-handshake',
+      { detail_code: hubCompatibility?.code ?? null },
+    );
+  } else if (providerCatalogChecked && providerCatalogOk) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'PASS',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_RESOLVED, 'harness-catalog',
+    );
+  } else if (providerCatalogChecked) {
+    rows.provider_catalog = baseRow(
+      'provider_catalog', 'live-runtime', 'FAIL',
+      READINESS_REASON_CODES.PROVIDER_CATALOG_UNAVAILABLE, 'harness-catalog',
+    );
+  }
+
+  for (const [id] of TARGET_ROWS) {
+    rows[id] = normalizeEvidence(rows[id], evidence?.[id]);
+  }
+
+  const ordered = TARGET_ROWS.map(([id]) => rows[id]);
+  const counts = Object.fromEntries(READINESS_STATUSES.map((status) => [
+    status,
+    ordered.filter((row) => row.status === status).length,
+  ]));
+
+  return {
+    schema_version: 1,
+    platform,
+    conservative: true,
+    summary: counts,
+    rows: ordered,
+  };
+}

package/src/removable-waiter.mjs

@@ -1,29 +1,29 @@
-// Long-poll wait registration that removes itself: the terminal transition
-// bulk-clears job.waiters, so a timed-out waiter that stayed registered would
-// linger (and accumulate across polls) for the remaining lifetime of a
-// long-running job. All three wait surfaces (hub, standalone jobs, workflow
-// runtime) share this one implementation so the cleanup invariant cannot
-// drift again.
-
-/**
- * Race the job's waiters against a timeout, always unregistering the waiter
- * afterwards. `timeoutMs <= 0` means "no timeout": wait forever unless
- * `immediateWithoutTimeout` is set, which resolves immediately (poll
- * semantics, used by the hub route).
- */
-export async function raceWaiters(waiters, { timeoutMs = 0, immediateWithoutTimeout = false } = {}) {
-  let waiter = null;
-  let timer = null;
-  try {
-    await Promise.race([
-      new Promise((resolve) => { waiter = resolve; waiters.push(resolve); }),
-      timeoutMs > 0
-        ? new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); })
-        : (immediateWithoutTimeout ? Promise.resolve() : new Promise(() => {})),
-    ]);
-  } finally {
-    const index = waiters.indexOf(waiter);
-    if (index !== -1) waiters.splice(index, 1);
-    if (timer !== null) clearTimeout(timer);
-  }
-}
+// Long-poll wait registration that removes itself: the terminal transition
+// bulk-clears job.waiters, so a timed-out waiter that stayed registered would
+// linger (and accumulate across polls) for the remaining lifetime of a
+// long-running job. All three wait surfaces (hub, standalone jobs, workflow
+// runtime) share this one implementation so the cleanup invariant cannot
+// drift again.
+
+/**
+ * Race the job's waiters against a timeout, always unregistering the waiter
+ * afterwards. `timeoutMs <= 0` means "no timeout": wait forever unless
+ * `immediateWithoutTimeout` is set, which resolves immediately (poll
+ * semantics, used by the hub route).
+ */
+export async function raceWaiters(waiters, { timeoutMs = 0, immediateWithoutTimeout = false } = {}) {
+  let waiter = null;
+  let timer = null;
+  try {
+    await Promise.race([
+      new Promise((resolve) => { waiter = resolve; waiters.push(resolve); }),
+      timeoutMs > 0
+        ? new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); })
+        : (immediateWithoutTimeout ? Promise.resolve() : new Promise(() => {})),
+    ]);
+  } finally {
+    const index = waiters.indexOf(waiter);
+    if (index !== -1) waiters.splice(index, 1);
+    if (timer !== null) clearTimeout(timer);
+  }
+}