@ran-sh/dsh-crew 1.9.0 → 1.10.0

package/src/failure-classification.mjs

@@ -1,201 +1,201 @@
-// Pure, secret-free failure classification for workflow and MCP results.
-//
-// Classification consumes structured status/codes/outcomes only. It never
-// parses raw exception text, provider responses, credentials, quotas or logs.
-
-export const FAILURE_CATEGORIES = Object.freeze([
-  'none',
-  'policy',
-  'compatibility',
-  'provider',
-  'runtime',
-  'verification',
-  'cancelled',
-]);
-
-export const FAILURE_REASON_CODES = Object.freeze({
-  NONE: 'NONE',
-  CANCELLED: 'CANCELLED',
-  ATTEMPT_TIMEOUT: 'ATTEMPT_TIMEOUT',
-  RUNTIME_FAILURE: 'RUNTIME_FAILURE',
-  EXECUTION_FAILED: 'EXECUTION_FAILED',
-  TESTS_FAILED: 'TESTS_FAILED',
-  TESTS_NOT_RUN: 'TESTS_NOT_RUN',
-  DELIVERY_INCOMPLETE: 'DELIVERY_INCOMPLETE',
-  WORKSPACE_MISMATCH: 'WORKSPACE_MISMATCH',
-  TASK_BLOCKED: 'TASK_BLOCKED',
-  TASK_PARTIAL: 'TASK_PARTIAL',
-  REVIEW_CHANGES_REQUESTED: 'REVIEW_CHANGES_REQUESTED',
-  REVIEW_INCONCLUSIVE: 'REVIEW_INCONCLUSIVE',
-  POLICY_REJECTED: 'POLICY_REJECTED',
-  HUB_INCOMPATIBLE: 'HUB_INCOMPATIBLE',
-  PROVIDER_UNAVAILABLE: 'PROVIDER_UNAVAILABLE',
-});
-
-const PROVIDER_CODES = new Set([
-  'NO_DSH_PROVIDER_SELECTED',
-  'NO_WORKER_MODEL_AVAILABLE',
-  'MODEL_CATALOG_UNAVAILABLE',
-  'PROVIDER_CATALOG_UNAVAILABLE',
-  'PROVIDER_CATALOG_HEALTH_WARNING',
-]);
-
-const POLICY_CODES = new Set([
-  'SUBAGENTS_DISABLED',
-  'TIER_DISABLED',
-  'NO_AUTO_TIER',
-  'NO_WORKER_TIER',
-  'PRO_NOT_AUTO',
-  'VISION_DISABLED',
-  'ROLE_DISABLED',
-  'ROLE_NOT_AUTO',
-  'ROLE_TIER_CONFLICT',
-]);
-
-const COMPATIBILITY_CODES = new Set([
-  'HUB_UNREACHABLE',
-  'HUB_HTTP_ERROR',
-  'HUB_SERVICE_MISMATCH',
-  'HUB_PROTOCOL_MISSING',
-  'HUB_PROTOCOL_MISMATCH',
-  'HUB_CAPABILITY_MISSING',
-]);
-
-const RUNTIME_CODES = new Set([
-  'ISOLATION_UNAVAILABLE',
-  'NOT_GIT_REPOSITORY',
-  'GIT_NOT_FOUND',
-  'GIT_TIMEOUT',
-  'GIT_ERROR',
-  'WORKTREE_LOCKED',
-  'WORKTREE_CREATE_FAILED',
-  'PROFILE_NOT_FOUND',
-  'PROFILE_ROLE_MISMATCH',
-  'WORKSPACE_CONTEXT_NOT_FOUND',
-  'WORKSPACE_ROOT_MISMATCH',
-  'WORKSPACE_CONTEXT_REFS_INVALID',
-  'CANDIDATE_CAPTURE_FAILED',
-  'ATTEMPT_INFRA_FAILURE',
-  'HUB_REQUEST_FAILED',
-]);
-
-function normalizedCode(value) {
-  return typeof value === 'string' && value.trim() ? value.trim() : null;
-}
-
-function failureFamily(category, reasonCode, sourceCode) {
-  const code = sourceCode ?? reasonCode ?? '';
-  if (category === 'none') return 'NONE';
-  if (category === 'compatibility' || code.startsWith('HUB_')) return 'HARNESS';
-  if (category === 'provider' || code.startsWith('MODEL_') || code.startsWith('PROVIDER_')) return 'MODEL';
-  if (/^(WORK|GIT_|ISOLATION_|CANDIDATE_|PROFILE_)/.test(code)) return 'WORKSPACE';
-  if (String(reasonCode).startsWith('REVIEW_')) return 'REVIEW';
-  if (category === 'policy') return 'POLICY';
-  return 'JOB';
-}
-
-function failureDisposition(category, family) {
-  if (category === 'none') return 'none';
-  if (category === 'cancelled') return 'terminal';
-  if (category === 'compatibility') return 'retry';
-  if (category === 'provider') return 'fallback';
-  if (category === 'policy' || family === 'WORKSPACE' || family === 'REVIEW') return 'human';
-  if (category === 'runtime') return 'retry';
-  return 'terminal';
-}
-
-function result(category, reasonCode, { sourceCode = null, terminalReason = null } = {}) {
-  const family = failureFamily(category, reasonCode, sourceCode);
-  return {
-    schema_version: 1,
-    category,
-    reason_code: reasonCode,
-    ...(sourceCode ? { source_code: sourceCode } : {}),
-    ...(terminalReason ? { terminal_reason: terminalReason } : {}),
-    family,
-    disposition: failureDisposition(category, family),
-  };
-}
-
-function verificationRoot({ outcome, review } = {}) {
-  if (review?.verdict === 'request_changes') return FAILURE_REASON_CODES.REVIEW_CHANGES_REQUESTED;
-  if (review?.verdict === 'inconclusive' && review?.status === 'failed') return FAILURE_REASON_CODES.REVIEW_INCONCLUSIVE;
-  if (outcome?.tests_status === 'FAIL') return FAILURE_REASON_CODES.TESTS_FAILED;
-  if (outcome?.delivery?.complete === false) return FAILURE_REASON_CODES.DELIVERY_INCOMPLETE;
-  if (outcome?.workspace_evidence_ok === false) return FAILURE_REASON_CODES.WORKSPACE_MISMATCH;
-  if (outcome?.task_status === 'blocked') return FAILURE_REASON_CODES.TASK_BLOCKED;
-  if (outcome?.tests_status === 'NOT RUN') return FAILURE_REASON_CODES.TESTS_NOT_RUN;
-  if (outcome?.task_status === 'partial') return FAILURE_REASON_CODES.TASK_PARTIAL;
-  return null;
-}
-
-/**
- * Classify one workflow/result snapshot.
- *
- * Precedence is intentional:
- * 1) cancellation is explicit user/runtime intent;
- * 2) stable compatibility/provider/policy codes identify the failing boundary;
- * 3) timeout/runtime execution failures outrank verification;
- * 4) verification uses the business evidence that caused escalation/failure;
- * 5) otherwise the result is `none`.
- *
- * `decision.reason` is retained only as a bounded terminal reason (for example
- * max_attempts_reached); it never replaces the underlying verification cause.
- */
-export function classifyFailure({
-  phase = null,
-  status = null,
-  errorCode = null,
-  outcome = null,
-  decision = null,
-  review = null,
-  childAttempts = [],
-} = {}) {
-  const code = normalizedCode(errorCode);
-  const terminalReason = normalizedCode(decision?.reason);
-
-  if (phase === 'cancelled' || status === 'cancelled' || code === 'WORKFLOW_CANCELLED') {
-    return result('cancelled', FAILURE_REASON_CODES.CANCELLED, {
-      sourceCode: code === 'WORKFLOW_CANCELLED' ? code : null,
-      terminalReason,
-    });
-  }
-
-  if (code && COMPATIBILITY_CODES.has(code)) {
-    return result('compatibility', code, { sourceCode: code, terminalReason });
-  }
-  if (code && PROVIDER_CODES.has(code)) {
-    return result('provider', FAILURE_REASON_CODES.PROVIDER_UNAVAILABLE, { sourceCode: code, terminalReason });
-  }
-  if (code && POLICY_CODES.has(code)) {
-    return result('policy', FAILURE_REASON_CODES.POLICY_REJECTED, { sourceCode: code, terminalReason });
-  }
-
-  const attempts = Array.isArray(childAttempts) ? childAttempts : [];
-  if (attempts.some((attempt) => attempt?.timed_out === true || attempt?.stopReason === 'timeout')) {
-    return result('runtime', FAILURE_REASON_CODES.ATTEMPT_TIMEOUT, { terminalReason });
-  }
-  if (code && RUNTIME_CODES.has(code)) {
-    return result('runtime', code, { sourceCode: code, terminalReason });
-  }
-  if (outcome?.execution_status === 'failed') {
-    return result('runtime', FAILURE_REASON_CODES.EXECUTION_FAILED, { terminalReason });
-  }
-
-  const verification = verificationRoot({ outcome, review });
-  if (verification) return result('verification', verification, { terminalReason });
-
-  if (phase === 'failed' || status === 'failed') {
-    return result('runtime', FAILURE_REASON_CODES.RUNTIME_FAILURE, {
-      sourceCode: code,
-      terminalReason,
-    });
-  }
-
-  return result('none', FAILURE_REASON_CODES.NONE);
-}
-
-/** Classify an immediate MCP rejection before a workflow exists. */
-export function classifyFailureCode(code) {
-  return classifyFailure({ status: 'failed', errorCode: code });
-}
+// Pure, secret-free failure classification for workflow and MCP results.
+//
+// Classification consumes structured status/codes/outcomes only. It never
+// parses raw exception text, provider responses, credentials, quotas or logs.
+
+export const FAILURE_CATEGORIES = Object.freeze([
+  'none',
+  'policy',
+  'compatibility',
+  'provider',
+  'runtime',
+  'verification',
+  'cancelled',
+]);
+
+export const FAILURE_REASON_CODES = Object.freeze({
+  NONE: 'NONE',
+  CANCELLED: 'CANCELLED',
+  ATTEMPT_TIMEOUT: 'ATTEMPT_TIMEOUT',
+  RUNTIME_FAILURE: 'RUNTIME_FAILURE',
+  EXECUTION_FAILED: 'EXECUTION_FAILED',
+  TESTS_FAILED: 'TESTS_FAILED',
+  TESTS_NOT_RUN: 'TESTS_NOT_RUN',
+  DELIVERY_INCOMPLETE: 'DELIVERY_INCOMPLETE',
+  WORKSPACE_MISMATCH: 'WORKSPACE_MISMATCH',
+  TASK_BLOCKED: 'TASK_BLOCKED',
+  TASK_PARTIAL: 'TASK_PARTIAL',
+  REVIEW_CHANGES_REQUESTED: 'REVIEW_CHANGES_REQUESTED',
+  REVIEW_INCONCLUSIVE: 'REVIEW_INCONCLUSIVE',
+  POLICY_REJECTED: 'POLICY_REJECTED',
+  HUB_INCOMPATIBLE: 'HUB_INCOMPATIBLE',
+  PROVIDER_UNAVAILABLE: 'PROVIDER_UNAVAILABLE',
+});
+
+const PROVIDER_CODES = new Set([
+  'NO_DSH_PROVIDER_SELECTED',
+  'NO_WORKER_MODEL_AVAILABLE',
+  'MODEL_CATALOG_UNAVAILABLE',
+  'PROVIDER_CATALOG_UNAVAILABLE',
+  'PROVIDER_CATALOG_HEALTH_WARNING',
+]);
+
+const POLICY_CODES = new Set([
+  'SUBAGENTS_DISABLED',
+  'TIER_DISABLED',
+  'NO_AUTO_TIER',
+  'NO_WORKER_TIER',
+  'PRO_NOT_AUTO',
+  'VISION_DISABLED',
+  'ROLE_DISABLED',
+  'ROLE_NOT_AUTO',
+  'ROLE_TIER_CONFLICT',
+]);
+
+const COMPATIBILITY_CODES = new Set([
+  'HUB_UNREACHABLE',
+  'HUB_HTTP_ERROR',
+  'HUB_SERVICE_MISMATCH',
+  'HUB_PROTOCOL_MISSING',
+  'HUB_PROTOCOL_MISMATCH',
+  'HUB_CAPABILITY_MISSING',
+]);
+
+const RUNTIME_CODES = new Set([
+  'ISOLATION_UNAVAILABLE',
+  'NOT_GIT_REPOSITORY',
+  'GIT_NOT_FOUND',
+  'GIT_TIMEOUT',
+  'GIT_ERROR',
+  'WORKTREE_LOCKED',
+  'WORKTREE_CREATE_FAILED',
+  'PROFILE_NOT_FOUND',
+  'PROFILE_ROLE_MISMATCH',
+  'WORKSPACE_CONTEXT_NOT_FOUND',
+  'WORKSPACE_ROOT_MISMATCH',
+  'WORKSPACE_CONTEXT_REFS_INVALID',
+  'CANDIDATE_CAPTURE_FAILED',
+  'ATTEMPT_INFRA_FAILURE',
+  'HUB_REQUEST_FAILED',
+]);
+
+function normalizedCode(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function failureFamily(category, reasonCode, sourceCode) {
+  const code = sourceCode ?? reasonCode ?? '';
+  if (category === 'none') return 'NONE';
+  if (category === 'compatibility' || code.startsWith('HUB_')) return 'HARNESS';
+  if (category === 'provider' || code.startsWith('MODEL_') || code.startsWith('PROVIDER_')) return 'MODEL';
+  if (/^(WORK|GIT_|ISOLATION_|CANDIDATE_|PROFILE_)/.test(code)) return 'WORKSPACE';
+  if (String(reasonCode).startsWith('REVIEW_')) return 'REVIEW';
+  if (category === 'policy') return 'POLICY';
+  return 'JOB';
+}
+
+function failureDisposition(category, family) {
+  if (category === 'none') return 'none';
+  if (category === 'cancelled') return 'terminal';
+  if (category === 'compatibility') return 'retry';
+  if (category === 'provider') return 'fallback';
+  if (category === 'policy' || family === 'WORKSPACE' || family === 'REVIEW') return 'human';
+  if (category === 'runtime') return 'retry';
+  return 'terminal';
+}
+
+function result(category, reasonCode, { sourceCode = null, terminalReason = null } = {}) {
+  const family = failureFamily(category, reasonCode, sourceCode);
+  return {
+    schema_version: 1,
+    category,
+    reason_code: reasonCode,
+    ...(sourceCode ? { source_code: sourceCode } : {}),
+    ...(terminalReason ? { terminal_reason: terminalReason } : {}),
+    family,
+    disposition: failureDisposition(category, family),
+  };
+}
+
+function verificationRoot({ outcome, review } = {}) {
+  if (review?.verdict === 'request_changes') return FAILURE_REASON_CODES.REVIEW_CHANGES_REQUESTED;
+  if (review?.verdict === 'inconclusive' && review?.status === 'failed') return FAILURE_REASON_CODES.REVIEW_INCONCLUSIVE;
+  if (outcome?.tests_status === 'FAIL') return FAILURE_REASON_CODES.TESTS_FAILED;
+  if (outcome?.delivery?.complete === false) return FAILURE_REASON_CODES.DELIVERY_INCOMPLETE;
+  if (outcome?.workspace_evidence_ok === false) return FAILURE_REASON_CODES.WORKSPACE_MISMATCH;
+  if (outcome?.task_status === 'blocked') return FAILURE_REASON_CODES.TASK_BLOCKED;
+  if (outcome?.tests_status === 'NOT RUN') return FAILURE_REASON_CODES.TESTS_NOT_RUN;
+  if (outcome?.task_status === 'partial') return FAILURE_REASON_CODES.TASK_PARTIAL;
+  return null;
+}
+
+/**
+ * Classify one workflow/result snapshot.
+ *
+ * Precedence is intentional:
+ * 1) cancellation is explicit user/runtime intent;
+ * 2) stable compatibility/provider/policy codes identify the failing boundary;
+ * 3) timeout/runtime execution failures outrank verification;
+ * 4) verification uses the business evidence that caused escalation/failure;
+ * 5) otherwise the result is `none`.
+ *
+ * `decision.reason` is retained only as a bounded terminal reason (for example
+ * max_attempts_reached); it never replaces the underlying verification cause.
+ */
+export function classifyFailure({
+  phase = null,
+  status = null,
+  errorCode = null,
+  outcome = null,
+  decision = null,
+  review = null,
+  childAttempts = [],
+} = {}) {
+  const code = normalizedCode(errorCode);
+  const terminalReason = normalizedCode(decision?.reason);
+
+  if (phase === 'cancelled' || status === 'cancelled' || code === 'WORKFLOW_CANCELLED') {
+    return result('cancelled', FAILURE_REASON_CODES.CANCELLED, {
+      sourceCode: code === 'WORKFLOW_CANCELLED' ? code : null,
+      terminalReason,
+    });
+  }
+
+  if (code && COMPATIBILITY_CODES.has(code)) {
+    return result('compatibility', code, { sourceCode: code, terminalReason });
+  }
+  if (code && PROVIDER_CODES.has(code)) {
+    return result('provider', FAILURE_REASON_CODES.PROVIDER_UNAVAILABLE, { sourceCode: code, terminalReason });
+  }
+  if (code && POLICY_CODES.has(code)) {
+    return result('policy', FAILURE_REASON_CODES.POLICY_REJECTED, { sourceCode: code, terminalReason });
+  }
+
+  const attempts = Array.isArray(childAttempts) ? childAttempts : [];
+  if (attempts.some((attempt) => attempt?.timed_out === true || attempt?.stopReason === 'timeout')) {
+    return result('runtime', FAILURE_REASON_CODES.ATTEMPT_TIMEOUT, { terminalReason });
+  }
+  if (code && RUNTIME_CODES.has(code)) {
+    return result('runtime', code, { sourceCode: code, terminalReason });
+  }
+  if (outcome?.execution_status === 'failed') {
+    return result('runtime', FAILURE_REASON_CODES.EXECUTION_FAILED, { terminalReason });
+  }
+
+  const verification = verificationRoot({ outcome, review });
+  if (verification) return result('verification', verification, { terminalReason });
+
+  if (phase === 'failed' || status === 'failed') {
+    return result('runtime', FAILURE_REASON_CODES.RUNTIME_FAILURE, {
+      sourceCode: code,
+      terminalReason,
+    });
+  }
+
+  return result('none', FAILURE_REASON_CODES.NONE);
+}
+
+/** Classify an immediate MCP rejection before a workflow exists. */
+export function classifyFailureCode(code) {
+  return classifyFailure({ status: 'failed', errorCode: code });
+}

package/src/history/admission-gate.mjs

@@ -1,67 +1,67 @@
-/**
- * Crew-profile-only runtime adapter. Fence the public agent creation entry,
- * including creations still awaiting publication in the official agent list.
- * Callers must persist their maintenance marker BEFORE asking idle().
- * No original agent is cancelled or disposed by this adapter.
- */
-const installed = new WeakSet();
-const guarded = Symbol.for('dsh-crew.history.admission');
-function method(object, name) {
-  for (let current = object; current; current = Object.getPrototypeOf(current)) {
-    const descriptor = Object.getOwnPropertyDescriptor(current, name);
-    if (descriptor) return descriptor.value;
-  }
-}
-
-/**
- * Whether one registered agent currently owns a running turn.
- *
- * Registration is not activity: the session controller resumes a session into
- * the registry as soon as it opens it, and leaves it there after the turn ends
- * with `status: 'idle'`. Treating a non-empty registry as "in use" therefore
- * wedged cleanup permanently behind ACTIVE_SESSIONS on a machine whose web UI had
- * ever opened a session. Only a `running` status means work is actually in
- * flight; anything else (idle, or a status an older agent does not expose) is
- * treated as not running, and `creating > 0` remains the independent guard for a
- * creation that has not published yet.
- */
-function isRunning(agent) {
-  try { return agent?.status === 'running'; } catch { return false; }
-}
-
-export function installHistoryAdmissionGate(agents, isMaintenancePending) {
-  if (typeof agents?.create !== 'function' || typeof agents?.list !== 'function'
-    || typeof isMaintenancePending !== 'function') throw new Error('HISTORY_ADMISSION_UNAVAILABLE');
-  if (installed.has(agents)) throw new Error('HISTORY_ADMISSION_ALREADY_INSTALLED');
-  const entries = ['create', 'resume'].filter(name => typeof method(agents, name) === 'function')
-    .map(name => ({ name, original: method(agents, name), wrapper: null }));
-  if (!entries.some(entry => entry.name === 'create')) throw new Error('HISTORY_ADMISSION_UNAVAILABLE');
-  if (entries.some(entry => entry.original[guarded])) throw new Error('HISTORY_ADMISSION_ALREADY_INSTALLED');
-  let creating = 0;
-  for (const entry of entries) {
-    entry.wrapper = async function(...args) {
-      if (isMaintenancePending()) throw new Error('HISTORY_MAINTENANCE_PENDING');
-      creating += 1;
-      try { return await entry.original.apply(this, args); }
-      finally { creating -= 1; }
-    };
-    entry.wrapper[guarded] = true;
-    agents[entry.name] = entry.wrapper;
-  }
-  installed.add(agents);
-  return {
-    idle() {
-      // Cordis returns fresh traceable callable proxies; compare descriptors,
-      // not the per-access wrapper returned by agents.create/resume.
-      if (entries.some(entry => method(agents, entry.name) !== entry.wrapper)) return false;
-      try {
-        const live = agents.list();
-        return Array.isArray(live) && creating === 0 && !live.some(isRunning);
-      } catch { return false; }
-    },
-    dispose() {
-      for (const entry of entries) if (method(agents, entry.name) === entry.wrapper) agents[entry.name] = entry.original;
-      installed.delete(agents);
-    },
-  };
-}
+/**
+ * Crew-profile-only runtime adapter. Fence the public agent creation entry,
+ * including creations still awaiting publication in the official agent list.
+ * Callers must persist their maintenance marker BEFORE asking idle().
+ * No original agent is cancelled or disposed by this adapter.
+ */
+const installed = new WeakSet();
+const guarded = Symbol.for('dsh-crew.history.admission');
+function method(object, name) {
+  for (let current = object; current; current = Object.getPrototypeOf(current)) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, name);
+    if (descriptor) return descriptor.value;
+  }
+}
+
+/**
+ * Whether one registered agent currently owns a running turn.
+ *
+ * Registration is not activity: the session controller resumes a session into
+ * the registry as soon as it opens it, and leaves it there after the turn ends
+ * with `status: 'idle'`. Treating a non-empty registry as "in use" therefore
+ * wedged cleanup permanently behind ACTIVE_SESSIONS on a machine whose web UI had
+ * ever opened a session. Only a `running` status means work is actually in
+ * flight; anything else (idle, or a status an older agent does not expose) is
+ * treated as not running, and `creating > 0` remains the independent guard for a
+ * creation that has not published yet.
+ */
+function isRunning(agent) {
+  try { return agent?.status === 'running'; } catch { return false; }
+}
+
+export function installHistoryAdmissionGate(agents, isMaintenancePending) {
+  if (typeof agents?.create !== 'function' || typeof agents?.list !== 'function'
+    || typeof isMaintenancePending !== 'function') throw new Error('HISTORY_ADMISSION_UNAVAILABLE');
+  if (installed.has(agents)) throw new Error('HISTORY_ADMISSION_ALREADY_INSTALLED');
+  const entries = ['create', 'resume'].filter(name => typeof method(agents, name) === 'function')
+    .map(name => ({ name, original: method(agents, name), wrapper: null }));
+  if (!entries.some(entry => entry.name === 'create')) throw new Error('HISTORY_ADMISSION_UNAVAILABLE');
+  if (entries.some(entry => entry.original[guarded])) throw new Error('HISTORY_ADMISSION_ALREADY_INSTALLED');
+  let creating = 0;
+  for (const entry of entries) {
+    entry.wrapper = async function(...args) {
+      if (isMaintenancePending()) throw new Error('HISTORY_MAINTENANCE_PENDING');
+      creating += 1;
+      try { return await entry.original.apply(this, args); }
+      finally { creating -= 1; }
+    };
+    entry.wrapper[guarded] = true;
+    agents[entry.name] = entry.wrapper;
+  }
+  installed.add(agents);
+  return {
+    idle() {
+      // Cordis returns fresh traceable callable proxies; compare descriptors,
+      // not the per-access wrapper returned by agents.create/resume.
+      if (entries.some(entry => method(agents, entry.name) !== entry.wrapper)) return false;
+      try {
+        const live = agents.list();
+        return Array.isArray(live) && creating === 0 && !live.some(isRunning);
+      } catch { return false; }
+    },
+    dispose() {
+      for (const entry of entries) if (method(agents, entry.name) === entry.wrapper) agents[entry.name] = entry.original;
+      installed.delete(agents);
+    },
+  };
+}