@moxt-ai/mobius 0.0.28 → 0.0.30

package/dist/index.js

@@ -18903,6 +18903,28 @@ function date4(params) {
 
 // ../protocol/src/prompt-usage.ts
 var TOKEN_COUNT = external_exports.number().int().nonnegative();
+function normalizeQuotaTokenCount(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  if (Reflect.has(value, "inputTokens") || Reflect.has(value, "outputTokens") || Reflect.has(value, "totalTokens")) {
+    return value;
+  }
+  if (!Reflect.has(value, "input_tokens") && !Reflect.has(value, "output_tokens")) {
+    return value;
+  }
+  const inputTokens = Reflect.get(value, "input_tokens");
+  const outputTokens = Reflect.get(value, "output_tokens");
+  const reportedTotal = Reflect.get(value, "total_tokens");
+  return {
+    cachedInputTokens: Reflect.get(value, "cached_input_tokens"),
+    cachedWriteTokens: Reflect.get(value, "cached_write_tokens"),
+    inputTokens,
+    outputTokens,
+    reasoningOutputTokens: Reflect.get(value, "reasoning_output_tokens"),
+    totalTokens: reportedTotal === void 0 && typeof inputTokens === "number" && typeof outputTokens === "number" ? inputTokens + outputTokens : reportedTotal
+  };
+}
 var promptUsageSchema = external_exports.object({
   cachedReadTokens: TOKEN_COUNT.nullish(),
   cachedWriteTokens: TOKEN_COUNT.nullish(),
@@ -18911,14 +18933,17 @@ var promptUsageSchema = external_exports.object({
   thoughtTokens: TOKEN_COUNT.nullish(),
   totalTokens: TOKEN_COUNT
 }).readonly();
-var quotaTokenCountSchema = external_exports.object({
-  cachedInputTokens: TOKEN_COUNT,
-  cachedWriteTokens: TOKEN_COUNT.optional(),
-  inputTokens: TOKEN_COUNT,
-  outputTokens: TOKEN_COUNT,
-  reasoningOutputTokens: TOKEN_COUNT,
-  totalTokens: TOKEN_COUNT
-}).readonly();
+var quotaTokenCountSchema = external_exports.preprocess(
+  normalizeQuotaTokenCount,
+  external_exports.object({
+    cachedInputTokens: TOKEN_COUNT.optional(),
+    cachedWriteTokens: TOKEN_COUNT.optional(),
+    inputTokens: TOKEN_COUNT,
+    outputTokens: TOKEN_COUNT,
+    reasoningOutputTokens: TOKEN_COUNT.optional(),
+    totalTokens: TOKEN_COUNT
+  }).readonly()
+);
 var promptMetadataSchema = external_exports.object({
   quota: external_exports.object({
     model_usage: external_exports.array(
@@ -24926,6 +24951,18 @@ import { createHash, randomUUID } from "node:crypto";
 import { stat as stat3 } from "node:fs/promises";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 var LOCAL_BOT_GRANT_LIFETIME_MILLISECONDS = 90 * 24 * 60 * 60 * 1e3;
+var identifier2 = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/);
+var savedApprovalSchema = external_exports.object({
+  local_grant_id: identifier2,
+  bot_id: identifier2,
+  binding_id: identifier2,
+  binding_revision: external_exports.number().int().positive(),
+  agent_ref: identifier2,
+  workspace_ref: external_exports.string().min(1).max(2048),
+  revocation_epoch: external_exports.number().int().nonnegative(),
+  agent_identity_digest: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  workspace_identity_digest: external_exports.string().regex(/^[a-f0-9]{64}$/)
+}).readonly();
 var LocalBotAuthorizationError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -25030,6 +25067,17 @@ function parseTargets(encoded) {
 }
 var LocalBotGrantStore = class {
   #database;
+  static containsBot = (path2, botId) => {
+    const database = new DatabaseSync3(path2, { readOnly: true });
+    try {
+      if (database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'local_bot_grants'").get() === void 0) {
+        return false;
+      }
+      return database.prepare("SELECT local_grant_id FROM local_bot_grants WHERE bot_id = ? LIMIT 1").get(botId) !== void 0;
+    } finally {
+      database.close();
+    }
+  };
   constructor(path2) {
     this.#database = new DatabaseSync3(path2);
     this.#database.exec(`
@@ -25063,6 +25111,78 @@ var LocalBotGrantStore = class {
           ) STRICT;
         `);
   }
+  /** Only the local CLI may invoke this explicit approval transition. */
+  reapprove = async (botId, catalog, directories, bindingAuthorityId, now, signal) => {
+    signal.throwIfAborted();
+    if (!identifier2.safeParse(botId).success) {
+      throw new LocalBotAuthorizationError("invalid_request", "The Bot ID is invalid");
+    }
+    const row = this.#database.prepare("SELECT * FROM local_bot_grants WHERE bot_id = ? ORDER BY binding_revision DESC LIMIT 1").get(botId);
+    if (row === void 0) {
+      throw new LocalBotAuthorizationError("bot_not_found", "This machine has no saved approval for that Bot");
+    }
+    const parsed = savedApprovalSchema.safeParse(row);
+    if (!parsed.success) {
+      throw new LocalBotAuthorizationError("local_grant_invalid", "The saved Bot approval is invalid", {
+        cause: parsed.error
+      });
+    }
+    const saved = parsed.data;
+    const agent = catalog.find(saved.agent_ref);
+    if (!agent.capabilities.embeddedContextPrompt) {
+      throw new LocalBotAuthorizationError("binding_incompatible", "The local Agent cannot apply Bot context");
+    }
+    const [adapterUnchanged, agentUnchanged] = await Promise.all([
+      revalidateExecutable(agent.adapterIdentity),
+      revalidateExecutable(agent.agentIdentity)
+    ]);
+    signal.throwIfAborted();
+    if (!adapterUnchanged || !agentUnchanged) {
+      throw new LocalBotAuthorizationError(
+        "binding_incompatible",
+        "The local Agent executable changed before approval"
+      );
+    }
+    const workspacePath = await directories.resolve(bindingAuthorityId, saved.workspace_ref, signal);
+    const workspaceIdentityDigest = await workspaceDigest(workspacePath);
+    signal.throwIfAborted();
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const result = this.#database.prepare(`UPDATE local_bot_grants
+                SET agent_identity_digest = ?, workspace_identity_digest = ?, workspace_path = ?,
+                    revoked_at = NULL, expires_at = ?, revocation_epoch = revocation_epoch + 1
+                WHERE local_grant_id = ? AND revocation_epoch = ?
+                    AND agent_identity_digest = ? AND workspace_identity_digest = ?
+                    AND binding_revision = (SELECT MAX(binding_revision) FROM local_bot_grants WHERE bot_id = ?)`).run(
+        agentDigest(agent),
+        workspaceIdentityDigest,
+        workspacePath,
+        now + LOCAL_BOT_GRANT_LIFETIME_MILLISECONDS,
+        saved.local_grant_id,
+        saved.revocation_epoch,
+        saved.agent_identity_digest,
+        saved.workspace_identity_digest,
+        botId
+      );
+      if (result.changes !== 1) {
+        throw new LocalBotAuthorizationError(
+          "binding_not_approved",
+          "The Bot binding changed during approval; run the command again"
+        );
+      }
+      this.#database.prepare(`INSERT INTO audit_events (recorded_at, event, command_id, session_id, details_json)
+                VALUES (?, 'bot_binding_locally_reapproved', ?, '', ?)`).run(
+        new Date(now).toISOString(),
+        saved.binding_id,
+        JSON.stringify({ botId, bindingId: saved.binding_id, agentRef: saved.agent_ref })
+      );
+      this.#database.exec("COMMIT");
+    } catch (cause) {
+      this.#database.exec("ROLLBACK");
+      throw cause;
+    }
+    return { bindingId: saved.binding_id, workspacePath, agentRef: saved.agent_ref };
+  };
   approve = async (request, catalog, directories, bindingAuthorityId, now, signal) => {
     signal.throwIfAborted();
     const existing = this.#database.prepare(
@@ -25759,7 +25879,7 @@ var BotOutboundIpcServer = class {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir4, open as open4, realpath as realpath7, rename as rename3, stat as stat7, writeFile as writeFile2 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename as basename2, join as join14, resolve as resolve3 } from "node:path";
+import { basename as basename2, join as join15, resolve as resolve3 } from "node:path";
 import { fetch as fetch3 } from "undici";
 
 // src/agent-catalog/agent-discovery.ts
@@ -26189,6 +26309,13 @@ var ManagedNpmPackageInstaller = class {
 
 // src/agent-catalog/agent-specification.ts
 import { join as join5 } from "node:path";
+
+// src/agent-catalog/version-output.ts
+function normalizeVersionOutput(output2) {
+  return output2.trim().split(/\r?\n/, 1)[0]?.trim().slice(0, 128) ?? "";
+}
+
+// src/agent-catalog/agent-specification.ts
 var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
 var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
 var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
@@ -26197,6 +26324,8 @@ var LocalAgentSpecification = class {
   authenticationCommand = () => "";
   adapterVersionArguments = ["--version"];
   agentVersionArguments = ["--version"];
+  normalizeAdapterVersion = normalizeVersionOutput;
+  normalizeAgentVersion = normalizeVersionOutput;
   promptTimeoutMilliseconds = DEFAULT_PROMPT_TIMEOUT_MILLISECONDS;
   versionProbeTimeoutMilliseconds = VERSION_PROBE_TIMEOUT_MILLISECONDS;
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
@@ -26308,6 +26437,20 @@ var AgentProbeError = class extends Error {
   }
 };
 
+// src/agent-catalog/agents/resolve-user-local-executable.ts
+import { isAbsolute as isAbsolute4, join as join6 } from "node:path";
+async function resolveUserLocalExecutable(executableName, context) {
+  context.signal.throwIfAborted();
+  const platform = context.platform ?? process.platform;
+  const homeDirectory = context.environment["HOME"];
+  if (platform === "win32" || homeDirectory === void 0 || !isAbsolute4(homeDirectory)) {
+    return [];
+  }
+  const executable = await resolveExecutablePath(join6(homeDirectory, ".local", "bin", executableName), platform);
+  context.signal.throwIfAborted();
+  return executable === null ? [] : [executable];
+}
+
 // src/agent-catalog/agents/verify-session-creation.ts
 import { methods as methods4 } from "@agentclientprotocol/sdk";
 async function verifySessionCreation(connection, capabilities, defaultWorkspace, signal, label) {
@@ -26332,6 +26475,37 @@ async function verifySessionCreation(connection, capabilities, defaultWorkspace,
   }
 }
 
+// src/agent-catalog/agents/copilot-cli-agent.ts
+var COPILOT_CLI_TESTED_VERSION = "1.0.83";
+var CopilotCliAgentSpecification = class extends DirectAcpAgentDefinition {
+  acpProbeTimeoutMilliseconds = 2e4;
+  adapterVersion = COPILOT_CLI_TESTED_VERSION;
+  authenticationCommand = () => "copilot login";
+  agentExecutable = "copilot";
+  id = "github-copilot-cli";
+  label = "GitHub Copilot CLI";
+  versionProbeTimeoutMilliseconds = 1e4;
+  constructor() {
+    super(
+      "MOBIUS_COPILOT_PATH",
+      ["--no-auto-update", "--acp", "--stdio"],
+      ["agents", "github-copilot-cli", COPILOT_CLI_TESTED_VERSION, "bin", "copilot"]
+    );
+  }
+  createLaunchEnvironment = async (_agent, _context) => Object.freeze({ COPILOT_AUTO_UPDATE: "false" });
+  resolveInstalledAgentExecutables = async (context) => await resolveUserLocalExecutable(this.agentExecutable, context);
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    if (capabilities.loadSession !== true || capabilities.sessionCapabilities?.list == null || (initialized.authMethods ?? []).length === 0) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "GitHub Copilot CLI reported an unsupported ACP capability set"
+      );
+    }
+    await verifySessionCreation(connection, capabilities, defaultWorkspace, signal, this.label);
+  };
+};
+
 // src/agent-catalog/agents/cursor-cli-agent.ts
 var CURSOR_CLI_TESTED_VERSION = "2026.09.02-c22c1a3";
 var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
@@ -26358,7 +26532,7 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
 import { realpath as realpath4, stat as stat5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join6, normalize as normalize2 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join7, normalize as normalize2 } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -26376,7 +26550,7 @@ var DEEPSEEK_HARNESS_PACKAGE = new DeepSeekHarnessManagedPackage(
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
 async function validateAgentHome(path2) {
-  if (!isAbsolute4(path2) || normalize2(path2) !== path2) {
+  if (!isAbsolute5(path2) || normalize2(path2) !== path2) {
     throw new AgentProbeError("agent_environment_invalid", "The configured Agent home is invalid");
   }
   try {
@@ -26426,7 +26600,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join6(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join7(readStateDirectory(context.environment), "agents", this.id, "home");
       }
     } catch {
       context.signal.throwIfAborted();
@@ -26442,7 +26616,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join6(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join7(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -26462,9 +26636,41 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/gemini-cli-agent.ts
+var GEMINI_CLI_TESTED_VERSION = "0.59.0";
+var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
+  acpProbeTimeoutMilliseconds = 2e4;
+  adapterVersion = GEMINI_CLI_TESTED_VERSION;
+  authenticationCommand = () => "gemini";
+  agentExecutable = "gemini";
+  id = "gemini-cli";
+  label = "Gemini CLI";
+  versionProbeTimeoutMilliseconds = 1e4;
+  constructor() {
+    super(
+      "MOBIUS_GEMINI_PATH",
+      ["--acp"],
+      [
+        "agents",
+        "gemini-cli",
+        GEMINI_CLI_TESTED_VERSION,
+        "bin",
+        process.platform === "win32" ? "gemini.cmd" : "gemini"
+      ]
+    );
+  }
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    if (capabilities.loadSession !== true || (initialized.authMethods ?? []).length === 0) {
+      throw new AgentProbeError("acp_incompatible", "Gemini CLI reported an unsupported ACP capability set");
+    }
+    await verifySessionCreation(connection, capabilities, defaultWorkspace, signal, this.label);
+  };
+};
+
 // src/agent-catalog/agents/grok-build-agent.ts
 import { realpath as realpath5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join7, relative as relative3, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join8, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/grok-managed-package.ts
 var GROK_BUILD_MANAGED_VERSION = "1.0.21";
@@ -26527,7 +26733,7 @@ function grokBuildManagedPackage(platform, architecture) {
 // src/agent-catalog/agents/grok-build-agent.ts
 function isContainedPath2(root, candidate) {
   const difference = relative3(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute5(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep3}`) && !isAbsolute6(difference);
 }
 var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   adapterVersion = GROK_BUILD_MANAGED_VERSION;
@@ -26555,7 +26761,7 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       if (managed.path === agent.path) {
         return Object.freeze({
           GROK_HOME: await realpath5(
-            join7(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+            join8(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -26566,9 +26772,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath5(join7(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
-    await validateManagedNpmPackage(join7(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
-    const executable = await resolveExecutablePath(join7(versionRoot, "home", "bin", "grok"), platform);
+    const versionRoot = await realpath5(join8(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
+    await validateManagedNpmPackage(join8(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
+    const executable = await resolveExecutablePath(join8(versionRoot, "home", "bin", "grok"), platform);
     signal.throwIfAborted();
     if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
       throw new AgentProbeError("managed_agent_invalid", "The managed Grok Build executable is invalid");
@@ -26585,14 +26791,39 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
 };
 
+// src/agent-catalog/agents/hermes-agent.ts
+var HERMES_TESTED_VERSION = "0.21.1";
+var HermesAgentSpecification = class extends DirectAcpAgentDefinition {
+  acpProbeTimeoutMilliseconds = 2e4;
+  adapterVersion = HERMES_TESTED_VERSION;
+  adapterVersionArguments = ["acp", "--version"];
+  authenticationCommand = () => "hermes acp --setup";
+  agentExecutable = "hermes";
+  agentVersionArguments = ["acp", "--version"];
+  id = "hermes";
+  label = "Hermes Agent";
+  constructor() {
+    super("MOBIUS_HERMES_PATH", ["acp"], ["agents", "hermes", HERMES_TESTED_VERSION, "bin", "hermes"]);
+  }
+  resolveInstalledAgentExecutables = async (context) => await resolveUserLocalExecutable(this.agentExecutable, context);
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    const session = capabilities.sessionCapabilities;
+    if (capabilities.loadSession !== true || session?.fork == null || session.list == null || session.resume == null || (initialized.authMethods ?? []).length === 0) {
+      throw new AgentProbeError("acp_incompatible", "Hermes Agent reported an unsupported ACP capability set");
+    }
+    await verifySessionCreation(connection, capabilities, defaultWorkspace, signal, this.label);
+  };
+};
+
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
 import { createHash as createHash2 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { chmod as chmod2, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open3, realpath as realpath6, rename as rename2, rm as rm2, stat as stat6, writeFile } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute6, join as join8, relative as relative4, sep as sep4 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute7, join as join9, relative as relative4, sep as sep4 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch as fetch2 } from "undici";
@@ -26698,7 +26929,7 @@ function isRecord10(value) {
 }
 function isContainedPath3(root, candidate) {
   const difference = relative4(root, candidate);
-  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep4}`) && !isAbsolute6(difference);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep4}`) && !isAbsolute7(difference);
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
@@ -26777,11 +27008,11 @@ async function validateManagedAgentArchive(root, definition, signal) {
     if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
       throw new Error("Managed Agent root is not user-owned");
     }
-    const manifest = await readManifest(join8(rootPath, "archive.json"));
+    const manifest = await readManifest(join9(rootPath, "archive.json"));
     if (manifest["archiveSha256"] !== definition.archiveSha256 || manifest["archiveUrl"] !== definition.archiveUrl.toString() || manifest["version"] !== definition.version || typeof manifest["executableSha256"] !== "string") {
       throw new Error("Managed Agent archive identity is invalid");
     }
-    const executable = await resolveExecutablePath(join8(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join9(rootPath, "bin", definition.executableName));
     if (executable === null || !isContainedPath3(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
       throw new Error("Managed Agent executable is invalid");
     }
@@ -26873,7 +27104,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
   }
   createLaunchEnvironment = async (_agent, _context) => Object.freeze({ OPENCODE_DISABLE_AUTOUPDATE: "1" });
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join9(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join10(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -26891,7 +27122,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import {
   methods as methods5
 } from "@agentclientprotocol/sdk";
@@ -26950,7 +27181,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join10(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join11(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -26988,7 +27219,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { isAbsolute as isAbsolute7, join as join11 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join12 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -27041,7 +27272,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join11(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join12(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -27052,10 +27283,10 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
     if ((context.platform ?? process.platform) !== "darwin") {
       return [];
     }
-    const requestedPaths = [join11("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
+    const requestedPaths = [join12("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
     const homeDirectory = context.environment["HOME"];
-    if (homeDirectory !== void 0 && isAbsolute7(homeDirectory)) {
-      requestedPaths.unshift(join11(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
+    if (homeDirectory !== void 0 && isAbsolute8(homeDirectory)) {
+      requestedPaths.unshift(join12(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
     }
     const executables = [];
     for (const requestedPath of requestedPaths) {
@@ -27081,12 +27312,15 @@ function supportedLocalAgentSpecifications() {
   return Object.freeze([
     new CodexAgentSpecification(),
     new ClaudeCodeAgentSpecification(),
+    new CopilotCliAgentSpecification(),
     new PiAgentSpecification(),
     new DeepSeekHarnessAgentSpecification(),
+    new HermesAgentSpecification(),
     new OpenCodeAgentSpecification(),
     new CursorCliAgentSpecification(),
     new GrokBuildAgentSpecification(),
-    new WorkBuddyAgentSpecification()
+    new WorkBuddyAgentSpecification(),
+    new GeminiCliAgentSpecification()
   ]);
 }
 
@@ -27098,12 +27332,172 @@ import {
   PROTOCOL_VERSION as PROTOCOL_VERSION2,
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
+var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var VerifiedAcpReadiness = class {
+  adapterVersion;
+  capabilities;
+  constructor(adapterVersion, capabilities) {
+    this.adapterVersion = adapterVersion;
+    this.capabilities = capabilities;
+  }
+};
+var DiscoveryAcpHandler = class {
+  onElicitation = (_request, _signal) => Promise.reject(new Error("ACP probe does not accept elicitations"));
+  onElicitationComplete = (_notification) => Promise.resolve();
+  onPermission = (_request, _signal) => Promise.reject(new Error("ACP probe does not grant permissions"));
+  onUpdate = (_notification) => Promise.resolve();
+};
+function readableAcpStream(input2) {
+  let byteLength = 0;
+  let open5 = true;
+  return new ReadableStream({
+    start(controller) {
+      input2.on("data", (chunk) => {
+        if (!open5) {
+          return;
+        }
+        if (!(chunk instanceof Uint8Array)) {
+          open5 = false;
+          controller.error(new Error("ACP adapter produced invalid output"));
+          return;
+        }
+        byteLength += chunk.byteLength;
+        if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
+          open5 = false;
+          controller.error(new Error("ACP adapter output limit exceeded"));
+          return;
+        }
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      input2.once("end", () => {
+        if (open5) {
+          open5 = false;
+          controller.close();
+        }
+      });
+      input2.once("error", (error61) => {
+        if (open5) {
+          open5 = false;
+          controller.error(error61);
+        }
+      });
+    },
+    cancel() {
+      open5 = false;
+    }
+  });
+}
+function writableAcpStream(output2) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolveWrite, rejectWrite) => {
+        output2.write(chunk, (error61) => {
+          if (error61) {
+            rejectWrite(error61);
+            return;
+          }
+          resolveWrite();
+        });
+      });
+    }
+  });
+}
+async function probeAcpReadiness(specification, agent, environment, defaultWorkspace, signal) {
+  signal.throwIfAborted();
+  const controller = new AbortController();
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error("ACP probe timed out"));
+  }, specification.acpProbeTimeoutMilliseconds);
+  const abort = () => controller.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) {
+    abort();
+  }
+  const child = spawn3(agent.adapterPath, [...agent.arguments], {
+    cwd: defaultWorkspace,
+    detached: process.platform !== "win32",
+    env: { ...environment, ...agent.environment },
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const processExit = new Promise((_resolve, reject) => {
+    const rejectExit = () => reject(new Error("ACP adapter exited during initialization"));
+    child.once("error", reject);
+    child.once("exit", rejectExit);
+    if (child.exitCode !== null || child.signalCode !== null) {
+      rejectExit();
+    }
+  });
+  const stdin = child.stdin;
+  const stdout = child.stdout;
+  const stderr = child.stderr;
+  if (stdin === null || stdout === null || stderr === null) {
+    await stopProcessTree(child);
+    throw new AgentProbeError("acp_incompatible", "ACP adapter streams are unavailable");
+  }
+  let stderrBytes = 0;
+  const consumeStderr = (chunk) => {
+    stderrBytes += chunk.byteLength;
+    if (stderrBytes > ACP_OUTPUT_LIMIT_BYTES) {
+      controller.abort(new Error("ACP adapter output limit exceeded"));
+    }
+  };
+  stderr.on("data", consumeStderr);
+  const connection = createAcpClient(new DiscoveryAcpHandler()).connect(
+    ndJsonStream2(writableAcpStream(stdin), readableAcpStream(stdout))
+  );
+  try {
+    const initialized = await Promise.race([
+      connection.agent.request(
+        methods6.agent.initialize,
+        {
+          clientCapabilities: {},
+          clientInfo: { name: "mobius", version: "0.0.3" },
+          protocolVersion: PROTOCOL_VERSION2
+        },
+        { cancellationSignal: controller.signal }
+      ),
+      processExit
+    ]);
+    if (initialized.protocolVersion !== PROTOCOL_VERSION2) {
+      throw new AgentProbeError("acp_incompatible", "ACP adapter selected an unsupported protocol version");
+    }
+    await specification.verifyAcp(connection, initialized, defaultWorkspace, controller.signal);
+    return new VerifiedAcpReadiness(
+      normalizeVersionOutput(initialized.agentInfo?.version ?? ""),
+      normalizeAcpCapabilities(initialized)
+    );
+  } catch (error61) {
+    if (signal.aborted) {
+      signal.throwIfAborted();
+    }
+    if (timedOut) {
+      throw new AgentProbeError("adapter_probe_timeout", "ACP adapter probe timed out", { cause: error61 });
+    }
+    if (error61 instanceof AgentProbeError) {
+      throw error61;
+    }
+    if (error61 instanceof RequestError2 && error61.code === -32e3 && specification.authenticationCommand().length > 0) {
+      throw new AgentProbeError("authentication_required", "Agent authentication is required", { cause: error61 });
+    }
+    throw new AgentProbeError("acp_incompatible", "ACP adapter initialization failed", { cause: error61 });
+  } finally {
+    clearTimeout(timeout);
+    signal.removeEventListener("abort", abort);
+    connection.close();
+    stdin.end();
+    stderr.removeListener("data", consumeStderr);
+    await stopProcessTree(child);
+  }
+}
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute8, join as join13 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join14 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -27160,7 +27554,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join12(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join13(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -27194,7 +27588,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join13(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join14(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -27205,7 +27599,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
 async function resolveSpecificationExecutables(executableName, overrideVariable, resolveInstalled, resolveManaged, context) {
   const override = context.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute8(override)) {
+    if (override.length === 0 || !isAbsolute9(override)) {
       return [];
     }
     const executable = await resolveExecutablePath(override, context.platform);
@@ -27259,10 +27653,7 @@ async function resolveAdapterExecutable(specification, context) {
   const executables = await resolveAdapterExecutables(specification, context);
   return executables[0] ?? null;
 }
-function normalizedVersion(output2) {
-  return output2.trim().split(/\r?\n/, 1)[0]?.trim().slice(0, 128) ?? "";
-}
-async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal, timeoutMilliseconds) {
+async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal, timeoutMilliseconds, normalize4 = normalizeVersionOutput) {
   const result = await runBoundedProcess({
     arguments: arguments_,
     command: executable.path,
@@ -27271,7 +27662,7 @@ async function probeVersion(executable, arguments_, environment, defaultWorkspac
     signal,
     timeoutMilliseconds
   });
-  const version2 = normalizedVersion(result.stdout || result.stderr);
+  const version2 = normalize4(result.stdout || result.stderr);
   if (version2.length === 0) {
     throw new ProcessExecutionError("process_exit_failed", "The executable did not report a version");
   }
@@ -27295,7 +27686,8 @@ async function findVerifiedAgentExecutable(specification, context) {
         context.environment,
         context.defaultWorkspace,
         context.signal,
-        specification.versionProbeTimeoutMilliseconds
+        specification.versionProbeTimeoutMilliseconds,
+        specification.normalizeAgentVersion
       );
       return new VerifiedAgentExecutable(executable, version2);
     } catch {
@@ -27307,168 +27699,6 @@ async function findVerifiedAgentExecutable(specification, context) {
   return null;
 }
 
-// src/agent-catalog/acp-readiness-probe.ts
-var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
-var VerifiedAcpReadiness = class {
-  adapterVersion;
-  capabilities;
-  constructor(adapterVersion, capabilities) {
-    this.adapterVersion = adapterVersion;
-    this.capabilities = capabilities;
-  }
-};
-var DiscoveryAcpHandler = class {
-  onElicitation = (_request, _signal) => Promise.reject(new Error("ACP probe does not accept elicitations"));
-  onElicitationComplete = (_notification) => Promise.resolve();
-  onPermission = (_request, _signal) => Promise.reject(new Error("ACP probe does not grant permissions"));
-  onUpdate = (_notification) => Promise.resolve();
-};
-function readableAcpStream(input2) {
-  let byteLength = 0;
-  let open5 = true;
-  return new ReadableStream({
-    start(controller) {
-      input2.on("data", (chunk) => {
-        if (!open5) {
-          return;
-        }
-        if (!(chunk instanceof Uint8Array)) {
-          open5 = false;
-          controller.error(new Error("ACP adapter produced invalid output"));
-          return;
-        }
-        byteLength += chunk.byteLength;
-        if (byteLength > ACP_OUTPUT_LIMIT_BYTES) {
-          open5 = false;
-          controller.error(new Error("ACP adapter output limit exceeded"));
-          return;
-        }
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      input2.once("end", () => {
-        if (open5) {
-          open5 = false;
-          controller.close();
-        }
-      });
-      input2.once("error", (error61) => {
-        if (open5) {
-          open5 = false;
-          controller.error(error61);
-        }
-      });
-    },
-    cancel() {
-      open5 = false;
-    }
-  });
-}
-function writableAcpStream(output2) {
-  return new WritableStream({
-    write(chunk) {
-      return new Promise((resolveWrite, rejectWrite) => {
-        output2.write(chunk, (error61) => {
-          if (error61) {
-            rejectWrite(error61);
-            return;
-          }
-          resolveWrite();
-        });
-      });
-    }
-  });
-}
-async function probeAcpReadiness(specification, agent, environment, defaultWorkspace, signal) {
-  signal.throwIfAborted();
-  const controller = new AbortController();
-  let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    controller.abort(new Error("ACP probe timed out"));
-  }, specification.acpProbeTimeoutMilliseconds);
-  const abort = () => controller.abort(signal.reason);
-  signal.addEventListener("abort", abort, { once: true });
-  if (signal.aborted) {
-    abort();
-  }
-  const child = spawn3(agent.adapterPath, [...agent.arguments], {
-    cwd: defaultWorkspace,
-    detached: process.platform !== "win32",
-    env: { ...environment, ...agent.environment },
-    shell: false,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  const processExit = new Promise((_resolve, reject) => {
-    const rejectExit = () => reject(new Error("ACP adapter exited during initialization"));
-    child.once("error", reject);
-    child.once("exit", rejectExit);
-    if (child.exitCode !== null || child.signalCode !== null) {
-      rejectExit();
-    }
-  });
-  const stdin = child.stdin;
-  const stdout = child.stdout;
-  const stderr = child.stderr;
-  if (stdin === null || stdout === null || stderr === null) {
-    await stopProcessTree(child);
-    throw new AgentProbeError("acp_incompatible", "ACP adapter streams are unavailable");
-  }
-  let stderrBytes = 0;
-  const consumeStderr = (chunk) => {
-    stderrBytes += chunk.byteLength;
-    if (stderrBytes > ACP_OUTPUT_LIMIT_BYTES) {
-      controller.abort(new Error("ACP adapter output limit exceeded"));
-    }
-  };
-  stderr.on("data", consumeStderr);
-  const connection = createAcpClient(new DiscoveryAcpHandler()).connect(
-    ndJsonStream2(writableAcpStream(stdin), readableAcpStream(stdout))
-  );
-  try {
-    const initialized = await Promise.race([
-      connection.agent.request(
-        methods6.agent.initialize,
-        {
-          clientCapabilities: {},
-          clientInfo: { name: "mobius", version: "0.0.3" },
-          protocolVersion: PROTOCOL_VERSION2
-        },
-        { cancellationSignal: controller.signal }
-      ),
-      processExit
-    ]);
-    if (initialized.protocolVersion !== PROTOCOL_VERSION2) {
-      throw new AgentProbeError("acp_incompatible", "ACP adapter selected an unsupported protocol version");
-    }
-    await specification.verifyAcp(connection, initialized, defaultWorkspace, controller.signal);
-    return new VerifiedAcpReadiness(
-      normalizedVersion(initialized.agentInfo?.version ?? ""),
-      normalizeAcpCapabilities(initialized)
-    );
-  } catch (error61) {
-    if (signal.aborted) {
-      signal.throwIfAborted();
-    }
-    if (timedOut) {
-      throw new AgentProbeError("adapter_probe_timeout", "ACP adapter probe timed out", { cause: error61 });
-    }
-    if (error61 instanceof AgentProbeError) {
-      throw error61;
-    }
-    if (error61 instanceof RequestError2 && error61.code === -32e3 && specification.authenticationCommand().length > 0) {
-      throw new AgentProbeError("authentication_required", "Agent authentication is required", { cause: error61 });
-    }
-    throw new AgentProbeError("acp_incompatible", "ACP adapter initialization failed", { cause: error61 });
-  } finally {
-    clearTimeout(timeout);
-    signal.removeEventListener("abort", abort);
-    connection.close();
-    stdin.end();
-    stderr.removeListener("data", consumeStderr);
-    await stopProcessTree(child);
-  }
-}
-
 // src/agent-catalog/discover-agent.ts
 function agentProbeFailure(specification, error61) {
   if (error61 instanceof AgentProbeError) {
@@ -27512,7 +27742,8 @@ async function discoverAgent(specification, context) {
         context.environment,
         context.defaultWorkspace,
         context.signal,
-        specification.versionProbeTimeoutMilliseconds
+        specification.versionProbeTimeoutMilliseconds,
+        specification.normalizeAgentVersion
       );
     } catch (error61) {
       if (context.signal.aborted) {
@@ -27548,7 +27779,8 @@ async function discoverAgent(specification, context) {
             },
             context.defaultWorkspace,
             context.signal,
-            specification.versionProbeTimeoutMilliseconds
+            specification.versionProbeTimeoutMilliseconds,
+            specification.normalizeAdapterVersion
           );
         }
       } catch (error61) {
@@ -27821,10 +28053,10 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   return options.pairingId.length > 0 ? decodePairingResponse(value, "runtimeCredential", REDEEM_RESPONSE_KEYS) : decodePairingResponse(value, "daemonToken", CLAIM_RESPONSE_KEYS);
 }
 async function persistConnection(channelId, relayOrigin, runtimeCredential2, defaultWorkspace, environment) {
-  const connectionsDirectory = join14(readStateDirectory(environment), "connections");
+  const connectionsDirectory = join15(readStateDirectory(environment), "connections");
   await mkdir4(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join14(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join14(connectionsDirectory, `.${channelId}.${randomUUID3()}.tmp`);
+  const connectionPath = join15(connectionsDirectory, `${channelId}.json`);
+  const temporaryPath = join15(connectionsDirectory, `.${channelId}.${randomUUID3()}.tmp`);
   await writeFile2(
     temporaryPath,
     `${JSON.stringify(
@@ -27862,7 +28094,7 @@ function decodeSavedConnection(value, expectedChannelId) {
   };
 }
 async function readSavedConnection(channelId, environment) {
-  const connectionPath = join14(readStateDirectory(environment), "connections", `${channelId}.json`);
+  const connectionPath = join15(readStateDirectory(environment), "connections", `${channelId}.json`);
   let encoded = "";
   const handle = await open4(connectionPath, "r");
   try {
@@ -27898,7 +28130,7 @@ function buildPairedDaemon(connection, connectionPath, inventory, environment) {
   const relayUrl = mobiusApiUrl(connection.relayOrigin, "/v1/runtimes/connect");
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.runtimeCredential);
-  const auditDatabasePath = join14(readStateDirectory(environment), "audit", `${connection.channelId}.sqlite`);
+  const auditDatabasePath = join15(readStateDirectory(environment), "audit", `${connection.channelId}.sqlite`);
   return {
     channelUrl: new URL(`/channels/${encodeURIComponent(connection.channelId)}`, connection.relayOrigin).toString(),
     config: createDaemonConfig(
@@ -27960,7 +28192,7 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
 }
 async function resumeMobiusRuntime(channelId, signal, environment = process.env) {
   const normalizedChannelId = validatePairingId(channelId);
-  const connectionPath = join14(readStateDirectory(environment), "connections", `${normalizedChannelId}.json`);
+  const connectionPath = join15(readStateDirectory(environment), "connections", `${normalizedChannelId}.json`);
   const connection = await readSavedConnection(normalizedChannelId, environment);
   const inventory = await discoverLocalAgentInventory({
     defaultWorkspace: connection.defaultWorkspace,
@@ -27975,7 +28207,7 @@ async function resumeLocalMachine(arguments_, signal = new AbortController().sig
 
 // src/run-daemon.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { basename as basename5, join as join16 } from "node:path";
+import { basename as basename5, join as join17 } from "node:path";
 import { styleText } from "node:util";
 import { fetch as fetch7, WebSocket as WebSocket2 } from "undici";
 
@@ -28919,7 +29151,7 @@ async function uploadRuntimeArtifact(config2, sessionId, image, signal) {
 // src/authorization/workspace-directory.ts
 import { readdir, realpath as realpath8, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute9, join as join15, normalize as normalize3, relative as relative5 } from "node:path";
+import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute10, join as join16, normalize as normalize3, relative as relative5 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
   directoryLabel;
@@ -28971,7 +29203,7 @@ var WorkspaceDirectoryService = class {
     }
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute9(path2)) {
+      if (isAbsolute10(path2)) {
         return path2;
       }
     }
@@ -28979,7 +29211,7 @@ var WorkspaceDirectoryService = class {
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute9(requested) || requested.includes("\0") || normalize3(requested) !== requested) {
+    if (!isAbsolute10(requested) || requested.includes("\0") || normalize3(requested) !== requested) {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
@@ -28987,7 +29219,7 @@ var WorkspaceDirectoryService = class {
       signal.throwIfAborted();
       const metadata = await stat8(target);
       signal.throwIfAborted();
-      if (!isAbsolute9(target) || normalize3(target) !== target || !metadata.isDirectory()) {
+      if (!isAbsolute10(target) || normalize3(target) !== target || !metadata.isDirectory()) {
         throw new LocalAuthorizationError("The selected location is not a directory");
       }
       return target;
@@ -29003,7 +29235,7 @@ var WorkspaceDirectoryService = class {
   };
   label = (path2) => {
     const suffix = relative5(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute9(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
+    return suffix === "" ? "~" : !isAbsolute10(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -29033,7 +29265,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join15(target, child.name), signal);
+          const path2 = await this.resolvePath(join16(target, child.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -30905,7 +31137,7 @@ function botIpcSocketPath() {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\mobius-bot-${randomUUID6()}`;
   }
-  return join16("/tmp", `mobius-bot-${randomUUID6()}.sock`);
+  return join17("/tmp", `mobius-bot-${randomUUID6()}.sock`);
 }
 var DaemonAcpObserver = class {
   #config;
@@ -31575,7 +31807,7 @@ async function executeSessionConfigure(publisher, socket, command, config2, dire
     reportOperationFailure(socket, command.requestId, command.sessionId, error61);
   }
 }
-async function executePrompt(outbox, publisher, command, config2, directories, audit, sessions, attemptId, timer, signal) {
+async function executePrompt(outbox, publisher, command, config2, directories, audit, sessions, attemptId, activateAttempt, timer, signal) {
   const activities = new CoalescingDaemonActivityPublisher(timer, (activity) => {
     publisher.recordAttempt(command.sessionId, encodeDaemonActivity(command, activity), attemptId);
   });
@@ -31604,6 +31836,7 @@ async function executePrompt(outbox, publisher, command, config2, directories, a
       }),
       attemptId
     );
+    activateAttempt();
     const attachments = await resolvePromptArtifacts(config2, command, signal);
     let stopReason;
     if (command.disposition === SessionPromptDisposition.Steer) {
@@ -31715,7 +31948,7 @@ function botExecutionAgent(agent, contextHandle, socketPath) {
     agent.capabilities
   );
 }
-async function executeBotPrompt(outbox, publisher, command, config2, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, timer, signal) {
+async function executeBotPrompt(outbox, publisher, command, config2, directories, audit, sessions, grants, contexts, applicator, ipc, attemptId, activateAttempt, timer, signal) {
   const activities = new CoalescingDaemonActivityPublisher(timer, (activity) => {
     publisher.recordAttempt(command.sessionId, encodeDaemonActivity(command, activity), attemptId);
   });
@@ -31796,6 +32029,7 @@ async function executeBotPrompt(outbox, publisher, command, config2, directories
         }),
         attemptId
       );
+      activateAttempt();
       const result = await sessions.runPrompt({
         additionalDirectories: resolved.additionalDirectories,
         agent,
@@ -31989,11 +32223,13 @@ async function runRelayConnection(config2, directories, audit, sessions, install
         }
         const turn = new ActiveDaemonTurn(command, receipt.attemptId);
         activeTurns.set(command.commandId, turn);
-        if (trackActiveAttempt) {
-          activeAttemptIds.set(command.sessionId, receipt.attemptId);
-        }
+        const activateAttempt = () => {
+          if (trackActiveAttempt) {
+            activeAttemptIds.set(command.sessionId, receipt.attemptId);
+          }
+        };
         try {
-          await execute(receipt.attemptId, turn.signal);
+          await execute(receipt.attemptId, activateAttempt, turn.signal);
         } finally {
           activeTurns.delete(command.commandId);
           if (activeAttemptIds.get(command.sessionId) === receipt.attemptId) {
@@ -32078,7 +32314,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             delivery,
             command,
             true,
-            (attemptId, executionSignal) => executeBotPrompt(
+            (attemptId, activateAttempt, executionSignal) => executeBotPrompt(
               outbox,
               publisher,
               command,
@@ -32091,6 +32327,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               applicator,
               ipc,
               attemptId,
+              activateAttempt,
               timer,
               executionSignal
             )
@@ -32103,7 +32340,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             delivery,
             command,
             command.disposition !== SessionPromptDisposition.Steer,
-            (attemptId, executionSignal) => executePrompt(
+            (attemptId, activateAttempt, executionSignal) => executePrompt(
               outbox,
               publisher,
               command,
@@ -32112,6 +32349,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               audit,
               sessions,
               attemptId,
+              activateAttempt,
               timer,
               executionSignal
             )
@@ -32613,7 +32851,6 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             }
             const turn2 = new ActiveDaemonTurn(command2, receipt2.attemptId);
             activeTurns.set(command2.commandId, turn2);
-            activeAttemptIds.set(command2.sessionId, receipt2.attemptId);
             void executeBotPrompt(
               outbox,
               publisher,
@@ -32627,6 +32864,7 @@ async function runRelayConnection(config2, directories, audit, sessions, install
               applicator,
               ipc,
               receipt2.attemptId,
+              () => activeAttemptIds.set(command2.sessionId, receipt2.attemptId),
               timer,
               turn2.signal
             ).catch((error61) => {
@@ -32653,9 +32891,6 @@ async function runRelayConnection(config2, directories, audit, sessions, install
           }
           const turn = new ActiveDaemonTurn(command, receipt.attemptId);
           activeTurns.set(command.commandId, turn);
-          if (command.disposition !== SessionPromptDisposition.Steer) {
-            activeAttemptIds.set(command.sessionId, receipt.attemptId);
-          }
           void executePrompt(
             outbox,
             publisher,
@@ -32665,6 +32900,11 @@ async function runRelayConnection(config2, directories, audit, sessions, install
             audit,
             sessions,
             receipt.attemptId,
+            () => {
+              if (command.disposition !== SessionPromptDisposition.Steer) {
+                activeAttemptIds.set(command.sessionId, receipt.attemptId);
+              }
+            },
             timer,
             turn.signal
           ).catch((error61) => {
@@ -32851,7 +33091,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer) {
 
 // src/runtime.ts
 import { mkdir as mkdir5, realpath as realpath9, stat as stat9 } from "node:fs/promises";
-import { dirname as dirname8, join as join17, resolve as resolve5 } from "node:path";
+import { dirname as dirname8, join as join18, resolve as resolve5 } from "node:path";
 var APP_CREDENTIAL_PATTERN = /^mapp_[a-zA-Z0-9_-]{22}_[a-zA-Z0-9_-]{43}$/;
 var CONVERSATION_CREDENTIAL_PATTERN = /^mconv_[a-zA-Z0-9_-]{22}_[a-zA-Z0-9_-]{43}$/;
 var IDENTIFIER_PATTERN9 = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
@@ -32916,7 +33156,7 @@ function loadMobiusRuntimeConnection(environment = process.env) {
     throw new MobiusRuntimeConfigurationError("MOBIUS_CHANNEL_ID is invalid");
   }
   return Object.freeze({
-    auditDatabasePath: environment["MOBIUS_AUDIT_DATABASE"]?.trim() || join17(readStateDirectory(environment), "audit", `${channelId}.sqlite`),
+    auditDatabasePath: environment["MOBIUS_AUDIT_DATABASE"]?.trim() || join18(readStateDirectory(environment), "audit", `${channelId}.sqlite`),
     channelId,
     defaultWorkspace: loadDefaultWorkspace(environment),
     relayUrl: requiredEnvironmentValue(environment, "MOBIUS_RELAY_URL"),