@botiverse/raft-daemon 0.72.7-play.20260712141058 → 0.72.8

package/dist/{chunk-4HOAZV4L.js → chunk-FNFNAY5B.js}

@@ -1368,7 +1368,12 @@ var PROMOTED_IDENTITY_ATTRS = [
   "request_id",
   "operation_id",
   "route_pattern",
-  "caller_kind"
+  "caller_kind",
+  "db_system",
+  "query_name",
+  "inbox_backend",
+  "inbox_route",
+  "inbox_fallback_reason"
 ];
 var PROMOTED_CLOSED_ATTRS = [
   "router_reason",
@@ -1390,6 +1395,15 @@ var PROMOTED_CLOSED_ATTRS = [
   "repair_kind",
   "action",
   "error_class",
+  "error_kind",
+  "error_subkind",
+  "rw_failure_stage",
+  "sqlstate",
+  "driver_code",
+  "rw_breaker_state",
+  "fallback_target",
+  "fallback_outcome",
+  "terminal_status",
   "status_bucket",
   "shadow_agent_id",
   "shadow_signal_site",
@@ -2019,13 +2033,20 @@ var integrationUpdateAppRegistrationOperationSchema = integrationAppDraftFieldsS
   unsafeDemoUrlOverride: z.boolean().optional(),
   draftHint: draftHintSchema
 });
+var integrationRecoverAppOwnerOperationSchema = z.object({
+  type: z.literal("integration:recover_app_owner"),
+  clientKey: z.string().trim().min(1).max(120),
+  targetAgent: z.string().trim().min(1).max(120),
+  draftHint: draftHintSchema
+});
 var actionCardActionSchema = z.discriminatedUnion("type", [
   channelCreateOperationSchema,
   agentCreateOperationSchema,
   channelAddMemberOperationSchema,
   integrationApproveAgentLoginOperationSchema,
   integrationRegisterAppOperationSchema,
-  integrationUpdateAppRegistrationOperationSchema
+  integrationUpdateAppRegistrationOperationSchema,
+  integrationRecoverAppOwnerOperationSchema
 ]);
 
 // ../shared/src/featureFlagRolloutGuardrail.ts
@@ -2299,7 +2320,11 @@ var agentApiTaskCreateBodySchema = passthroughObject({
   channel: z3.string().trim().min(1),
   tasks: z3.array(passthroughObject({
     title: z3.string().trim().min(1)
-  })).min(1)
+  })).min(1),
+  assignee: z3.string().trim().refine(
+    (value) => value.startsWith("@") && value.slice(1).trim().length > 0,
+    { message: "assignee must be an @handle" }
+  ).optional()
 });
 var agentApiTaskUnclaimBodySchema = passthroughObject({
   channel: z3.string().trim().min(1),
@@ -2431,6 +2456,20 @@ var agentApiIntegrationAppPrepareBodySchema = passthroughObject({
 var agentApiIntegrationAppRotateSecretBodySchema = passthroughObject({
   clientKey: z3.string().trim().min(1)
 });
+var agentApiIntegrationAppTransferOwnerBodySchema = passthroughObject({
+  clientKey: z3.string().trim().min(1),
+  targetAgent: z3.string().trim().min(1)
+});
+var agentApiIntegrationAppUpdateBodySchema = passthroughObject({
+  clientKey: z3.string().trim().min(1),
+  name: optionalStringSchema,
+  description: optionalStringSchema,
+  homepageUrl: optionalStringSchema,
+  returnUrl: optionalStringSchema,
+  agentManifestUrl: optionalStringSchema,
+  scopes: optionalStringArraySchema,
+  unsafeDemoUrlOverride: optionalBooleanSchema
+});
 var agentApiActionPrepareBodySchema = passthroughObject({
   target: z3.string().trim().min(1),
   action: actionCardActionSchema
@@ -2572,6 +2611,19 @@ var agentApiIntegrationAppRotateSecretResponseSchema = passthroughObject({
   clientName: z3.string(),
   clientSecret: z3.string()
 });
+var agentApiIntegrationAppTransferOwnerResponseSchema = passthroughObject({
+  clientId: z3.string(),
+  clientKey: z3.string(),
+  clientName: z3.string(),
+  ownerAgentId: z3.string(),
+  ownerAgentName: z3.string()
+});
+var agentApiIntegrationAppUpdateResponseSchema = passthroughObject({
+  clientId: z3.string(),
+  clientKey: z3.string(),
+  clientName: z3.string(),
+  updatedFields: z3.array(z3.string())
+});
 var agentApiAttachmentEnvelopeSchema = passthroughObject({
   id: z3.string(),
   filename: z3.string()
@@ -2789,10 +2841,21 @@ var agentApiTaskListResponseSchema = passthroughObject({
 var agentApiCreatedTaskEnvelopeSchema = passthroughObject({
   taskNumber: z3.number().int().positive(),
   messageId: z3.string(),
-  title: z3.string()
+  title: z3.string(),
+  status: taskStatusSchema,
+  claimedByType: z3.enum(["user", "agent"]).nullable(),
+  claimedById: z3.string().nullable(),
+  claimedAt: z3.string().datetime().nullable()
+});
+var agentApiTaskAssignmentReceiptSchema = passthroughObject({
+  messageId: z3.string(),
+  content: z3.string(),
+  assignee: z3.string().startsWith("@"),
+  state: z3.enum(["started", "assigned"])
 });
 var agentApiTaskCreateResponseSchema = passthroughObject({
-  tasks: z3.array(agentApiCreatedTaskEnvelopeSchema)
+  tasks: z3.array(agentApiCreatedTaskEnvelopeSchema),
+  assignmentReceipt: agentApiTaskAssignmentReceiptSchema.optional()
 });
 var agentApiTaskUnclaimResponseSchema = passthroughObject({
   ok: z3.literal(true)
@@ -3334,6 +3397,26 @@ var agentApiContract = {
     request: { body: agentApiIntegrationAppRotateSecretBodySchema },
     response: { body: agentApiIntegrationAppRotateSecretResponseSchema }
   }),
+  integrationAppTransferOwner: route({
+    key: "integrationAppTransferOwner",
+    method: "POST",
+    path: "/integrations/app/transfer-owner",
+    client: { resource: "integrations", method: "transferAppOwner" },
+    capability: "read",
+    description: "Transfer a server-local integration app to another same-server agent. Only the current app owner may transfer it.",
+    request: { body: agentApiIntegrationAppTransferOwnerBodySchema },
+    response: { body: agentApiIntegrationAppTransferOwnerResponseSchema }
+  }),
+  integrationAppUpdate: route({
+    key: "integrationAppUpdate",
+    method: "POST",
+    path: "/integrations/app/update",
+    client: { resource: "integrations", method: "updateApp" },
+    capability: "read",
+    description: "Update a server-local integration app. Only the current app owner may update it.",
+    request: { body: agentApiIntegrationAppUpdateBodySchema },
+    response: { body: agentApiIntegrationAppUpdateResponseSchema }
+  }),
   actionPrepare: route({
     key: "actionPrepare",
     method: "POST",
@@ -4027,20 +4110,20 @@ var EXTERNAL_AGENT_RUNTIME_ID = "external";
 var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
 var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
 var RUNTIMES = [
-  { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
-  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
-  { id: "builtin", displayName: "Built-in Pi", binary: "", supported: true },
-  { id: "antigravity", displayName: "Antigravity CLI", binary: "agy", supported: true },
+  { id: "claude", displayName: "Claude Code", abbreviation: "CC", binary: "claude", supported: true },
+  { id: "codex", displayName: "Codex CLI", abbreviation: "CX", binary: "codex", supported: true },
+  { id: "builtin", displayName: "Built-in Pi", abbreviation: "BP", binary: "", supported: true },
+  { id: "antigravity", displayName: "Antigravity CLI", abbreviation: "AG", binary: "agy", supported: true },
   // Kimi: prefer the in-process SDK (`kimi-sdk` → "Kimi Code") for new agents.
   // The legacy `kimi` (kimi-cli child-process) entry stays for backward compat
   // with existing `runtime=kimi` agents but is labelled deprecated.
-  { id: "kimi-sdk", displayName: "Kimi Code", binary: "", supported: true },
-  { id: "kimi", displayName: "Kimi CLI (deprecated)", binary: "kimi", supported: true },
-  { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
-  { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
-  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
-  { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true },
-  { id: "pi", displayName: "Pi", binary: "pi", supported: true }
+  { id: "kimi-sdk", displayName: "Kimi Code", abbreviation: "KC", binary: "", supported: true },
+  { id: "kimi", displayName: "Kimi CLI (deprecated)", abbreviation: "KL", binary: "kimi", supported: true },
+  { id: "copilot", displayName: "Copilot CLI", abbreviation: "CP", binary: "copilot", supported: true },
+  { id: "cursor", displayName: "Cursor CLI", abbreviation: "CU", binary: "cursor-agent", supported: true },
+  { id: "gemini", displayName: "Gemini CLI", abbreviation: "GM", binary: "gemini", supported: true },
+  { id: "opencode", displayName: "OpenCode", abbreviation: "OC", binary: "opencode", supported: true },
+  { id: "pi", displayName: "Pi", abbreviation: "PI", binary: "pi", supported: true }
 ];
 var RUNTIME_MODELS = {
   [EXTERNAL_AGENT_RUNTIME_ID]: [
@@ -5029,7 +5112,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **What \`raft task create\` really means:**
 - Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
 - \`raft task create\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
-- \`raft task create\` only creates the task \u2014 to own it, call \`raft task claim\` afterward.
+- \`raft task create\` creates an unassigned \`todo\` task by default. \`--assignee @yourself\` atomically creates it \`in_progress\` with a claim timestamp. A server owner/admin may use \`--assignee @someone-else\` to reserve a \`todo\` task for that actor; the assignee must still claim it to start. Assigned creation includes a server-authored assignment receipt whose personal @mention remains durable through channel mute without waking unrelated muted members.
 - Typical uses for \`raft task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
 - If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
 - If the work already exists as a message, reuse it via \`raft task claim --target "#channel" --message-id abc12345\`.
@@ -5439,15 +5522,6 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
-// src/authEnv.ts
-var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
-var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
-function scrubDaemonChildEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  delete env[SLOCK_AGENT_TOKEN_ENV];
-  return env;
-}
-
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -7066,9 +7140,7 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
   "agent-token",
@@ -7423,7 +7495,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -8031,7 +8103,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -8057,7 +8129,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -10261,11 +10333,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -10321,7 +10393,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -10458,15 +10530,12 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
-var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
-var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
-var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -10475,73 +10544,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os4.homedir(), env = process.env) {
-  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  if (inlineConfig && inlineConfig.trim()) {
-    return {
-      raw: inlineConfig,
-      explicitPath: null,
-      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
-    };
-  }
-  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
-  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
-  try {
-    return {
-      raw: readFileSync3(configPath, "utf8"),
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  } catch {
-    return {
-      raw: null,
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  }
-}
-function buildKimiSpawnEnv(env = process.env) {
-  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
-  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
-  return scrubDaemonChildEnv(spawnEnv);
-}
-function buildKimiEffectiveEnv(ctx, overrideEnv) {
-  return {
-    ...process.env,
-    ...ctx.config.envVars || {},
-    ...overrideEnv || {}
-  };
-}
-function buildKimiLaunchOptions(ctx, opts = {}) {
-  const env = buildKimiEffectiveEnv(ctx, opts.env);
-  const source = readKimiConfigSource(opts.home ?? os4.homedir(), env);
-  const args = [];
-  let configFilePath = null;
-  let configContent = null;
-  if (source.explicitPath) {
-    configFilePath = source.explicitPath;
-  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
-    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
-    configContent = source.raw;
-    if (opts.writeGeneratedConfig !== false) {
-      writeFileSync3(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
-      chmodSync(configFilePath, 384);
-    }
-  }
-  if (configFilePath) {
-    args.push("--config-file", configFilePath);
-  }
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
-  }
-  return {
-    args,
-    env: buildKimiSpawnEnv(env),
-    configFilePath,
-    configContent
-  };
-}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -10565,25 +10567,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId, ctx, opts) => {
-      if (!ctx) return { args: ["--model", modelId] };
-      const launchCtx = {
-        ...ctx,
-        config: {
-          ...ctx.config,
-          model: modelId
-        }
-      };
-      const launch = buildKimiLaunchOptions(launchCtx, {
-        home: opts?.home,
-        writeGeneratedConfig: false
-      });
-      return {
-        args: launch.args,
-        env: launch.env,
-        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -10607,23 +10591,21 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config));
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -10631,7 +10613,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -10744,9 +10726,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os4.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -11431,7 +11418,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -23918,11 +23905,14 @@ var AGENT_MIGRATION_OBJECT_STORE_CONTENT_TYPE = "application/vnd.raft.agent-migr
 var ARCHIVE_MANIFEST_PATH = "manifest.json";
 var ARCHIVE_WORKSPACE_PREFIX = "workspace/";
 var MAX_ARCHIVE_MANIFEST_BYTES = 64 * 1024 * 1024;
+var MAX_BUNDLE_TOO_LARGE_ACCOUNTING_ENTRIES = 3;
+var MAX_ENCODED_ACCOUNTING_PATH_LENGTH = 96;
 var AgentMigrationObjectStoreBundleTooLargeError = class extends Error {
-  constructor(actualBytes, maxBytes) {
-    super(`MIGRATION_OBJECT_STORE_BUNDLE_TOO_LARGE:actualBytes=${actualBytes}:maxBytes=${maxBytes}`);
+  constructor(actualBytes, maxBytes, largestEntries = []) {
+    super(bundleTooLargeWireMessage(actualBytes, maxBytes, largestEntries));
     this.actualBytes = actualBytes;
     this.maxBytes = maxBytes;
+    this.largestEntries = largestEntries;
     this.name = "AgentMigrationObjectStoreBundleTooLargeError";
   }
   code = "MIGRATION_OBJECT_STORE_BUNDLE_TOO_LARGE";
@@ -23991,7 +23981,11 @@ async function stageAgentMigrationObjectStoreBundle(input) {
       addContentBytes: (value) => {
         contentBytes += value;
         if (contentBytes > input.maxBytes) {
-          throw new AgentMigrationObjectStoreBundleTooLargeError(contentBytes, input.maxBytes);
+          throw new AgentMigrationObjectStoreBundleTooLargeError(
+            contentBytes,
+            input.maxBytes,
+            archiveManifest ? largestWorkspaceEntries(archiveManifest.manifest) : []
+          );
         }
       }
     }).then(() => next(), next);
@@ -24159,10 +24153,45 @@ function assertAgentMigrationObjectStoreBundleSize(manifest, maxBytes) {
     if (!Number.isSafeInteger(total)) throw new Error("MIGRATION_OBJECT_STORE_FILE_SIZE_INVALID");
   }
   if (total > maxBytes) {
-    throw new AgentMigrationObjectStoreBundleTooLargeError(total, maxBytes);
+    throw new AgentMigrationObjectStoreBundleTooLargeError(
+      total,
+      maxBytes,
+      largestWorkspaceEntries(manifest)
+    );
   }
   return total;
 }
+function largestWorkspaceEntries(manifest, limit = MAX_BUNDLE_TOO_LARGE_ACCOUNTING_ENTRIES) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) return [];
+  const sizeByTopLevelPath = /* @__PURE__ */ new Map();
+  for (const entry of manifest.files) {
+    if (entry.source !== "workspace" || entry.kind !== "file" || !entry.workspaceRelativePath || !Number.isSafeInteger(entry.sizeBytes) || (entry.sizeBytes ?? -1) < 0) {
+      continue;
+    }
+    const relativePath = normalizeWorkspaceRelativePath(entry.workspaceRelativePath);
+    const slashIndex = relativePath.indexOf("/");
+    const accountingPath = slashIndex === -1 ? relativePath : `${relativePath.slice(0, slashIndex)}/`;
+    sizeByTopLevelPath.set(
+      accountingPath,
+      (sizeByTopLevelPath.get(accountingPath) ?? 0) + (entry.sizeBytes ?? 0)
+    );
+  }
+  return [...sizeByTopLevelPath].map(([accountingPath, sizeBytes]) => ({ path: accountingPath, sizeBytes })).sort((left, right) => right.sizeBytes - left.sizeBytes || left.path.localeCompare(right.path)).slice(0, limit);
+}
+function bundleTooLargeWireMessage(actualBytes, maxBytes, largestEntries) {
+  const prefix = `MIGRATION_OBJECT_STORE_BUNDLE_TOO_LARGE:actualBytes=${actualBytes}:maxBytes=${maxBytes}`;
+  const encodedEntries = largestEntries.slice(0, MAX_BUNDLE_TOO_LARGE_ACCOUNTING_ENTRIES).map((entry) => `${encodeAccountingPath(entry.path)},${entry.sizeBytes}`).filter((entry) => entry.length > 0);
+  return encodedEntries.length > 0 ? `${prefix}:topEntries=${encodedEntries.join(";")}` : prefix;
+}
+function encodeAccountingPath(value) {
+  let encoded = "";
+  for (const character of value) {
+    const next = encodeURIComponent(character);
+    if (encoded.length + next.length > MAX_ENCODED_ACCOUNTING_PATH_LENGTH) break;
+    encoded += next;
+  }
+  return encoded;
+}
 function normalizeWorkspaceRelativePath(relativePath) {
   const normalized = path20.posix.normalize(relativePath.replaceAll("\\", "/"));
   if (normalized === "." || normalized.startsWith("../") || normalized === ".." || path20.isAbsolute(normalized)) {
@@ -24457,7 +24486,7 @@ function sanitizePathSegment2(value) {
 }
 
 // src/secretFile.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
 import path22 from "path";
 function readSecretFileSync(filePath) {
   return readFileSync10(filePath, "utf8").trim();
@@ -24751,7 +24780,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-SCXCWA6D.js");
+  await import("./dist-54TOXXOV.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -24883,6 +24912,8 @@ function summarizeIncomingMessage(msg) {
       return `(directory=${msg.directoryName})`;
     case "machine:runtime_models:detect":
       return `(runtime=${msg.runtime}, req=${msg.requestId})`;
+    case "machine:runtimes:rescan":
+      return "(rescan runtimes)";
     case "machine:migration_transport:lease":
       return `(agent=${msg.agentId}, migration=${msg.migrationId}, session=${msg.sessionId}, provider=${msg.provider}, role=${msg.role}, kind=${msg.transferKind}, url=${msg.url ? "set" : "missing"})`;
     case "reminder.upsert":
@@ -25977,6 +26008,13 @@ var DaemonCore = class {
           this.connection.send({ type: "machine:workspace:delete_result", directoryName: msg.directoryName, success });
         });
         break;
+      // Re-detect installed runtimes on demand. `emitReady` already re-runs the
+      // detector and pushes the fresh capabilities, and the server fans those out
+      // as `machine:capabilities` — so re-emitting IS the answer, no bespoke
+      // result message needed.
+      case "machine:runtimes:rescan":
+        this.emitReadyIfConnected();
+        break;
       case "machine:runtime_models:detect": {
         const driver = getDriver(msg.runtime);
         const span = this.tracer.startSpan("daemon.runtime_models.detect", {
@@ -26275,6 +26313,7 @@ export {
   buildAgentMigrationObjectStoreBundle,
   stageAgentMigrationObjectStoreBundle,
   assertAgentMigrationObjectStoreBundleSize,
+  largestWorkspaceEntries,
   buildAgentMigrationAdoptPlan,
   verifyAgentMigrationAdoptPlan,
   executeAgentMigrationAdoptPlan,