@pushary/agent-hooks 1.9.7 → 1.9.9

package/dist/{chunk-MZPXVH4A.js → chunk-UF6RBP5V.js}

@@ -1,34 +1,200 @@
-import {
-  addClaudeMcpServer,
-  addPusharyToolPermissions,
-  isPusharyHook,
-  removeClaudeMcpServers
-} from "./chunk-ANEAA37E.js";
 import {
   CLAUDE_HOOK_EVENTS,
   addGeminiMcpServer,
-  removeGeminiMcpServer
-} from "./chunk-JCWZ23MJ.js";
+  removeGeminiMcpServer,
+  supportedClaudeEvents
+} from "./chunk-M3STIAGU.js";
 import {
   CLAUDE_CODE_AGENT,
   parseApplyPatchFiles
-} from "./chunk-QFEM7R6T.js";
+} from "./chunk-KQFTBQ66.js";
 import {
   guardBinary,
   holdBudgetOf,
+  isProtectedByScope,
   registerHookEntry
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-Z23ZBYDW.js";
 import {
+  HOOK_LOCATOR_BINARY,
   PHONE_ANSWERED_TOOLS,
   hookCompatibleProfile,
   hookCompatibleProfileBySource,
   toToolLookup,
   withHookHoldBudget
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-5RGA636G.js";
+
+// src/claude-config.ts
+import { join } from "path";
+import { isDeepStrictEqual } from "util";
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var HOOK_BINARIES = /* @__PURE__ */ new Set([
+  ...CLAUDE_HOOK_EVENTS.map((hook) => hook.binary),
+  HOOK_LOCATOR_BINARY
+]);
+var namesPusharyBinary = (command) => command.split(/[\s/\\"']+/).some((segment) => HOOK_BINARIES.has(segment.replace(/\.(cmd|exe)$/i, "")));
+var isPusharyHook = (entry2, scope) => {
+  const hooks = asRecord(entry2)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    if (isProtectedByScope(command, scope)) return false;
+    return namesPusharyBinary(command);
+  });
+};
+var pusharyMcpServer = (apiKey) => ({
+  type: "http",
+  url: PUSHARY_MCP_URL,
+  headers: { Authorization: `Bearer ${apiKey}` }
+});
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = pusharyMcpServer(apiKey);
+};
+var isClaudeMcpSnapshot = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const snapshot = value;
+  return typeof snapshot.hadMcpServers === "boolean" && typeof snapshot.mcpServersWasRecord === "boolean" && (!snapshot.hadMcpServers || snapshot.mcpServersWasRecord || Object.hasOwn(snapshot, "mcpServers")) && typeof snapshot.hadPushary === "boolean" && (!snapshot.hadPushary || Object.hasOwn(snapshot, "pushary")) && (!Object.hasOwn(snapshot, "installedPushary") || asRecord(snapshot.installedPushary)?.type === "http" && asRecord(snapshot.installedPushary)?.url === PUSHARY_MCP_URL);
+};
+var captureClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = asRecord(config.mcpServers);
+  const hadMcpServers = Object.hasOwn(config, "mcpServers");
+  return {
+    hadMcpServers,
+    mcpServersWasRecord: Boolean(mcpServers),
+    ...hadMcpServers && !mcpServers ? { mcpServers: structuredClone(config.mcpServers) } : {},
+    hadPushary: Boolean(mcpServers && Object.hasOwn(mcpServers, "pushary")),
+    ...mcpServers && Object.hasOwn(mcpServers, "pushary") ? { pushary: structuredClone(mcpServers.pushary) } : {},
+    ...apiKey ? { installedPushary: pusharyMcpServer(apiKey) } : {}
+  };
+};
+var updateClaudeMcpSnapshot = (snapshot, apiKey) => ({
+  ...snapshot,
+  installedPushary: pusharyMcpServer(apiKey)
+});
+var restoreClaudeMcpServer = (config, snapshot) => {
+  const mcpServers = asRecord(config.mcpServers);
+  const current = asRecord(mcpServers?.pushary);
+  if (Object.hasOwn(snapshot, "installedPushary")) {
+    if (!isDeepStrictEqual(mcpServers?.pushary, snapshot.installedPushary)) return false;
+  } else if (current?.type !== "http" || current.url !== PUSHARY_MCP_URL) {
+    return false;
+  }
+  if (!snapshot.mcpServersWasRecord) {
+    if (Object.keys(mcpServers).length === 1) {
+      if (snapshot.hadMcpServers) config.mcpServers = structuredClone(snapshot.mcpServers);
+      else delete config.mcpServers;
+    } else {
+      delete mcpServers.pushary;
+    }
+  } else if (snapshot.hadPushary) {
+    mcpServers.pushary = structuredClone(snapshot.pushary);
+  } else {
+    delete mcpServers.pushary;
+    if (!snapshot.hadMcpServers && Object.keys(mcpServers).length === 0) delete config.mcpServers;
+  }
+  return true;
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var removePusharyToolPermissions = (settings) => {
+  const permissions = asRecord(settings.permissions);
+  if (!permissions || !Array.isArray(permissions.allow)) return false;
+  const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+  if (filtered.length === permissions.allow.length) return false;
+  if (filtered.length === 0) delete permissions.allow;
+  else permissions.allow = filtered;
+  if (Object.keys(permissions).length === 0) delete settings.permissions;
+  return true;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings, binDir, version = null) => {
+  const resolve2 = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = ensureRecord(settings, "hooks");
+  const supported = new Map(supportedClaudeEvents(version).map((hook) => [hook.event, hook]));
+  for (const known of CLAUDE_HOOK_EVENTS) {
+    const current = Array.isArray(hooks[known.event]) ? hooks[known.event] : [];
+    const definition = supported.get(known.event);
+    if (definition) {
+      hooks[known.event] = registerHookEntry(current, isPusharyHook, entry(definition, resolve2));
+      continue;
+    }
+    const others = current.filter((item) => !isPusharyHook(item));
+    if (others.length > 0) {
+      hooks[known.event] = others;
+    } else {
+      delete hooks[known.event];
+    }
+  }
+};
+var entry = (definition, resolve2) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: withHookHoldBudget(resolve2(definition.binary), holdBudgetOf(definition)),
+    timeout: definition.timeout
+  }]
+});
+var removePusharySettings = (settings, scope) => {
+  let changed = scope?.keepMcpServer === true ? false : removeClaudeMcpServers(settings);
+  if (scope?.keepMcpServer !== true && removePusharyToolPermissions(settings)) changed = true;
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const { event: key } of CLAUDE_HOOK_EVENTS) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry2) => !isPusharyHook(entry2, scope));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
 
 // src/compatible-config.ts
 import { homedir } from "os";
-import { isAbsolute, join, resolve } from "path";
+import { isAbsolute, join as join2, resolve } from "path";
 var AGENT_FLAG = "--agent";
 var SOURCE_FLAG = "--source";
 var agentArgument = (profile) => `${AGENT_FLAG}=${profile.agentType}`;
@@ -74,25 +240,25 @@ var normalizeToolCall = (profile, input) => {
   const lookup = lookupFor(profile, input);
   return { ...input, tool_name: lookup.tool, tool_input: lookup.input };
 };
-var underHome = (segments, home = homedir()) => join(home, ...segments);
+var underHome = (segments, home = homedir()) => join2(home, ...segments);
 var compatibleConfigFile = (profile, home) => underHome(profile.configFile, home);
 var compatibleMcpFile = (profile, home) => profile.mcp ? underHome(profile.mcp.file, home) : null;
 var compatibleInstructionsFile = (profile, home) => profile.instructions ? underHome(profile.instructions.file, home) : null;
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-var ensureRecord = (target, key) => {
-  const existing = asRecord(target[key]);
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord2 = (target, key) => {
+  const existing = asRecord2(target[key]);
   if (existing) return existing;
   const created = {};
   target[key] = created;
   return created;
 };
-var descend = (config, keyPath) => keyPath.reduce(ensureRecord, config);
-var findMap = (config, keyPath) => keyPath.reduce((node, key) => node && asRecord(node[key]), config);
+var descend = (config, keyPath) => keyPath.reduce(ensureRecord2, config);
+var findMap = (config, keyPath) => keyPath.reduce((node, key) => node && asRecord2(node[key]), config);
 var pruneEmptyMap = (config, keyPath) => {
   if (keyPath.length === 0) return false;
   const parent = findMap(config, keyPath.slice(0, -1));
   const key = keyPath[keyPath.length - 1];
-  const map = asRecord(parent?.[key]);
+  const map = asRecord2(parent?.[key]);
   if (!parent || !map || Object.keys(map).length > 0) return false;
   delete parent[key];
   return true;
@@ -114,12 +280,12 @@ var WRITTEN = { ok: true };
 var ROOT_KEY = "(root)";
 var dotted = (segments) => segments.join(".") || ROOT_KEY;
 var hooksShapeConflict = (config, profile) => {
-  if (!asRecord(config)) return ROOT_KEY;
+  if (!asRecord2(config)) return ROOT_KEY;
   const walked = [];
   let node = config;
   for (const key of profile.hooksKeyPath) {
     if (node[key] === void 0) return void 0;
-    const nested = asRecord(node[key]);
+    const nested = asRecord2(node[key]);
     if (!nested) return dotted([...walked, key]);
     walked.push(key);
     node = nested;
@@ -128,9 +294,9 @@ var hooksShapeConflict = (config, profile) => {
   return clash ? dotted([...walked, clash.event]) : void 0;
 };
 var permissionsShapeConflict = (config) => {
-  if (!asRecord(config)) return ROOT_KEY;
+  if (!asRecord2(config)) return ROOT_KEY;
   if (config.permissions === void 0) return void 0;
-  const permissions = asRecord(config.permissions);
+  const permissions = asRecord2(config.permissions);
   if (!permissions) return "permissions";
   return permissions.allow !== void 0 && !Array.isArray(permissions.allow) ? "permissions.allow" : void 0;
 };
@@ -154,7 +320,7 @@ var entryFor = (profile, definition, resolve2) => ({
 var addCompatibleHooks = (config, profile, binDir) => {
   const conflictAt = hooksShapeConflict(config, profile);
   if (conflictAt) return { ok: false, conflictAt };
-  const resolve2 = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const resolve2 = (name) => guardBinary(binDir ? join2(binDir, name) : name);
   const hooks = descend(config, profile.hooksKeyPath);
   const supported = new Map(compatibleHookEvents(profile).map((hook) => [hook.event, hook]));
   for (const known of CLAUDE_HOOK_EVENTS) {
@@ -177,7 +343,7 @@ var removeCompatibleHooks = (config, profile, scope) => {
   for (const { event } of CLAUDE_HOOK_EVENTS) {
     const entries = hooks[event];
     if (!Array.isArray(entries)) continue;
-    const kept = entries.filter((entry) => !isPusharyHook(entry, scope));
+    const kept = entries.filter((entry2) => !isPusharyHook(entry2, scope));
     if (kept.length === entries.length) continue;
     if (kept.length === 0) delete hooks[event];
     else hooks[event] = kept;
@@ -191,14 +357,14 @@ var hasCompatibleHooks = (config, profile) => {
   if (!hooks) return false;
   return compatibleHookEvents(profile).some(({ event }) => {
     const entries = hooks[event];
-    return Array.isArray(entries) && entries.some((entry) => isPusharyHook(entry));
+    return Array.isArray(entries) && entries.some((entry2) => isPusharyHook(entry2));
   });
 };
 var missingCompatibleHookEvents = (config, profile) => {
   const hooks = findMap(config, profile.hooksKeyPath);
   return compatibleHookEvents(profile).filter(({ event }) => {
     const entries = hooks?.[event];
-    return !Array.isArray(entries) || !entries.some((entry) => isPusharyHook(entry));
+    return !Array.isArray(entries) || !entries.some((entry2) => isPusharyHook(entry2));
   }).map(({ event }) => event);
 };
 var compatiblePermissionRuleFile = (profile, home) => profile.permissionRuleFile ? underHome(profile.permissionRuleFile, home) : null;
@@ -210,7 +376,7 @@ var addCompatibleMcpServer = (config, profile, apiKey) => {
   }
   addClaudeMcpServer(config, apiKey);
   if (!profile.mcp.trusted) return;
-  const server = asRecord(asRecord(config.mcpServers)?.pushary);
+  const server = asRecord2(asRecord2(config.mcpServers)?.pushary);
   if (server) server.trust = true;
 };
 var removeCompatibleMcpServer = (config, profile) => {
@@ -219,6 +385,16 @@ var removeCompatibleMcpServer = (config, profile) => {
 };
 
 export {
+  addClaudeMcpServer,
+  isClaudeMcpSnapshot,
+  captureClaudeMcpServer,
+  updateClaudeMcpSnapshot,
+  restoreClaudeMcpServer,
+  removeClaudeMcpServers,
+  removePusharyToolPermissions,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings,
   profileFromArgv,
   activeIdentity,
   activeHookSource,

package/dist/{chunk-AVNKVF7N.js → chunk-UPIZSCYD.js}

@@ -4,18 +4,18 @@ import {
 } from "./chunk-POFBE6ZY.js";
 import {
   isNetworkFailure
-} from "./chunk-JXISQ7DT.js";
+} from "./chunk-5N5L6DNN.js";
 import {
   clientReportClaims
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-Z23ZBYDW.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-IRHABAQT.js";
 import {
   CLIENT_REPORT_PATH,
   degradedLine
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-5RGA636G.js";
 
 // src/client-report-claim.ts
 import { createHash } from "crypto";

package/dist/{chunk-3PVDOCFI.js → chunk-VHPFNLRS.js}

@@ -4,7 +4,7 @@ import {
   forkFinishWithUpgradeLock,
   installWithUpgradeLock,
   releaseAutoUpdateLock
-} from "./chunk-RQGODFQN.js";
+} from "./chunk-AZOKPWVI.js";
 import {
   describeAutoUpdateCheck,
   globalInstallLocation,
@@ -14,7 +14,7 @@ import {
   readAutoUpdateState,
   updateAutoUpdateState,
   upgradeEntryFor
-} from "./chunk-QTO6HEZD.js";
+} from "./chunk-K545B734.js";
 import {
   EXIT
 } from "./chunk-KZERVKTD.js";
@@ -27,10 +27,10 @@ import {
   npmErrorMessage,
   readGlobalCliInstallAt,
   readGlobalPrefix
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-Z23ZBYDW.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-STQRUH3S.js";
+} from "./chunk-5DCDQ5VW.js";
 import {
   commandsPackage,
   globalUpgradeEntry,
@@ -39,7 +39,7 @@ import {
   isSameMajorVersion,
   ownPackageRoot,
   packageVersionAt
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-5RGA636G.js";
 
 // src/global-upgrade.ts
 import { existsSync } from "fs";

package/dist/{chunk-HPRZJKRO.js → chunk-VIIHC42X.js}

@@ -1,6 +1,6 @@
 import {
   readTranscriptPreference
-} from "./chunk-ADSQDYYG.js";
+} from "./chunk-REU2VQPH.js";
 
 // src/transcript-setting.ts
 var transcriptEnvironmentPreference = () => {

package/dist/{chunk-D6S5EKXA.js → chunk-WRPYCIV2.js}

@@ -1,23 +1,23 @@
-import {
-  clientErrorKindOf,
-  reportClientError
-} from "./chunk-AVNKVF7N.js";
 import {
   SubscriptionRequiredError,
   callMcpTool
-} from "./chunk-L76HTPU6.js";
+} from "./chunk-6AYSKVLL.js";
+import {
+  clientErrorKindOf,
+  reportClientError
+} from "./chunk-UPIZSCYD.js";
 import {
   installNetworkDefaults
-} from "./chunk-JXISQ7DT.js";
+} from "./chunk-5N5L6DNN.js";
 import {
   getBaseUrl
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-IRHABAQT.js";
 import {
   ASK_AGENT_NAME_MAX,
   ASK_QUESTION_MAX,
   DECISION_LINE_MAX,
   truncateLine
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-5RGA636G.js";
 
 // src/api.ts
 import { randomUUID } from "crypto";
@@ -56,11 +56,9 @@ var isBlockedActionClaim = (data) => {
 
 // src/api.ts
 installNetworkDefaults();
-var DECISION_STOP_REASON = "Approval was cancelled or became unavailable. Retry only after resolving it.";
 var isDecisionStopped = (result) => result.handoffAction === "stop" || ["cancelled", "unavailable", "stopped", "missing"].includes(result.status ?? "");
 var isLocalQuestionHandoff = (result) => result.suppressed === true || result.noDevices === true || result.status === "terminal" || result.status === "notified";
 var STOPPED = { answered: false, handoffAction: "stop" };
-var UNVERIFIABLE_APPROVAL_REASON = "Pushary could not create a verifiable approval. Retry the action.";
 var unavailableQuestionUnlessSubscriptionRequired = (error) => {
   if (error instanceof SubscriptionRequiredError) throw error;
   return { correlationId: "", status: "unavailable" };
@@ -174,10 +172,8 @@ export {
   isPolicyConfig,
   isAskUserResponse,
   isWaitForAnswerResponse,
-  DECISION_STOP_REASON,
   isDecisionStopped,
   isLocalQuestionHandoff,
-  UNVERIFIABLE_APPROVAL_REASON,
   unavailableQuestionUnlessSubscriptionRequired,
   askUser,
   waitForAnswer,

package/dist/{chunk-ZUTU43FT.js → chunk-Z23ZBYDW.js}

@@ -13,7 +13,7 @@ import {
   isReleaseVersion,
   ownPackageName,
   withHookHoldBudget
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-5RGA636G.js";
 
 // src/setup/paths.ts
 import { homedir as homedir2 } from "os";
@@ -365,9 +365,9 @@ var installGlobally = (options) => {
   }
   const started = (async () => {
     if (!npmIsOnPath()) throw new NpmMissingError();
-    const { withUpgradeLock } = await import("./global-upgrade-E2HUEB4B.js");
-    const { installWithUpgradeLock, ownsUpgradeLock } = await import("./upgrade-lock-JCIDZMHF.js");
-    const { autoUpdateLock: autoUpdateLock2 } = await import("./paths-QVTEGNZV.js");
+    const { withUpgradeLock } = await import("./global-upgrade-H272QOGD.js");
+    const { installWithUpgradeLock, ownsUpgradeLock } = await import("./upgrade-lock-L3GHFIRW.js");
+    const { autoUpdateLock: autoUpdateLock2 } = await import("./paths-HMVOTFUN.js");
     let result = "skipped";
     const install = async () => {
       const platform = process.platform;
@@ -438,6 +438,7 @@ var guardHookCommand = (target, platform = process.platform) => {
   return `${HOOK_SHELL} '${HOOK_GUARD_SCRIPTS[guardKindOf(target)]}' ${path}`;
 };
 var guardBinary = (path, platform) => guardHookCommand({ kind: "binary", path, runtime: "node" }, platform);
+var guardNodeScript = (script, platform) => guardHookCommand({ kind: "node", script }, platform);
 var guardCursorGate = (script, platform) => guardHookCommand({ kind: "cursor_gate", script }, platform);
 var guardedArgv = (target, args = [], platform = process.platform) => {
   const path = targetPath(target);
@@ -853,6 +854,7 @@ export {
   installGlobally,
   holdBudgetOf,
   guardBinary,
+  guardNodeScript,
   guardCursorGate,
   guardedArgv,
   registerHookEntry,

package/dist/{chunk-SBLPHUEB.js → chunk-ZGADIZDS.js}

@@ -8,8 +8,9 @@ import {
   SETUP_AGENT_CHOICES,
   SETUP_CONNECT_MODES,
   isSetupConnectMode,
-  isValidApiKey
-} from "./chunk-QR6VE5ME.js";
+  isValidApiKey,
+  normalizeAgentId
+} from "./chunk-5RGA636G.js";
 
 // src/setup/options.ts
 var AGENT_CHOICES = SETUP_AGENT_CHOICES;
@@ -41,8 +42,7 @@ var SETUP_FLAGS = {
   bools: ["key-stdin", "skip-phone", "yes", "y", "json", "dry-run", "take-over-hooks", "help", "h"],
   values: ["key", "connect", "agents", "verify", "control", "transcripts"]
 };
-var effectiveControlMode = (options, stored, configPresent) => options.controlExplicit ? options.control : stored ?? (configPresent ? null : options.control);
-var isAgentChoice = (value) => AGENT_CHOICES.includes(value);
+var effectiveControlMode = (options, stored) => options.controlExplicit ? options.control : stored ?? options.control;
 var parseAgentSelection = (raw, yes) => {
   if (raw === void 0) {
     return yes ? { kind: "auto" } : { kind: "ask" };
@@ -52,13 +52,15 @@ var parseAgentSelection = (raw, yes) => {
   if (value === "none") return { kind: "none" };
   const parts = value.split(",").map((part) => part.trim()).filter((part) => part !== "");
   if (parts.length === 0) throw new UsageError("--agents needs a value");
-  const unknown = parts.filter((part) => !isAgentChoice(part));
+  const resolved = parts.map((part) => ({ part, agent: normalizeAgentId(part, AGENT_CHOICES) }));
+  const unknown = resolved.flatMap(({ part, agent }) => agent === null ? [part] : []);
   if (unknown.length > 0) {
     throw new UsageError(
       `--agents does not know: ${unknown.join(", ")}. Use auto, none, or any of: ${AGENT_CHOICES.join(", ")}`
     );
   }
-  return { kind: "explicit", agents: [...new Set(parts)] };
+  const agents = resolved.flatMap(({ agent }) => agent === null ? [] : [agent]);
+  return { kind: "explicit", agents: [...new Set(agents)] };
 };
 var parseSetupOptions = (input) => {
   const flags = parseFlags(input.argv, SETUP_FLAGS);

package/dist/{global-upgrade-E2HUEB4B.js → global-upgrade-H272QOGD.js}

@@ -5,15 +5,15 @@ import {
   readGlobalUpgradeSubject,
   upgradeInstalledPackage,
   withUpgradeLock
-} from "./chunk-3PVDOCFI.js";
-import "./chunk-RQGODFQN.js";
-import "./chunk-QTO6HEZD.js";
+} from "./chunk-VHPFNLRS.js";
+import "./chunk-AZOKPWVI.js";
+import "./chunk-K545B734.js";
 import "./chunk-POFBE6ZY.js";
 import "./chunk-KZERVKTD.js";
-import "./chunk-ZUTU43FT.js";
+import "./chunk-Z23ZBYDW.js";
 import "./chunk-T7E75EKA.js";
-import "./chunk-STQRUH3S.js";
-import "./chunk-QR6VE5ME.js";
+import "./chunk-5DCDQ5VW.js";
+import "./chunk-5RGA636G.js";
 export {
   finishGlobalUpgrade,
   finishUpgradeWithLock,

package/dist/{paths-QVTEGNZV.js → paths-HMVOTFUN.js}

@@ -32,8 +32,8 @@ import {
   pusharyDir,
   vscodePluginDir,
   vscodePluginMcp
-} from "./chunk-ZUTU43FT.js";
-import "./chunk-QR6VE5ME.js";
+} from "./chunk-Z23ZBYDW.js";
+import "./chunk-5RGA636G.js";
 export {
   autoUpdateLock,
   autoUpdateLog,

package/dist/reapply-Q5NHDTVU.js

@@ -0,0 +1,55 @@
+import {
+  ensureCodexTrustAfterReapply,
+  inspectConfiguredManagedProviders,
+  reapplyAllAgents,
+  reapplyClaudeForVersion,
+  reapplyClaudeSettings,
+  reapplyCodexSettings,
+  reapplyCursorPlugin,
+  reapplyGeminiSettings,
+  reapplyOpenCodePlugin,
+  reapplyVsCodePlugin,
+  repairCodexHolds
+} from "./chunk-6EBGOHDJ.js";
+import "./chunk-NGKUXZID.js";
+import "./chunk-RIVNNBEK.js";
+import "./chunk-XHKBHWLX.js";
+import "./chunk-BZLHTMT6.js";
+import "./chunk-UF6RBP5V.js";
+import "./chunk-BYLKCZ2G.js";
+import "./chunk-M3STIAGU.js";
+import "./chunk-ZGADIZDS.js";
+import "./chunk-MLGIVVSG.js";
+import "./chunk-GMXKITVA.js";
+import "./chunk-6ICPEJY5.js";
+import "./chunk-KQFTBQ66.js";
+import "./chunk-N6IOSZOE.js";
+import "./chunk-MD4SVNT6.js";
+import "./chunk-WRPYCIV2.js";
+import "./chunk-6AYSKVLL.js";
+import "./chunk-QRXPWW3M.js";
+import "./chunk-UPIZSCYD.js";
+import "./chunk-POFBE6ZY.js";
+import "./chunk-5N5L6DNN.js";
+import "./chunk-KOWFRUIT.js";
+import "./chunk-7QLSKOSU.js";
+import "./chunk-KZERVKTD.js";
+import "./chunk-BNSKVIAW.js";
+import "./chunk-Z23ZBYDW.js";
+import "./chunk-T7E75EKA.js";
+import "./chunk-IRHABAQT.js";
+import "./chunk-5DCDQ5VW.js";
+import "./chunk-5RGA636G.js";
+export {
+  ensureCodexTrustAfterReapply,
+  inspectConfiguredManagedProviders,
+  reapplyAllAgents,
+  reapplyClaudeForVersion,
+  reapplyClaudeSettings,
+  reapplyCodexSettings,
+  reapplyCursorPlugin,
+  reapplyGeminiSettings,
+  reapplyOpenCodePlugin,
+  reapplyVsCodePlugin,
+  repairCodexHolds
+};

package/dist/src/index.d.ts

@@ -183,6 +183,7 @@ interface AnswerResult {
     value?: string;
     note?: string;
 }
+
 declare const askUser: (apiKey: string, params: AskUserParams, timeoutMs?: number) => Promise<AskUserResponse>;
 declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?: number, signal?: AbortSignal) => Promise<AnswerResult>;
 declare const cancelQuestion: (apiKey: string, correlationId: string, signal?: AbortSignal) => Promise<{