@aiden-ade/sandbox-agent 0.1.75 → 0.1.77

package/dist/index.cjs

@@ -15231,7 +15231,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.75";
+var AGENT_VERSION = "0.1.77";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -37172,6 +37172,13 @@ var ACTIVE_AGENT_RUN_STATUSES = [
 ];
 var STOPPABLE_AGENT_RUN_STATUSES = [...ACTIVE_AGENT_RUN_STATUSES, "paused"];
 
+// ../shared/dist/agent/types.js
+function resolveEffectiveBackendKind(backendKind) {
+  if (backendKind === "codex")
+    return "codex_app_server";
+  return backendKind || "claude_cli";
+}
+
 // ../shared/dist/effort.js
 var EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
 var CLAUDE_EFFORT_LEVELS = [
@@ -38415,7 +38422,12 @@ function findManagedAlanServer(servers) {
   }
   return null;
 }
-var RETIRED_SESSION_HEADER_NAMES = ["x-conversation-id", "x-team-id", "x-allowed-tools"];
+var RETIRED_SESSION_HEADER_NAMES = [
+  "x-conversation-id",
+  "x-team-id",
+  "x-allowed-tools",
+  "authorization"
+];
 function buildSessionHeaders(input2) {
   const headers = {};
   for (const [key, value2] of Object.entries(input2.runHeaders)) {
@@ -41648,7 +41660,7 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
       } else if (resumeId && context.config.systemPromptAppend?.trim()) {
         args.push("--append-system-prompt", context.config.systemPromptAppend.trim());
       }
-      if (context.config.teamId?.trim() && await cliSupportsFlag(command, "--approve-mcps", context.env)) {
+      if (context.config.alanMcp && await cliSupportsFlag(command, "--approve-mcps", context.env)) {
         args.push("--approve-mcps");
       }
       const baseModel = collapseModelIdToBase(context.config.selectedModel?.trim() || "");
@@ -42384,7 +42396,15 @@ function emitCodexFileChanges(context, state, itemId, changes) {
     const toolName = kind === "add" ? "write_file" : "edit_file";
     const toolId = changes.length > 1 ? `${itemId}:${index}` : itemId;
     trackCodexStreamedToolId(state, toolId);
-    void context.presenter.onToolUse(toolName, { file_path: filePath, kind }, toolId);
+    const diffMetadata = {};
+    for (const key of ["additions", "deletions", "patch", "diff"]) {
+      if (record2[key] !== void 0) diffMetadata[key] = record2[key];
+    }
+    void context.presenter.onToolUse(
+      toolName,
+      { file_path: filePath, kind, ...diffMetadata },
+      toolId
+    );
     void context.presenter.onToolResult?.(toolId, `${kind} ${filePath}`);
   });
 }
@@ -43789,7 +43809,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         context.config.images,
         context.cwd
       );
-      const approveMcps = context.config.teamId?.trim() ? await cliSupportsFlag(command, "--approve-mcps", context.env) : false;
+      const approveMcps = context.config.alanMcp ? await cliSupportsFlag(command, "--approve-mcps", context.env) : false;
       try {
         return await createGenericCliBackend({
           kind: "cursor_agent_cli",
@@ -46246,10 +46266,6 @@ ${ctx.promptText}` : ctx.promptText;
 }
 var DROID_DEFAULT_MODEL = "claude-opus-4-8";
 var AGENT_ACTIVITY_HEARTBEAT_MS = 1e4;
-function normalizeBackendKind(kind) {
-  if (kind === "codex") return "codex_app_server";
-  return kind || "claude_cli";
-}
 function firstCatalogModelId(backendKind) {
   const fromPicker = catalogModelsForProvider(backendKind, PROVIDER_MODELS[backendKind]).find(
     (model) => model.id.trim()
@@ -46496,7 +46512,7 @@ var BaseMachineAgent = class _BaseMachineAgent {
     return message.includes("aborted") || message.includes("interrupted") || message.includes("cancelled") || message.includes("canceled");
   }
   resolveBackendKind(config2) {
-    return normalizeBackendKind(this.runtime.backendKind || config2.backendKind);
+    return resolveEffectiveBackendKind(this.runtime.backendKind || config2.backendKind);
   }
   getDefaultSupportTier(backendKind) {
     switch (backendKind) {
@@ -49442,7 +49458,7 @@ async function discoverProviderModelDetails(provider, executable, env) {
 }
 
 // src/daemon-provider-scan.ts
-function normalizeBackendKind2(backendKind) {
+function normalizeBackendKind(backendKind) {
   if (backendKind === "codex") return "codex_app_server";
   return backendKind;
 }
@@ -55672,7 +55688,7 @@ function removeAlanFromJsonConfig(path2, existingContent) {
   }
   return JSON.stringify(config2);
 }
-async function unregisterAlanMcp(backendKind, home = (0, import_node_os8.homedir)()) {
+async function unregisterAlanMcp(backendKind, home = (0, import_node_os8.homedir)(), options = {}) {
   const removedPaths = [];
   const errors = [];
   const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
@@ -55681,6 +55697,12 @@ async function unregisterAlanMcp(backendKind, home = (0, import_node_os8.homedir
     const releaseLock = await waitForConfigLock(`${file2.path}.alan-lock`);
     try {
       const current = (0, import_node_fs14.readFileSync)(file2.path, "utf8");
+      if (options.onlyIfRegistration && !registrationsMatch(
+        parseAlanMcpRegistration(file2.path, current),
+        options.onlyIfRegistration
+      )) {
+        continue;
+      }
       let next;
       if (file2.path.endsWith(".toml")) {
         const stripped = stripCodexAlanMcpSection(current);
@@ -55737,7 +55759,9 @@ function hasUsableRegistrationCredential(headers) {
   return Boolean(normalized.get("x-alan-run-reference") || normalized.get("authorization"));
 }
 function readAlanMcpRegistration(path2) {
-  const content = (0, import_node_fs14.readFileSync)(path2, "utf8");
+  return parseAlanMcpRegistration(path2, (0, import_node_fs14.readFileSync)(path2, "utf8"));
+}
+function parseAlanMcpRegistration(path2, content) {
   if (path2.endsWith(".toml")) {
     try {
       const parsed = parse5(content);
@@ -72923,7 +72947,7 @@ async function handleAgentExecute(ctx, payload) {
     });
     return;
   }
-  const backendKind = normalizeBackendKind2(payload.backendKind);
+  const backendKind = normalizeBackendKind(payload.backendKind);
   let runtimeCommand = resolveBackendRuntimeCommand(backendKind ?? payload.backendKind);
   if (!runtimeCommand && backendKind) {
     runtimeCommand = revalidateBackendRuntimeCommand(backendKind);
@@ -73108,12 +73132,13 @@ async function handleAgentExecute(ctx, payload) {
     });
     return;
   }
+  const registrationBackendKind = resolveEffectiveBackendKind(payload.backendKind);
   const authPromise = backendKind && runtimeCommand && !payload.providerApiKey ? preflightProviderAuth({
     backendKind,
     executable: runtimeCommand,
     env: getDaemonCliEnvironment()
   }).catch(() => ({ status: "unknown" })) : Promise.resolve({ status: "unknown" });
-  const mcpPromise = backendKind ? prepareAlanMcpForRun(backendKind, alanMcp, {
+  const mcpPromise = prepareAlanMcpForRun(registrationBackendKind, alanMcp, {
     // Observe mode resolves after the run has already been accepted, so
     // the verdict is logged here rather than folded into the result.
     onObservedResult: (failure) => {
@@ -73124,7 +73149,7 @@ async function handleAgentExecute(ctx, payload) {
         stage: failure.stage
       });
     }
-  }) : Promise.resolve(null);
+  });
   const skillTaskPromise = prepareSkillInvocationTask({
     manager: runtimeSkillManager,
     runtimeId,
@@ -73160,7 +73185,7 @@ async function handleAgentExecute(ctx, payload) {
     });
     return;
   }
-  if (backendKind && mcpOutcome && !mcpOutcome.ok) {
+  if (!mcpOutcome.ok) {
     pendingRunStarts.delete(payload.runId);
     releaseRunStart();
     const readinessCode = mcpOutcome.code;
@@ -73177,7 +73202,7 @@ async function handleAgentExecute(ctx, payload) {
     });
     return;
   }
-  if (backendKind && alanMcp && mcpOutcome && mcpOutcome.ok && "paths" in mcpOutcome) {
+  if ("paths" in mcpOutcome) {
     pushLog(
       `mcp-ready run=${payload.runId} verification=${"verification" in mcpOutcome ? mcpOutcome.verification : "file"}`
     );
@@ -73346,10 +73371,8 @@ async function handleAgentExecute(ctx, payload) {
     workspaceLease: workspaceLeaseCapture.lease
   });
   pendingRunStarts.delete(payload.runId);
-  if (payload.alanMcp && backendKind) {
-    alanMcpRegisteredRuns.add(payload.runId);
-    alanMcpRegisteredBackends.add(backendKind);
-  }
+  alanMcpRegisteredRuns.set(payload.runId, alanMcp);
+  alanMcpRegisteredBackends.add(registrationBackendKind);
   void agent.run({
     task: preparedTask,
     maxIterations: payload.maxIterations ?? 50,
@@ -74766,6 +74789,15 @@ var SKILL_PROVIDER_SOURCE_DEFINITIONS = [
     userDirectories: [".cursor/skills"],
     repositoryDirectories: [".cursor/skills"]
   },
+  {
+    // Canonical kind, not the `codex_cli` / `codex` aliases: LEGACY_PROVIDER_KIND_MAP
+    // normalizes both to this, and the enabled-provider set is built from
+    // normalized kinds, so a source declared under an alias never matches.
+    providerKind: "codex_app_server",
+    label: "Codex skills",
+    userDirectories: [".codex/skills"],
+    repositoryDirectories: [".codex/skills"]
+  },
   {
     providerKind: "copilot_cli",
     label: "Copilot skills",
@@ -74807,8 +74839,6 @@ function providerKindsForUserDirectory(relativeDirectory) {
   const providers = SKILL_PROVIDER_SOURCE_DEFINITIONS.flatMap((definition) => definition.userDirectories.includes(normalized) ? [definition.providerKind] : []);
   if (providers.length > 0)
     return providers;
-  if (normalized === ".codex/skills")
-    return ["cursor_agent_cli"];
   if (normalized === ".gemini/config/skills")
     return [];
   return void 0;
@@ -74844,6 +74874,11 @@ path = "~/.cursor/skills"
 label = "Cursor skills"
 providers = ["cursor_agent_cli"]
 
+[[skills.sources]]
+path = "~/.codex/skills"
+label = "Codex skills"
+providers = ["codex_app_server"]
+
 [[skills.sources]]
 path = "~/.copilot/skills"
 label = "Copilot skills"
@@ -74864,12 +74899,15 @@ var LocalSkillSource = class {
     const candidates = [];
     const visitedDirectories = /* @__PURE__ */ new Set();
     let incompleteRoot = false;
-    for (const resolvedRoot of resolveScanRoots(input2.roots, input2.enabledProviderKinds ?? [])) {
+    const resolvedRoots = resolveScanRoots(input2.roots, input2.enabledProviderKinds ?? []);
+    const declaredRoots = await canonicalDirectories(resolvedRoots.map((root) => root.directory));
+    for (const resolvedRoot of resolvedRoots) {
       const rootResult = await this.scanRoot(
         resolvedRoot,
         visitedDirectories,
         input2.ignoredPaths ?? [],
-        input2.mode
+        input2.mode,
+        declaredRoots
       );
       candidates.push(...rootResult.candidates);
       diagnostics.push(...rootResult.diagnostics);
@@ -74924,7 +74962,63 @@ var LocalSkillSource = class {
     if (cached2?.contentHash === expectedContentHash) return cached2;
     return inspectSkillPackage(absolutePath, { expectedName: null });
   }
-  async scanRoot(resolvedRoot, visitedDirectories, ignoredPaths, mode) {
+  /**
+   * The root read as one package, or null when it does not hold a SKILL.md.
+   *
+   * `expectedName` is null here on purpose. A package inside a library must be
+   * named for its directory, but a root is whatever the person called the
+   * folder, so that rule would reject it with DIRECTORY_NAME_MISMATCH.
+   */
+  async scanRootAsPackage(resolvedRoot, ignoredPaths, mode) {
+    const directory = resolvedRoot.directory;
+    if (!await pathExists((0, import_node_path16.join)(directory, "SKILL.md"))) return null;
+    const canonicalRoot = await (0, import_promises2.realpath)(directory).catch(() => directory);
+    const name = import_node_path16.default.basename(canonicalRoot);
+    try {
+      const fingerprint = await fingerprintPackage(canonicalRoot);
+      const ignoreSignature = JSON.stringify(ignoredPaths);
+      const cached2 = this.inspectionCache.get(canonicalRoot);
+      const inspected = mode === "incremental" && cached2?.fingerprint === fingerprint && cached2.ignoreSignature === ignoreSignature ? cached2.inspected : await inspectSkillPackage(canonicalRoot, { ignoredPaths, expectedName: null });
+      this.inspectionCache.set(canonicalRoot, { fingerprint, ignoreSignature, inspected });
+      return {
+        candidates: [
+          {
+            absolutePath: canonicalRoot,
+            rootPath: canonicalRoot,
+            order: `${resolvedRoot.order}:${name}`,
+            candidate: {
+              localKey: createLocalKey(resolvedRoot.root, inspected.metadata.name),
+              name: inspected.metadata.name,
+              description: inspected.metadata.description,
+              contentHash: inspected.contentHash,
+              fileCount: inspected.fileCount,
+              totalBytes: inspected.totalBytes,
+              origin: candidateOrigin(resolvedRoot.root),
+              diagnostics: inspected.diagnostics
+            }
+          }
+        ],
+        diagnostics: [],
+        incomplete: false
+      };
+    } catch (error61) {
+      return {
+        candidates: [],
+        diagnostics: [
+          {
+            code: "INVALID_SKILL",
+            message: error61 instanceof Error ? error61.message : String(error61),
+            rootLabel: resolvedRoot.root.label,
+            localKey: createLocalKey(resolvedRoot.root, name)
+          }
+        ],
+        incomplete: false
+      };
+    }
+  }
+  async scanRoot(resolvedRoot, visitedDirectories, ignoredPaths, mode, declaredRoots) {
+    const rootPackage = await this.scanRootAsPackage(resolvedRoot, ignoredPaths, mode);
+    if (rootPackage) return rootPackage;
     let entries;
     try {
       entries = await (0, import_promises2.readdir)(resolvedRoot.directory, { withFileTypes: true });
@@ -74959,10 +75053,11 @@ var LocalSkillSource = class {
         });
         continue;
       }
-      if (!isWithinDirectory(canonicalRoot, canonicalPath)) {
+      const roots = declaredRoots.length > 0 ? declaredRoots : [canonicalRoot];
+      if (!roots.some((root) => isWithinDirectory(root, canonicalPath))) {
         diagnostics.push({
           code: "SOURCE_OUTSIDE_DECLARED_ROOT",
-          message: `Skill ${entry.name} resolves outside ${resolvedRoot.root.label}`,
+          message: `Skill ${entry.name} resolves outside every declared Skill source`,
           rootLabel: resolvedRoot.root.label
         });
         continue;
@@ -74980,6 +75075,7 @@ var LocalSkillSource = class {
         const localKey = createLocalKey(resolvedRoot.root, entry.name);
         candidates.push({
           absolutePath: canonicalPath,
+          rootPath: canonicalRoot,
           order: `${resolvedRoot.order}:${entry.name}`,
           candidate: {
             localKey,
@@ -75022,6 +75118,21 @@ async function fingerprintPackage(root) {
     }
   }
 }
+var CODEX_SOURCE_LABEL = "Codex skills";
+var STALE_CODEX_LABEL = "Legacy Cursor-compatible skills";
+var STALE_CODEX_PROVIDER = "cursor_agent_cli";
+function staleCodexDeclaration(relativeDirectory, label, providerKinds) {
+  const normalized = relativeDirectory.replaceAll("\\", "/").replace(/^\.\//, "");
+  if (normalized !== ".codex/skills") return false;
+  const ownedByCursor = providerKinds !== void 0 && providerKinds.length === 1 && providerKinds[0] === STALE_CODEX_PROVIDER;
+  return ownedByCursor || label === STALE_CODEX_LABEL;
+}
+async function canonicalDirectories(directories) {
+  const canonical = await Promise.all(
+    directories.map((directory) => (0, import_promises2.realpath)(directory).catch(() => directory))
+  );
+  return [...new Set(canonical)];
+}
 function isWithinDirectory(parent, candidate) {
   const path2 = (0, import_node_path16.relative)(parent, candidate);
   return path2 !== ".." && !path2.startsWith(`..${import_node_path16.sep}`) && !(0, import_node_path16.isAbsolute)(path2);
@@ -75119,12 +75230,14 @@ function parseSkillSourceConfig(content, homeDirectory) {
     );
     const relativeDirectory = import_node_path16.default.relative(homeDirectory, sourcePath);
     const inferredProviders = providerKindsForUserDirectory(relativeDirectory);
+    const declaredProviders = value2.providers === void 0 ? inferredProviders : [...new Set(explicitProviders.map((provider) => provider.trim()).filter(Boolean))];
+    const stale = staleCodexDeclaration(relativeDirectory, label, declaredProviders);
     return {
       declarationId,
       path: sourcePath,
-      label,
+      label: stale ? CODEX_SOURCE_LABEL : label,
       precedence: index,
-      providerKinds: value2.providers === void 0 ? inferredProviders : [...new Set(explicitProviders.map((provider) => provider.trim()).filter(Boolean))]
+      providerKinds: stale ? inferredProviders : declaredProviders
     };
   });
   const duplicateId = sources.find(
@@ -75219,12 +75332,23 @@ function hashInventory(candidates) {
   return `sha256:${hash2.digest("hex")}`;
 }
 function deduplicateCandidatesByContent(candidates) {
-  const seen = /* @__PURE__ */ new Set();
-  return candidates.filter(({ candidate }) => {
-    if (seen.has(candidate.contentHash)) return false;
-    seen.add(candidate.contentHash);
+  const bestByContent = /* @__PURE__ */ new Map();
+  for (const located of candidates) {
+    const existing = bestByContent.get(located.candidate.contentHash);
+    if (!existing || located.rootPath.length > existing.rootPath.length) {
+      bestByContent.set(located.candidate.contentHash, located);
+    }
+  }
+  const winners = new Set(bestByContent.values());
+  return candidates.filter((located) => winners.has(located));
+}
+async function pathExists(candidate) {
+  try {
+    await (0, import_promises2.access)(candidate);
     return true;
-  });
+  } catch {
+    return false;
+  }
 }
 async function hasManagedMarker(directory) {
   try {
@@ -76060,7 +76184,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async adoptLegacyProjection(entry) {
     const destination = (0, import_node_path19.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
-    if (await pathExists(destination)) return;
+    if (await pathExists2(destination)) return;
     const manifest = await readLegacyManifest(this.legacyManifestPath);
     const legacy = manifest?.skills[entry.slug];
     if (!legacy) return;
@@ -76150,7 +76274,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       if (!await packageMatches(pending, entry.contentHash)) {
         throw new Error("Pending managed Skill projection failed content verification");
       }
-      if (await pathExists(destination)) {
+      if (await pathExists2(destination)) {
         await (0, import_promises5.rename)(destination, backup);
         movedExisting = true;
       }
@@ -76172,7 +76296,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     } catch (error61) {
       if (!completed && installedPending) {
         await (0, import_promises5.rm)(destination, { recursive: true, force: true });
-        if (movedExisting && await pathExists(backup)) await (0, import_promises5.rename)(backup, destination);
+        if (movedExisting && await pathExists2(backup)) await (0, import_promises5.rename)(backup, destination);
       }
       throw error61;
     } finally {
@@ -76184,7 +76308,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async requireReplaceable(entry) {
     const destination = (0, import_node_path19.join)(this.managedSkillsDirectory, entry.runtimeDirectory);
-    if (!await pathExists(destination)) return;
+    if (!await pathExists2(destination)) return;
     const marker = await readMarker(destination);
     if (!marker) throw unmanagedPathConflict(entry.runtimeDirectory);
     if (marker.skillId === entry.skillId && marker.versionId === entry.versionId && marker.contentHash === entry.contentHash && await packageMatches(destination, entry.contentHash)) {
@@ -76203,7 +76327,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       const destination = (0, import_node_path19.join)(this.managedSkillsDirectory, runtimeDirectory);
       const compatibility = (0, import_node_path19.join)(this.compatibilitySkillsDirectory, runtimeDirectory);
       const marker = await readMarker(destination);
-      if (!await pathExists(destination)) continue;
+      if (!await pathExists2(destination)) continue;
       if (marker && markerMatchesProjection(marker, recorded)) {
         if (!await removeCompatibilityProjection(compatibility, destination, recorded)) {
           failures.push({
@@ -76233,7 +76357,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   async ensureCompatibilityProjection(entry, canonicalDirectory) {
     await (0, import_promises5.mkdir)(this.compatibilitySkillsDirectory, { recursive: true, mode: 448 });
     const destination = (0, import_node_path19.join)(this.compatibilitySkillsDirectory, entry.runtimeDirectory);
-    if (await pathExists(destination)) {
+    if (await pathExists2(destination)) {
       if (await compatibilityProjectionMatches(destination, canonicalDirectory, entry)) return;
       throw unmanagedCompatibilityConflict(entry.runtimeDirectory);
     }
@@ -76350,7 +76474,7 @@ async function compatibilityProjectionMatches(destination, canonicalDirectory, e
   return marker?.canonicalDirectory === canonicalDirectory && marker.skillId === entry.skillId && marker.versionId === entry.versionId && marker.contentHash === entry.contentHash && await packageMatches(destination, entry.contentHash);
 }
 async function removeCompatibilityProjection(destination, canonicalDirectory, projection) {
-  if (!await pathExists(destination)) return true;
+  if (!await pathExists2(destination)) return true;
   const metadata = await (0, import_promises5.lstat)(destination);
   if (metadata.isSymbolicLink()) {
     const target = await (0, import_promises5.readlink)(destination);
@@ -76437,7 +76561,7 @@ function localRasterMediaType(path2) {
 function localTextMediaType(path2) {
   return path2.toLowerCase().endsWith(".md") ? "text/markdown; charset=utf-8" : "text/plain; charset=utf-8";
 }
-async function pathExists(path2) {
+async function pathExists2(path2) {
   try {
     await (0, import_promises5.lstat)(path2);
     return true;
@@ -76680,17 +76804,21 @@ async function startDaemon(args) {
   if (sleepInhibitor.backendNames().length > 0) {
     pushLog(`sleep-inhibitor backends=${sleepInhibitor.backendNames().join(",")}`);
   }
-  const alanMcpRegisteredRuns = /* @__PURE__ */ new Set();
+  const alanMcpRegisteredRuns = /* @__PURE__ */ new Map();
   const alanMcpRegisteredBackends = /* @__PURE__ */ new Set();
   const finalizeAlanMcpForRun = (runId) => {
+    const registration = alanMcpRegisteredRuns.get(runId);
     if (!alanMcpRegisteredRuns.delete(runId)) return;
     if (alanMcpRegisteredRuns.size > 0) return;
     const backends = [...alanMcpRegisteredBackends];
     alanMcpRegisteredBackends.clear();
     void (async () => {
       for (const backend of backends) {
+        if (alanMcpRegisteredRuns.size > 0) return;
         try {
-          const { removedPaths } = await unregisterAlanMcp(backend);
+          const { removedPaths } = await unregisterAlanMcp(backend, void 0, {
+            onlyIfRegistration: registration
+          });
           if (removedPaths.length > 0) {
             pushLog(`mcp-unregistered backend=${backend} run=${runId}`);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {