@ran-sh/dsh-crew 0.5.7 → 1.0.1

package/src/install/npx-lifecycle.mjs

@@ -49,9 +49,10 @@ import {
 
 export const CREW_APP_DIRNAME = 'app';
 export const RELEASES_DIRNAME = 'releases';
-export const CURRENT_POINTER_FILENAME = 'current.json';
-export const KEEP_RELEASES = 2;
-export const INCOMPLETE_MARKER = '.dsh-crew-incomplete';
+export const CURRENT_POINTER_FILENAME = 'current.json';
+export const KEEP_RELEASES = 2;
+export const INCOMPLETE_MARKER = '.dsh-crew-incomplete';
+const CREW_ROUTE_BASE = '/_dsh/dsh-crew';
 
 export function npmCliInvocation(args, {
   platform = process.platform,
@@ -477,7 +478,7 @@ function commitStagedRelease({ stageDir, manifest, home }) {
 
 const STALE_INCOMPLETE_MS = 24 * 60 * 60 * 1000;
 
-function gcOldReleases({ home, keep = KEEP_RELEASES }) {
+function gcOldReleases({ home, keep = KEEP_RELEASES }) {
   const pointer = readCurrentPointer({ home });
   const releasesDir = crewReleasesDir({ home });
   if (!existsSync(releasesDir)) return;
@@ -506,9 +507,123 @@ function gcOldReleases({ home, keep = KEEP_RELEASES }) {
     try { rmSync(victim, { recursive: true, force: true }); removed.push(victim); } catch { /* best effort */ }
   }
   return removed;
-}
-
-function registrationLinkPath({ home, name }) {
+}
+
+export function listManagedReleases({ home = homedir() } = {}) {
+  const pointer = readCurrentPointer({ home });
+  const root = crewReleasesDir({ home });
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => {
+      const path = join(root, entry.name);
+      const manifest = readManifest(path);
+      if (!manifest?.name || !manifest?.version) return null;
+      const validation = validateInstalledPayload(path, { expectedName: manifest.name, expectedVersion: manifest.version });
+      return {
+        name: manifest.name,
+        version: manifest.version,
+        path,
+        current: pointer?.path === path,
+        healthy: validation.ok,
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => compareVersions(b.version, a.version) || b.path.localeCompare(a.path));
+}
+
+async function restartOwnedRuntime(fetchImpl = globalThis.fetch) {
+  const response = await fetchImpl('http://127.0.0.1:3080/_dsh/dsh-crew/supervisor/restart', {
+    method: 'POST',
+    headers: { accept: 'application/json', 'content-type': 'application/json' },
+    body: JSON.stringify({ confirm: true }),
+  });
+  const body = await response.json();
+  return response.ok && body?.ok === true ? body : { ok: false, code: body?.code ?? 'CREW_3210_RESTART_FAILED' };
+}
+
+async function verifyRuntimeVersion(version, fetchImpl = globalThis.fetch) {
+  const response = await fetchImpl('http://127.0.0.1:3210/_dsh/dsh-crew/runtime', { headers: { accept: 'application/json' } });
+  const body = await response.json();
+  return response.ok && body?.ok === true && body.runtime_version === version
+    ? { ok: true, runtime_version: body.runtime_version }
+    : { ok: false, code: 'RUNTIME_VERSION_MISMATCH' };
+}
+
+export async function npxReleases({ home = homedir(), log = console.log } = {}) {
+  const releases = listManagedReleases({ home });
+  log(JSON.stringify(releases, null, 2));
+  return { ok: true, releases };
+}
+
+export async function npxRollback({
+  home = homedir(),
+  version,
+  log = console.log,
+  installer = realInstaller,
+  ensureRuntime,
+  validatePayload = validateInstalledPayload,
+  activate,
+  restart = () => restartOwnedRuntime(),
+  verifyRuntime = (targetVersion) => verifyRuntimeVersion(targetVersion),
+} = {}) {
+  const targetVersion = typeof version === 'string' ? version.trim() : '';
+  if (!targetVersion) return { ok: false, error: 'rollback requires a target version' };
+  const current = readCurrentPointer({ home });
+  if (!current?.path || !existsSync(current.path)) return { ok: false, error: 'no active Crew payload to roll back' };
+  const target = listManagedReleases({ home }).find((release) => release.version === targetVersion);
+  if (!target) return { ok: false, error: `retained release ${targetVersion} was not found` };
+  if (target.path === current.path) return { ok: true, idempotent: true, version: target.version, path: target.path };
+  const targetManifest = readManifest(target.path);
+  const validation = validatePayload(target.path, { expectedName: targetManifest?.name, expectedVersion: targetManifest?.version });
+  if (!validation.ok) return { ok: false, error: 'target release failed payload validation' };
+  const previousManifest = readManifest(current.path);
+  const activateReleaseFn = activate ?? (({ releaseDir, manifest }) => activateRelease({ home, releaseDir, manifest, log, installer, ensureRuntime }));
+  const switchPointer = (release) => writeCurrentPointer({ home, name: release.name, version: release.version, path: release.path });
+  try {
+    switchPointer(target);
+    if (!await activateReleaseFn({ releaseDir: target.path, manifest: targetManifest })) throw new Error('target release activation failed');
+    const restarted = await restart(target.version);
+    if (restarted?.ok === false) throw Object.assign(new Error('target runtime restart failed'), { code: restarted.code });
+    const runtime = await verifyRuntime(target.version);
+    if (runtime?.ok !== true) throw Object.assign(new Error('target runtime verification failed'), { code: runtime?.code ?? 'RUNTIME_VERSION_MISMATCH' });
+    log(`✓ rolled back Crew payload to ${target.version}`);
+    return { ok: true, rolled_back: true, version: target.version, path: target.path, restart: restarted, runtime };
+  } catch (error) {
+    const prior = { name: current.name, version: current.version, path: current.path };
+    let recovery;
+    try {
+      switchPointer(prior);
+      if (!previousManifest) throw Object.assign(new Error('previous release manifest unavailable'), { stage: 'activation' });
+      const activated = await activateReleaseFn({ releaseDir: prior.path, manifest: previousManifest });
+      if (activated !== true) throw Object.assign(new Error('previous release activation failed'), { stage: 'activation' });
+      const restarted = await restart(prior.version);
+      if (restarted?.ok !== true) throw Object.assign(new Error('previous runtime restart failed'), { stage: 'restart' });
+      const runtime = await verifyRuntime(prior.version);
+      if (runtime?.ok !== true) throw Object.assign(new Error('previous runtime verification failed'), { stage: 'verification' });
+      const restoredPointer = readCurrentPointer({ home });
+      if (restoredPointer?.path !== prior.path || restoredPointer.version !== prior.version) {
+        throw Object.assign(new Error('previous release pointer was not restored'), { stage: 'pointer' });
+      }
+      recovery = { ok: true, version: prior.version, path: prior.path };
+    } catch (recoveryError) {
+      recovery = {
+        ok: false,
+        code: 'RELEASE_ROLLBACK_RECOVERY_FAILED',
+        stage: ['activation', 'restart', 'verification', 'pointer'].includes(recoveryError?.stage) ? recoveryError.stage : 'unknown',
+      };
+    }
+    return {
+      ok: false,
+      error: error?.message ?? 'release rollback failed',
+      code: error?.code ?? 'RELEASE_ROLLBACK_FAILED',
+      restored: recovery.ok === true,
+      recovery,
+    };
+  }
+}
+
+function registrationLinkPath({ home, name }) {
   return join(crewProfileDir({ home }), 'node_modules', ...name.split('/'));
 }
 
@@ -1113,6 +1228,9 @@ Commands:
   inspect     print the machine-readable extension capability/readiness contract
   jobs        machine-first job API: list|get|watch|cancel|submit
   providers   3210 provider lifecycle API: list|delete-plan|delete|rollback|probe
+  credentials 3210 credential references: list|purge-plan|purge (separate confirmation)
+  releases    list retained, validated Crew payload releases
+  rollback    switch to a retained payload version and verify the 3210 runtime
   update      resolve the newest permitted package from the configured npm registry (or
               --candidate), stage and validate it, then activate; idempotent when current
   uninstall   remove the Crew-managed payload, registration, and integrations (config kept)
@@ -1122,8 +1240,8 @@ Options:
   --after <sequence>  with jobs watch/get: return canonical events after this cursor
   --detail <mode>     with jobs get/watch: compact (default) or full
   --request <path>    with jobs submit: JSON Job Request document
-  --plan <id>         with providers delete: approved plan id
-  --expected-revision <sha256>  with providers delete: profile revision from delete-plan
+  --plan <id>         with providers/credentials destructive actions: approved plan id
+  --expected-revision <sha256>  with providers/credentials actions: revision from plan
   --replacement-default <id>   with providers delete-plan: replacement Harness Default provider
   --confirm           with providers delete: confirm the destructive mutation
   --purge             with uninstall: also remove ~/.config/dsh-crew config/backups (destructive)
@@ -1132,13 +1250,14 @@ Options:
 Primary install: npm install -g @ran-sh/dsh-crew   (then run: dsh-crew install)
 Source checkouts use scripts/setup.mjs instead.`;
 
-export async function npxInspect({
+export async function npxInspect({
   log = console.log,
   fetchImpl = globalThis.fetch,
   readConfig = realInstaller.readGlobalConfig,
-} = {}) {
-  const hubUrl = readConfig()?.hub_url ?? 'http://127.0.0.1:3210';
-  const url = `${String(hubUrl).replace(/\/$/, '')}/_dsh/dsh-crew/extension`;
+} = {}) {
+  const hubUrl = String(readConfig()?.hub_url ?? PRODUCTION_HUB_URL).replace(/\/$/, '');
+  await assertProductionHub({ hubUrl, requiredCapabilities: INSPECT_CAPABILITIES, purpose: 'inspect', fetchImpl });
+  const url = `${String(hubUrl).replace(/\/$/, '')}/_dsh/dsh-crew/extension`;
   const response = await fetchImpl(url, { headers: { accept: 'application/json' } });
   const body = await response.json();
   if (!response.ok || body?.ok !== true || !body.extension) {
@@ -1156,12 +1275,15 @@ export async function npxJobs({
   log = console.log,
   fetchImpl = globalThis.fetch,
   readConfig = realInstaller.readGlobalConfig,
-} = {}) {
-  const hubUrl = String(readConfig()?.hub_url ?? 'http://127.0.0.1:3210').replace(/\/$/, '');
-  const base = `${hubUrl}/_dsh/dsh-crew/jobs`;
-  const action = args[0] ?? 'list';
-  const id = args[1];
-  let url = base;
+} = {}) {
+  const hubUrl = String(readConfig()?.hub_url ?? 'http://127.0.0.1:3210').replace(/\/$/, '');
+  const base = `${hubUrl}/_dsh/dsh-crew/jobs`;
+  const action = args[0] ?? 'list';
+  const id = args[1];
+  const requiredCapabilities = JOB_CAPABILITY_REQUIREMENTS[action];
+  if (!requiredCapabilities) throw new Error(`unknown jobs action: ${action}`);
+  await assertProductionHub({ hubUrl, requiredCapabilities, purpose: 'job', fetchImpl });
+  let url = base;
   let init = { headers: { accept: 'application/json' } };
   if (action === 'get' || action === 'watch') {
     if (!id) throw new Error(`jobs ${action} requires a job id`);
@@ -1174,9 +1296,7 @@ export async function npxJobs({
     if (!request) throw new Error('jobs submit requires --request <json-file>');
     const document = JSON.parse(readFileSync(resolve(request), 'utf8'));
     init = { method: 'POST', headers: { accept: 'application/json', 'content-type': 'application/json' }, body: JSON.stringify(document) };
-  } else if (action !== 'list') {
-    throw new Error(`unknown jobs action: ${action}`);
-  }
+  }
   const response = await fetchImpl(url, init);
   const body = await response.json();
   if (!response.ok || body?.ok === false) throw new Error(body?.error ?? 'Crew jobs API unavailable');
@@ -1184,6 +1304,60 @@ export async function npxJobs({
   return { ok: true, body };
 }
 
+const PROVIDER_CAPABILITY_REQUIREMENTS = Object.freeze({
+  list: Object.freeze(['provider-inventory']),
+  'delete-plan': Object.freeze(['provider-inventory', 'provider-lifecycle-v1']),
+  delete: Object.freeze(['provider-inventory', 'provider-lifecycle-v1']),
+  rollback: Object.freeze(['provider-inventory', 'provider-lifecycle-v1']),
+  probe: Object.freeze(['provider-inventory', 'provider-health-v1', 'provider-probe-stream-v1']),
+});
+const JOB_CAPABILITY_REQUIREMENTS = Object.freeze({
+  list: Object.freeze(['jobs']),
+  get: Object.freeze(['jobs', 'jobs-wait']),
+  watch: Object.freeze(['jobs', 'jobs-wait']),
+  cancel: Object.freeze(['jobs', 'jobs-cancel']),
+  submit: Object.freeze(['jobs', 'roles', 'attempt-index', 'model-policy']),
+});
+const INSPECT_CAPABILITIES = Object.freeze(['extension-contract', 'evidence', 'runtime-provenance-v1']);
+const CREDENTIAL_CAPABILITY_REQUIREMENTS = Object.freeze({
+  list: Object.freeze(['credential-reference-inventory-v1']),
+  'purge-plan': Object.freeze(['credential-reference-inventory-v1', 'credential-purge-v1']),
+  purge: Object.freeze(['credential-reference-inventory-v1', 'credential-purge-v1']),
+});
+export const PRODUCTION_HUB_URL = 'http://127.0.0.1:3210';
+
+export async function assertProductionHub({ hubUrl, requiredCapabilities = [], purpose = 'command', fetchImpl = globalThis.fetch } = {}) {
+  if (hubUrl !== PRODUCTION_HUB_URL) throw new Error(`${purpose} requires the isolated 3210 Crew Hub`);
+  const response = await fetchImpl(`${hubUrl}${CREW_ROUTE_BASE}/runtime`, { headers: { accept: 'application/json' } });
+  let body;
+  try { body = await response.json(); } catch { body = null; }
+  const validIdentity = response.ok && body?.ok === true
+    && body?.service === 'dsh-crew-hub'
+    && body?.execution_plane === 'hub-3210'
+    && body?.profile === 'dsh-crew'
+    && Number(body?.listen_port) === 3210
+    && typeof body?.runtime_id === 'string' && body.runtime_id.trim().length > 0;
+  if (!validIdentity) throw new Error(`${purpose} requires a compatible isolated 3210 Crew Hub`);
+  const advertised = new Set(Array.isArray(body.capabilities) ? body.capabilities.filter((value) => typeof value === 'string') : []);
+  const missing = requiredCapabilities.filter((capability) => !advertised.has(capability));
+  if (missing.length > 0) throw new Error(`missing ${purpose} capability: ${missing.join(', ')}`);
+  return { ok: true, runtime: body, capabilities: [...advertised] };
+}
+
+/**
+ * Confirm the target is the live isolated Hub and advertises the lifecycle
+ * surface before sending a provider request. This prevents a same-port stale
+ * Hub from turning a later 404 into an ambiguous destructive failure.
+ */
+export async function assertProviderHubCapabilities({ hubUrl, action, fetchImpl = globalThis.fetch } = {}) {
+  return assertProductionHub({
+    hubUrl,
+    requiredCapabilities: PROVIDER_CAPABILITY_REQUIREMENTS[action] ?? PROVIDER_CAPABILITY_REQUIREMENTS.list,
+    purpose: 'provider lifecycle',
+    fetchImpl,
+  });
+}
+
 /**
  * Call the isolated 3210 provider lifecycle API. The CLI never parses or
  * edits Harness YAML itself; the Hub remains the sole mutation authority.
@@ -1199,8 +1373,7 @@ export async function npxProviders({
   fetchImpl = globalThis.fetch,
   readConfig = realInstaller.readGlobalConfig,
 } = {}) {
-  const configuredHubUrl = String(readConfig()?.hub_url ?? 'http://127.0.0.1:3210').replace(/\/$/, '');
-  if (configuredHubUrl !== 'http://127.0.0.1:3210') throw new Error('providers CLI requires the isolated 3210 Crew Hub');
+  const configuredHubUrl = String(readConfig()?.hub_url ?? PRODUCTION_HUB_URL).replace(/\/$/, '');
   const hubUrl = configuredHubUrl;
   const base = `${hubUrl}/_dsh/dsh-crew/providers`;
   const action = args[0] ?? 'list';
@@ -1221,6 +1394,7 @@ export async function npxProviders({
   if (purgeOrphanCredentials === true || options.get('--purge-orphan-credentials') === true) {
     throw new Error('credential purge requires a separate explicit confirmation flow');
   }
+  await assertProviderHubCapabilities({ hubUrl, action, fetchImpl });
   let url = base;
   let init = { headers: { accept: 'application/json' } };
   if (action === 'list') {
@@ -1293,6 +1467,42 @@ export async function npxProviders({
   return { ok: true, body };
 }
 
+/** Independent credential-reference inventory and irreversible purge CLI. */
+export async function npxCredentials({
+  args = [],
+  planId,
+  expectedRevision,
+  confirm = false,
+  log = console.log,
+  fetchImpl = globalThis.fetch,
+  readConfig = realInstaller.readGlobalConfig,
+} = {}) {
+  const hubUrl = String(readConfig()?.hub_url ?? PRODUCTION_HUB_URL).replace(/\/$/, '');
+  const action = args[0] ?? 'list';
+  const id = args[1];
+  const requiredCapabilities = CREDENTIAL_CAPABILITY_REQUIREMENTS[action];
+  if (!requiredCapabilities) throw new Error(`unknown credentials action: ${action}`);
+  await assertProductionHub({ hubUrl, requiredCapabilities, purpose: 'credential', fetchImpl });
+  const base = `${hubUrl}${CREW_ROUTE_BASE}/credential-references`;
+  let url = base;
+  let init = { headers: { accept: 'application/json' } };
+  if (action === 'purge-plan') {
+    if (!id) throw new Error('credentials purge-plan requires a reference id');
+    url = `${base}/${encodeURIComponent(id)}/purge-plan`;
+    init = { method: 'POST', headers: { accept: 'application/json', 'content-type': 'application/json' }, body: JSON.stringify({ ...(expectedRevision ? { expected_revision: expectedRevision } : {}) }) };
+  } else if (action === 'purge') {
+    if (!id) throw new Error('credentials purge requires a reference id');
+    if (!planId || !expectedRevision || confirm !== true) throw new Error('credentials purge requires --plan, --expected-revision and --confirm');
+    url = `${base}/${encodeURIComponent(id)}`;
+    init = { method: 'DELETE', headers: { accept: 'application/json', 'content-type': 'application/json' }, body: JSON.stringify({ plan_id: planId, expected_revision: expectedRevision, confirm: true }) };
+  }
+  const response = await fetchImpl(url, init);
+  const body = await response.json();
+  if (!response.ok || body?.ok === false) throw new Error(body?.code ?? body?.error ?? 'Crew credential API unavailable');
+  log(JSON.stringify(body, null, 2));
+  return { ok: true, body };
+}
+
 function normalizeCommand(argv) {
   const flags = argv.slice(1);
   let candidate;
@@ -1372,7 +1582,7 @@ export async function runNpxCli({
     error(USAGE);
     return 1;
   }
-  if (unknown.length > 0 || !['install', 'integrate', 'detach', 'status', 'inspect', 'jobs', 'providers', 'update', 'uninstall'].includes(command)) {
+  if (unknown.length > 0 || !['install', 'integrate', 'detach', 'status', 'inspect', 'jobs', 'providers', 'credentials', 'releases', 'rollback', 'update', 'uninstall'].includes(command)) {
     error(`unknown command: ${command ?? '<none>'}\n\n${USAGE}`);
     return 1;
   }
@@ -1385,6 +1595,9 @@ export async function runNpxCli({
       inspect: commands.inspect ?? npxInspect,
       jobs: commands.jobs ?? npxJobs,
       providers: commands.providers ?? npxProviders,
+      credentials: commands.credentials ?? npxCredentials,
+      releases: commands.releases ?? npxReleases,
+      rollback: commands.rollback ?? npxRollback,
       update: commands.update ?? npxUpdate,
       uninstall: commands.uninstall ?? npxUninstall,
     };
@@ -1393,6 +1606,9 @@ export async function runNpxCli({
     else if (command === 'update') result = await actions.update({ candidate, log });
     else if (command === 'jobs') result = await actions.jobs({ args, after, detail, request, log });
     else if (command === 'providers') result = await actions.providers({ args, planId, expectedRevision, replacementDefault, confirm, purgeOrphanCredentials, log });
+    else if (command === 'credentials') result = await actions.credentials({ args, planId, expectedRevision, confirm, log });
+    else if (command === 'releases') result = await actions.releases({ args, log });
+    else if (command === 'rollback') result = await actions.rollback({ version: args?.[0], args, log });
     else result = await actions[command]({ log });
     return result?.ok === false ? 1 : 0;
   } catch (err) {

package/src/job-contracts.mjs

@@ -8,9 +8,12 @@
 export const JOB_CONTRACT_SCHEMA_VERSION = 1;
 
 export const JOB_EVENT_TYPES = Object.freeze([
-  'job.created',
-  'job.started',
-  'model.selected',
+  'job.created',
+  'job.started',
+  'runtime.bound',
+  'model.selected',
+  'model.admitted',
+  'agent.created',
   'model.fallback',
   'worker.started',
   'worker.completed',
@@ -137,12 +140,14 @@ function boundedExecutionContext(value) {
   const profile = boundedText(value.profile, 64);
   const runtimeId = boundedText(value.runtime_id, 128);
   const port = Number.isInteger(value.listen_port) ? value.listen_port : null;
-  if (!executionPlane && !profile && !runtimeId && port === null) return null;
+  const ingress = value.ingress === 'official-3080' || value.ingress === 'direct-3210' ? value.ingress : null;
+  if (!executionPlane && !profile && !runtimeId && port === null && !ingress) return null;
   return {
     execution_plane: executionPlane,
     profile,
     listen_port: port,
     runtime_id: runtimeId,
+    ...(ingress ? { ingress } : {}),
   };
 }
 

package/src/official-web-bridge.mjs

@@ -16,17 +16,11 @@ const HOP_BY_HOP = new Set([
   'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'content-length',
 ]);
 
-export function resolveCrewBridgeTarget(env = process.env) {
-  const raw = env?.DSH_CREW_BRIDGE_TARGET;
-  if (!raw) return CREW_BRIDGE_TARGET;
-  try {
-    const target = new URL(raw);
-    if (target.protocol !== 'http:' || !isLocalHostname(target.hostname.toLowerCase()) || target.pathname !== '/' || target.search || target.hash) return CREW_BRIDGE_TARGET;
-    const port = Number(target.port);
-    if (!Number.isInteger(port) || port < 1 || port > 65535) return CREW_BRIDGE_TARGET;
-    return target.origin;
-  } catch { return CREW_BRIDGE_TARGET; }
-}
+export function resolveCrewBridgeTarget() {
+  // Production bridge routing is an invariant, not an environment setting.
+  // Tests can inject dependencies directly into createCrewSidecarSupervisor.
+  return CREW_BRIDGE_TARGET;
+}
 
 export function isTrustedLocalRequest(req) {
   if (!localRequestCore(req)) return false;
@@ -108,6 +102,7 @@ export function createCrewSidecarSupervisor({
   pollInterval = 250,
   ownershipFile = join(crewDshHome({ home }), 'supervisor-ownership.json'),
 } = {}) {
+  if (bridgeTarget !== CREW_BRIDGE_TARGET) throw new Error('Crew supervisor is fixed to the isolated 3210 Crew Hub');
   let starting = null;
   let restarting = null;
   let runningChild = null;

package/src/provider-delete-adapters.mjs

@@ -115,6 +115,10 @@ function configProjection(config) {
   return projection;
 }
 
+function lifecycleProjection(state) {
+  return { tombstones: { ...(state?.tombstones ?? {}) } };
+}
+
 function restoreConfigProjection(config, projection) {
   const next = typeof structuredClone === 'function' ? structuredClone(config) : JSON.parse(JSON.stringify(config));
   for (const key of ['flash_model_priority', 'pro_model_priority', 'harness_default', 'agent_default_model', 'agentDefaultModel']) {
@@ -229,6 +233,11 @@ export function createProviderDeleteFileHooks({
         replacement_default: plan.replacement_default ?? null,
         was_harness_default: plan.was_harness_default === true,
         replacement_default_model: plan.replacement_default_model ?? null,
+        credential_refs: (Array.isArray(plan.credential_refs) ? plan.credential_refs : []).map((ref) => ({
+          kind: typeof ref?.kind === 'string' ? ref.kind.trim() : 'unknown',
+          name_or_handle: typeof ref?.name_or_handle === 'string' ? ref.name_or_handle.trim() : 'unknown',
+          ownership: typeof ref?.ownership === 'string' ? ref.ownership.trim() : 'unknown',
+        })).filter((ref) => ref.kind && ref.name_or_handle && ref.ownership).slice(0, 32),
       },
       files: {},
     };
@@ -247,6 +256,8 @@ export function createProviderDeleteFileHooks({
     manifest.config_projection = configProjection(config);
     manifest.config_revision = sha256(JSON.stringify(config));
     manifest.lifecycle_revision = sha256(JSON.stringify(lifecycle));
+    manifest.routing_projection_digest = sha256(JSON.stringify(manifest.config_projection));
+    manifest.lifecycle_projection_digest = sha256(JSON.stringify(lifecycleProjection(lifecycle)));
     manifest.profile_revision = sha256(fs.readFileSync(profileFile, 'utf8'));
     activeBackup = { root, manifest };
     persistManifest();
@@ -381,8 +392,23 @@ export function createProviderDeleteFileHooks({
     const source = fs.readFileSync(profileFile, 'utf8');
     const parsed = readProviderDeclarations(source, { file: 'harness/profiles/dsh-crew/cordis.patch.yml' });
     const providerPresent = parsed.ok && parsed.declarations.some((declaration) => declaration.id === plan.provider_id);
+    const config = await readConfig();
     const state = normalizeProviderLifecycleState(readJson(lifecycleFile, {}));
-    return { ok: providerPresent && state.tombstones[plan.provider_id] !== 'absent' };
+    const routingRestored = typeof activeBackup?.manifest?.routing_projection_digest === 'string'
+      && sha256(JSON.stringify(configProjection(config))) === activeBackup.manifest.routing_projection_digest;
+    const lifecycleRestored = typeof activeBackup?.manifest?.lifecycle_projection_digest === 'string'
+      && sha256(JSON.stringify(lifecycleProjection(state))) === activeBackup.manifest.lifecycle_projection_digest;
+    const declarationRestored = typeof activeBackup?.manifest?.profile_revision === 'string'
+      && sha256(source) === activeBackup.manifest.profile_revision;
+    return {
+      ok: providerPresent && state.tombstones[plan.provider_id] !== 'absent'
+        && routingRestored && lifecycleRestored && declarationRestored,
+      providerPresent,
+      tombstoneCleared: state.tombstones[plan.provider_id] !== 'absent',
+      routingRestored,
+      lifecycleRestored,
+      declarationRestored,
+    };
   };
 
   const recordTransaction = async (result, plan) => {
@@ -393,6 +419,7 @@ export function createProviderDeleteFileHooks({
       provider_id: result?.provider_id ?? plan?.provider_id,
       state: result?.state,
       expected_revision: plan?.expected_revision,
+      credential_refs: plan?.credential_refs,
     });
     if (result?.state === 'VERIFIED') {
       assertManagedPath(profileFile);

package/src/provider-desired-state.mjs

@@ -0,0 +1,37 @@
+// Reconcile Crew-owned provider declarations with persisted lifecycle intent.
+// Tombstones are lifecycle state, not a shadow catalog: they only prevent a
+// previously deleted managed route from being re-seeded during install/update.
+
+import {
+  inspectProviderProfile,
+  removeProviderDeclarations,
+} from './provider-profile-store.mjs';
+
+const PROVIDER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+export function reconcileProviderDesiredState(source, { tombstones = {}, expectedRevision } = {}) {
+  const requested = Object.entries(tombstones ?? {})
+    .filter(([id, state]) => state === 'absent' && PROVIDER_ID.test(id))
+    .map(([id]) => id);
+  if (requested.length === 0) return { ok: true, changed: false, removed: [], text: source };
+
+  const inspected = inspectProviderProfile(source);
+  if (!inspected.ok) return { ok: false, code: inspected.code, revision: inspected.revision };
+  const declared = new Set(inspected.providerIds);
+  const toRemove = requested.filter((id) => declared.has(id));
+  if (toRemove.length === 0) return { ok: true, changed: false, removed: [], text: source, revision: inspected.revision };
+
+  const result = removeProviderDeclarations(source, {
+    providerIds: toRemove,
+    expectedRevision: expectedRevision ?? inspected.revision,
+  });
+  if (!result.ok) return result;
+  return {
+    ok: true,
+    changed: true,
+    removed: result.removed,
+    remaining: result.remaining,
+    text: result.text,
+    revision: result.revision,
+  };
+}

package/src/provider-lifecycle-state.mjs

@@ -17,6 +17,18 @@ function validRevision(value) {
   return typeof value === 'string' && REVISION_PATTERN.test(value);
 }
 
+function normalizedCredentialRefs(value) {
+  if (!Array.isArray(value)) return undefined;
+  const refs = value.map((ref) => {
+    if (!ref || typeof ref !== 'object' || Array.isArray(ref)) return null;
+    const kind = typeof ref.kind === 'string' && ref.kind.trim() ? ref.kind.trim() : null;
+    const name = typeof ref.name_or_handle === 'string' && ref.name_or_handle.trim() ? ref.name_or_handle.trim() : null;
+    const ownership = typeof ref.ownership === 'string' && ref.ownership.trim() ? ref.ownership.trim() : null;
+    return kind && name && ownership ? { kind, name_or_handle: name, ownership } : null;
+  }).filter(Boolean).slice(0, 32);
+  return refs;
+}
+
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -24,10 +36,12 @@ function clone(value) {
 function normalizedTransaction(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   if (!validId(value.provider_id) || typeof value.state !== 'string' || !STATES.has(value.state)) return null;
+  const refs = normalizedCredentialRefs(value.credential_refs);
   return {
     provider_id: value.provider_id,
     state: value.state,
     ...(validRevision(value.expected_revision) ? { expected_revision: value.expected_revision } : {}),
+    ...(refs === undefined ? {} : { credential_refs: refs }),
   };
 }
 
@@ -70,7 +84,7 @@ export function clearProviderTombstone(state, providerId) {
   return out;
 }
 
-/** Record only non-secret transaction metadata; credential refs/values are ignored. */
+/** Record non-secret transaction metadata and credential reference names only. */
 export function recordProviderTransaction(state, transaction = {}) {
   const transactionId = requireProviderId(transaction.transaction_id ?? transaction.plan_id);
   const normalized = normalizedTransaction(transaction);

package/src/runtime-identity.mjs

@@ -18,7 +18,7 @@ export const PRODUCTION_PROFILE = 'dsh-crew';
 export const PRODUCTION_LISTEN_PORT = 3210;
 const RUNTIME_ID = randomUUID();
 
-export const RUNTIME_VERSION = '0.5.7';
+export const RUNTIME_VERSION = '1.0.1';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([
@@ -33,10 +33,17 @@ export const HUB_CAPABILITIES = Object.freeze([
   'config',
   'canonical-events',
   'evidence',
-  'profiles',
-  'workspace-context',
-  'extension-contract',
-]);
+  'profiles',
+  'workspace-context',
+  'extension-contract',
+  'provider-inventory',
+  'provider-lifecycle-v1',
+  'provider-health-v1',
+  'provider-probe-stream-v1',
+  'credential-reference-inventory-v1',
+  'credential-purge-v1',
+  'runtime-provenance-v1',
+]);
 
 // Capabilities the current MCP workflow depends on for full Hub execution.
 // Additional capabilities may be advertised without breaking compatibility.
@@ -56,6 +63,7 @@ export const HUB_COMPATIBILITY_CODES = Object.freeze({
   PROTOCOL_MISSING: 'HUB_PROTOCOL_MISSING',
   PROTOCOL_MISMATCH: 'HUB_PROTOCOL_MISMATCH',
   CAPABILITY_MISSING: 'HUB_CAPABILITY_MISSING',
+  PROVENANCE_MISSING: 'HUB_PROVENANCE_MISSING',
   EXECUTION_PLANE_MISMATCH: 'HUB_EXECUTION_PLANE_MISMATCH',
   LISTEN_PORT_MISMATCH: 'HUB_LISTEN_PORT_MISMATCH',
 });
@@ -87,7 +95,7 @@ export function getHubRuntimeIdentity() {
  * `compatible` means the response is from dsh-crew and satisfies the current
  * protocol + required capability contract.
  */
-export function evaluateHubHandshake(body, { requiredCapabilities = REQUIRED_HUB_CAPABILITIES } = {}) {
+export function evaluateHubHandshake(body, { requiredCapabilities = REQUIRED_HUB_CAPABILITIES, strictProduction = false } = {}) {
   const capabilities = normalizedCapabilities(body?.capabilities);
   const base = {
     reachable: true,
@@ -122,9 +130,16 @@ export function evaluateHubHandshake(body, { requiredCapabilities = REQUIRED_HUB
     return { ...base, code: HUB_COMPATIBILITY_CODES.PROTOCOL_MISSING };
   }
 
-  if (body.protocol_version !== HUB_PROTOCOL_VERSION) {
-    return { ...base, code: HUB_COMPATIBILITY_CODES.PROTOCOL_MISMATCH };
-  }
+  if (body.protocol_version !== HUB_PROTOCOL_VERSION) {
+    return { ...base, code: HUB_COMPATIBILITY_CODES.PROTOCOL_MISMATCH };
+  }
+
+  if (strictProduction && !(body?.execution_plane === PRODUCTION_EXECUTION_PLANE
+    && body?.profile === PRODUCTION_PROFILE
+    && Number.isInteger(body?.listen_port) && body.listen_port === PRODUCTION_LISTEN_PORT
+    && typeof body?.runtime_id === 'string' && body.runtime_id.trim().length > 0)) {
+    return { ...base, code: HUB_COMPATIBILITY_CODES.PROVENANCE_MISSING };
+  }
 
   const required = normalizedCapabilities(requiredCapabilities);
   const advertised = new Set(capabilities);