@ganglion/xacpx 0.12.1 → 0.14.0

package/dist/cli.js

@@ -141,6 +141,7 @@ ${detail}`,
     sessionBlockedByTasks: (alias, count) => `Session "${alias}" has ${count} unfinished task(s). Cancel or wait for them to complete first.`,
     sessionBlockedByTasksHint: "Use /tasks to list tasks, or /task cancel <id> to cancel one.",
     sessionRemoved: (alias) => `Session "${alias}" removed.`,
+    sessionArchived: (alias) => `Archived session "${alias}". Send a message to restore it.`,
     sessionRemovedWasActive: "This was the active session. Its chat context has been cleared.",
     sessionRemovedWasActivePromoted: (alias) => `This was the active session. Switched back to the previous session "${alias}".`,
     sessionTransportShared: (transportSession, count) => `Note: backend session "${transportSession}" is still referenced by ${count} other session(s) and was not closed.`,
@@ -1236,6 +1237,7 @@ ${detail}`,
     sessionBlockedByTasks: (alias, count) => `会话「${alias}」下还有 ${count} 个未结束的任务，请先取消或等待完成。`,
     sessionBlockedByTasksHint: "使用 /tasks 查看任务列表，或 /task cancel <id> 取消任务。",
     sessionRemoved: (alias) => `已删除会话「${alias}」。`,
+    sessionArchived: (alias) => `已归档会话「${alias}」。发送消息即可恢复。`,
     sessionRemovedWasActive: "该会话是当前活跃会话，已自动清除相关聊天上下文。",
     sessionRemovedWasActivePromoted: (alias) => `该会话是当前活跃会话，已切换回上一个会话「${alias}」。`,
     sessionTransportShared: (transportSession, count) => `提示：后端会话「${transportSession}」仍被其他 ${count} 个会话引用，未关闭。`,
@@ -4695,6 +4697,7 @@ function parseConfig(raw, options = {}) {
       ...typeof transport.command === "string" ? { command: transport.command } : {},
       ...typeof transport.sessionInitTimeoutMs === "number" ? { sessionInitTimeoutMs: transport.sessionInitTimeoutMs } : {},
       ...typeof transport.permissionPolicy === "string" ? { permissionPolicy: transport.permissionPolicy } : {},
+      ...typeof transport.preferLocalAgents === "boolean" ? { preferLocalAgents: transport.preferLocalAgents } : {},
       type: transportType,
       permissionMode,
       nonInteractivePermissions,
@@ -20399,6 +20402,9 @@ function parseCommand(input) {
   if (command === "/session" && parts[1] === "rm" && parts[2] && parts.length === 3) {
     return { kind: "session.rm", alias: parts[2] };
   }
+  if (command === "/session" && parts[1] === "archive" && parts[2] && parts.length === 3) {
+    return { kind: "session.archive", alias: parts[2] };
+  }
   if (command === "/ssn") {
     if (parts.length === 1) {
       return { kind: "session.native.list" };
@@ -20645,7 +20651,7 @@ function parseCommand(input) {
       return { kind: "session.shortcut.new", agent: parts[2], ...shortcutTarget };
     }
   }
-  if (command === "/session" && parts[1] && parts[1] !== "new" && parts[1] !== "attach" && parts[1] !== "reset" && parts[1] !== "rm") {
+  if (command === "/session" && parts[1] && parts[1] !== "new" && parts[1] !== "attach" && parts[1] !== "reset" && parts[1] !== "rm" && parts[1] !== "archive") {
     const shortcutTarget = readSessionShortcutTarget(parts, 2);
     if (shortcutTarget) {
       return { kind: "session.shortcut", agent: parts[1], ...shortcutTarget };
@@ -21109,6 +21115,7 @@ var init_command_policy = __esm(() => {
   COMMAND_KIND_TO_LABEL = {
     "session.reset": "/clear",
     "session.rm": "/session rm",
+    "session.archive": "/session archive",
     "session.tail": "/session tail",
     "replymode.set": "/replymode",
     "replymode.reset": "/replymode reset",
@@ -22326,9 +22333,9 @@ async function handleSessionRemove(context, chatKey, alias) {
   }
   let transportTeardownWarning;
   const shouldTeardownTransport = sharedAliasCount === 0;
-  if (shouldTeardownTransport && context.transport.removeSession) {
+  if (shouldTeardownTransport && context.transport.deleteSession) {
     try {
-      await context.transport.removeSession(session3);
+      await context.transport.deleteSession(session3);
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       transportTeardownWarning = message;
@@ -22361,7 +22368,19 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
+async function handleSessionArchive(context, chatKey, alias, archive) {
+  const internalAlias = await context.sessions.resolveAliasForChat(chatKey, alias);
+  const session3 = await context.sessions.getSession(internalAlias);
+  if (!session3) {
+    return { text: t().session.sessionNotFound(alias) };
+  }
+  await archive(internalAlias);
+  return { text: t().session.sessionArchived(alias) };
+}
+async function promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands) {
+  if (session3.archived) {
+    await context.sessions.setArchived(session3.alias, false);
+  }
   const effectiveReplyMode = resolveEffectiveReplyMode(context.config, chatKey, session3.replyMode);
   if (!session3.replyMode)
     session3.replyMode = effectiveReplyMode;
@@ -22393,7 +22412,7 @@ async function promptWithSession(context, session3, chatKey, text, reply, replyC
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session3, chatKey, text, replyContextToken, accountId);
   try {
     const replyContext = transportReply && context.quota && getChannelIdFromChatKey(chatKey) === "weixin" ? { chatKey, quota: context.quota } : undefined;
-    const result = await context.interaction.promptTransportSession(session3, promptText, transportReply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage);
+    const result = await context.interaction.promptTransportSession(session3, promptText, transportReply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage, onCommands);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -22413,23 +22432,23 @@ async function promptWithSession(context, session3, chatKey, text, reply, replyC
     throw error2;
   }
 }
-async function handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
+async function handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands) {
   try {
-    return await promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+    return await promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session3, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
     }
     return context.recovery.renderTransportError(session3, error2);
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands) {
   const session3 = metadata?.boundSessionAlias ? context.sessions.getResolvedSessionByInternalAlias(metadata.boundSessionAlias) : await context.sessions.getCurrentSession(chatKey);
   if (!session3) {
     return { text: t().session.noCurrent };
   }
-  return await handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+  return await handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
 }
 function toCoordinatorRouteChatMetadata(metadata) {
   if (!metadata) {
@@ -24688,7 +24707,7 @@ class CommandRouter {
     this.logger = logger2 ?? createNoopAppLogger();
     this.activeTurns = activeTurns;
   }
-  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage) {
+  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage, onCommands) {
     const startedAt = Date.now();
     let command = parseCommand(input);
     if (metadata?.channel === "control" && command.kind !== "prompt") {
@@ -24795,6 +24814,8 @@ class CommandRouter {
           return await handleSessionTail(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.lines);
         case "session.rm":
           return await handleSessionRemove(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias);
+        case "session.archive":
+          return await handleSessionArchive(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias, (internalAlias) => this.archiveSessionWithTransport(internalAlias));
         case "groups":
           return await handleGroupList(this.createHandlerContext(), chatKey, command.filter);
         case "group.new":
@@ -24848,16 +24869,16 @@ class CommandRouter {
               ...this.sessions.resolveSession(descriptor.alias, descriptor.agent, descriptor.workspace, descriptor.transportSession),
               transient: true
             };
-            return await handlePromptWithSession(sessionContext, transientSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+            return await handlePromptWithSession(sessionContext, transientSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
           }
           if (metadata?.scheduledSessionAlias) {
             const scheduledSession = await this.sessions.getSession(metadata.scheduledSessionAlias);
             if (!scheduledSession) {
               throw new Error(`session "${metadata.scheduledSessionAlias}" not found for scheduled prompt`);
             }
-            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
           }
-          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage, onCommands);
         }
       }
     });
@@ -24943,6 +24964,82 @@ class CommandRouter {
       await release();
     }
   }
+  async removeSessionWithTransport(internalAlias) {
+    const session3 = await this.sessions.getSession(internalAlias);
+    if (!session3) {
+      throw new Error(`session "${internalAlias}" does not exist`);
+    }
+    if (this.orchestration) {
+      const blocking = await this.orchestration.listSessionBlockingTasks(session3.transportSession);
+      if (blocking.length > 0) {
+        throw new Error(`session "${internalAlias}" has ${blocking.length} blocking task(s); cancel them before deleting`);
+      }
+    }
+    const sharedAliasCount = this.sessions.countAliasesSharingTransport(session3.transportSession, internalAlias);
+    const { wasActive } = await this.sessions.removeSession(internalAlias);
+    if (this.orchestration) {
+      try {
+        await this.orchestration.purgeSessionReferences(session3.transportSession);
+      } catch (error2) {
+        await this.logger.error("session.orchestration_purge_failed", "failed to purge orchestration references after web remove", {
+          alias: internalAlias,
+          transportSession: session3.transportSession,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+    }
+    let transportTornDown = false;
+    let transportTeardownWarning;
+    if (sharedAliasCount === 0 && this.transport.deleteSession) {
+      try {
+        await this.transport.deleteSession(session3);
+        transportTornDown = true;
+      } catch (error2) {
+        transportTeardownWarning = error2 instanceof Error ? error2.message : String(error2);
+        await this.logger.error("session.transport_delete_failed", "failed to delete acpx session after logical remove", {
+          alias: internalAlias,
+          transportSession: session3.transportSession,
+          message: transportTeardownWarning
+        });
+      }
+    }
+    return {
+      wasActive,
+      sharedAliasCount,
+      transportTornDown,
+      ...transportTeardownWarning ? { transportTeardownWarning } : {}
+    };
+  }
+  async archiveSessionWithTransport(internalAlias) {
+    const session3 = await this.sessions.getSession(internalAlias);
+    if (!session3) {
+      throw new Error(`session "${internalAlias}" does not exist`);
+    }
+    if (this.activeTurns?.isActiveAnywhere(internalAlias)) {
+      throw new Error(`session "${internalAlias}" has a running turn; stop it before archiving`);
+    }
+    const shared = this.sessions.countAliasesSharingTransport(session3.transportSession, internalAlias) > 0;
+    if (!shared) {
+      try {
+        await this.transport.cancel(session3);
+      } catch {}
+      if (this.transport.removeSession) {
+        try {
+          await this.transport.removeSession(session3);
+        } catch (error2) {
+          await this.logger.error("session.archive_close_failed", "failed to close acpx session on archive", {
+            alias: internalAlias,
+            transportSession: session3.transportSession,
+            message: error2 instanceof Error ? error2.message : String(error2)
+          });
+        }
+      }
+    }
+    await this.sessions.setArchived(internalAlias, true);
+  }
+  async unarchiveSession(internalAlias) {
+    await this.sessions.setArchived(internalAlias, false);
+  }
   async listNativeSessionsForControl(agent3, workspace3) {
     const listAgentSessions = this.transport.listAgentSessions?.bind(this.transport);
     if (!listAgentSessions)
@@ -25005,7 +25102,7 @@ class CommandRouter {
       setModelTransportSession: (session3, modelId) => this.setModelTransportSession(session3, modelId),
       getModelTransportSession: (session3) => this.getModelTransportSession(session3),
       cancelTransportSession: (session3) => this.cancelTransportSession(session3),
-      promptTransportSession: (session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride, onPlan, onUsage) => this.promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride ?? perfSpan, onPlan, onUsage)
+      promptTransportSession: (session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride, onPlan, onUsage, onCommands) => this.promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride ?? perfSpan, onPlan, onUsage, onCommands)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -25184,7 +25281,7 @@ class CommandRouter {
   async checkTransportSession(session3) {
     return await this.measureTransportCall("has_session", session3, () => this.transport.hasSession(session3));
   }
-  async promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage) {
+  async promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage, onCommands) {
     session3.mcpCoordinatorSession ??= stableCoordinatorSession(session3.transportSession);
     let done = false;
     let abortRequested = false;
@@ -25243,7 +25340,8 @@ class CommandRouter {
         ...onToolEvent ? { onToolEvent } : {},
         ...onThought ? { onThought } : {},
         ...onPlan ? { onPlan } : {},
-        ...onUsage ? { onUsage } : {}
+        ...onUsage ? { onUsage } : {},
+        ...onCommands ? { onCommands } : {}
       }));
     } catch (error2) {
       localOutcome = isAbortError2(error2) || abortRequested ? "aborted" : "error";
@@ -25429,7 +25527,7 @@ class ConsoleAgent {
       ...m.fileName ? { fileName: m.fileName } : {}
     })) : undefined;
     request.perfSpan?.mark("agent.dispatched");
-    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent, request.onThought, request.perfSpan, request.onPlan, request.onUsage);
+    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent, request.onThought, request.perfSpan, request.onPlan, request.onUsage, request.onCommands);
   }
   isKnownCommand(text) {
     return isKnownXacpxCommandText(text);
@@ -29659,6 +29757,10 @@ class SessionService {
       const previousCurrent = prevCtx?.current_session;
       const carriedPrevious = previousCurrent && previousCurrent !== internalAlias ? previousCurrent : prevCtx?.previous_session;
       session3.last_used_at = new Date().toISOString();
+      if (session3.archived) {
+        delete session3.archived;
+        delete session3.archived_at;
+      }
       const nextCtx = { ...prevCtx, current_session: internalAlias };
       if (carriedPrevious) {
         nextCtx.previous_session = carriedPrevious;
@@ -29860,6 +29962,22 @@ class SessionService {
     }
     return count;
   }
+  async setArchived(alias, archived) {
+    await this.mutate(async () => {
+      const session3 = this.state.sessions[alias];
+      if (!session3) {
+        throw new Error(`session "${alias}" does not exist`);
+      }
+      if (archived) {
+        session3.archived = true;
+        session3.archived_at = new Date(this.now()).toISOString();
+      } else {
+        delete session3.archived;
+        delete session3.archived_at;
+      }
+      await this.persist();
+    });
+  }
   async removeSession(alias) {
     return await this.mutate(async () => {
       const session3 = this.state.sessions[alias];
@@ -29974,7 +30092,8 @@ class SessionService {
       modeId: session3.mode_id,
       replyMode: session3.reply_mode,
       effectiveReplyMode,
-      cwd: workspaceConfig.cwd
+      cwd: workspaceConfig.cwd,
+      archived: session3.archived === true
     };
   }
   async setSessionModel(alias, modelId) {
@@ -30489,6 +30608,10 @@ function encodeBridgePromptUsageEvent(event) {
   return `${JSON.stringify(event)}
 `;
 }
+function encodeBridgePromptCommandsEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
 function encodeBridgeSessionProgressEvent(event) {
   return `${JSON.stringify(event)}
 `;
@@ -30795,7 +30918,14 @@ class AcpxBridgeClient {
         pending.onEvent?.({
           type: "prompt.usage",
           used: message.used,
-          size: message.size
+          size: message.size,
+          ...message.cost ? { cost: message.cost } : {},
+          ...message.breakdown ? { breakdown: message.breakdown } : {}
+        });
+      } else if (message.event === "prompt.commands") {
+        pending.onEvent?.({
+          type: "prompt.commands",
+          commands: message.commands
         });
       } else if (message.event === "session.progress") {
         pending.onEvent?.({
@@ -31258,6 +31388,8 @@ class AcpxBridgeTransport {
     let planChain = Promise.resolve();
     let usageError;
     let usageChain = Promise.resolve();
+    let commandsError;
+    let commandsChain = Promise.resolve();
     let toolEventMode = resolveToolEventMode(options);
     if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
       toolEventMode = "text";
@@ -31313,19 +31445,30 @@ class AcpxBridgeTransport {
       if (event.type === "prompt.usage") {
         const onUsage = options?.onUsage;
         if (onUsage) {
-          const usage = { used: event.used, size: event.size };
+          const usage = { used: event.used, size: event.size, ...event.cost ? { cost: event.cost } : {}, ...event.breakdown ? { breakdown: event.breakdown } : {} };
           usageChain = usageChain.then(() => onUsage(usage)).catch((error2) => {
             usageError ??= error2;
           });
         }
         return;
       }
+      if (event.type === "prompt.commands") {
+        const onCommands = options?.onCommands;
+        if (onCommands) {
+          const commands = event.commands;
+          commandsChain = commandsChain.then(() => onCommands(commands)).catch((error2) => {
+            commandsError ??= error2;
+          });
+        }
+        return;
+      }
     });
     await segmentChain;
     await toolEventChain;
     await thoughtChain;
     await planChain;
     await usageChain;
+    await commandsChain;
     if (sink) {
       const { overflowCount } = sink.finalize();
       await sink.drain({ timeoutMs: 30000 });
@@ -31349,6 +31492,9 @@ class AcpxBridgeTransport {
       if (usageError) {
         throw usageError;
       }
+      if (commandsError) {
+        throw commandsError;
+      }
       return { text: summary ? `${summary}
 
 ${result.text}` : "" };
@@ -31368,6 +31514,9 @@ ${result.text}` : "" };
     if (usageError) {
       throw usageError;
     }
+    if (commandsError) {
+      throw commandsError;
+    }
     return result;
   }
   async setMode(session3, modeId) {
@@ -31391,6 +31540,9 @@ ${result.text}` : "" };
   async removeSession(session3) {
     await this.client.request("removeSession", this.toParams(session3));
   }
+  async deleteSession(session3) {
+    await this.client.request("deleteSession", this.toParams(session3));
+  }
   async getAgentSessionId(session3) {
     const result = await this.client.request("getAgentSessionId", this.toParams(session3));
     return result.agentSessionId;
@@ -31574,6 +31726,7 @@ function createStreamingPromptState(formatToolCalls = false, options) {
   let onThought;
   let onPlan;
   let onUsage;
+  let onCommands;
   let rawStream = false;
   if (options === undefined) {
     toolEventMode = "text";
@@ -31586,6 +31739,7 @@ function createStreamingPromptState(formatToolCalls = false, options) {
     onThought = options.onThought;
     onPlan = options.onPlan;
     onUsage = options.onUsage;
+    onCommands = options.onCommands;
     rawStream = options.rawStream ?? false;
     toolEventMode = resolveToolEventMode({
       toolEventMode: options.mode,
@@ -31605,6 +31759,7 @@ function createStreamingPromptState(formatToolCalls = false, options) {
     onThought,
     onPlan,
     onUsage,
+    onCommands,
     finalize() {
       if (this.pendingLine.trim().length > 0) {
         parseStreamingChunks(this, this.pendingLine);
@@ -31672,8 +31827,17 @@ function parseStreamingChunks(state, line) {
   if (update.sessionUpdate === "usage_update") {
     const used = typeof update.used === "number" && Number.isFinite(update.used) ? update.used : undefined;
     const size = typeof update.size === "number" && Number.isFinite(update.size) ? update.size : undefined;
-    if (used !== undefined && size !== undefined && size > 0)
-      state.onUsage?.({ used, size });
+    if (used !== undefined && size !== undefined && size > 0) {
+      const cost = normalizeUsageCost(update.cost);
+      const breakdown = normalizeUsageBreakdown(update._meta?.usage);
+      state.onUsage?.({ used, size, ...cost ? { cost } : {}, ...breakdown ? { breakdown } : {} });
+    }
+    return;
+  }
+  if (update.sessionUpdate === "available_commands_update") {
+    if (Array.isArray(update.availableCommands)) {
+      state.onCommands?.(normalizeAgentCommands(update.availableCommands));
+    }
     return;
   }
   const isThoughtChunk = update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
@@ -31840,6 +32004,52 @@ function readFirstStringArray(record3, keys) {
   }
   return;
 }
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function firstFiniteNumber(record3, keys) {
+  for (const key of keys) {
+    const n = asFiniteNumber(record3[key]);
+    if (n !== undefined)
+      return n;
+  }
+  return;
+}
+function normalizeUsageBreakdown(value) {
+  if (!isRecord3(value))
+    return;
+  const out = {};
+  for (const [key, aliases] of USAGE_BREAKDOWN_FIELDS) {
+    const n = firstFiniteNumber(value, aliases);
+    if (n !== undefined)
+      out[key] = n;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function normalizeUsageCost(value) {
+  if (!isRecord3(value))
+    return;
+  const amount = asFiniteNumber(value.amount);
+  const currency = readString(value, "currency");
+  if (amount === undefined && !currency)
+    return;
+  return { ...amount !== undefined ? { amount } : {}, ...currency ? { currency } : {} };
+}
+function normalizeAgentCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  const out = [];
+  for (const entry of value) {
+    if (!isRecord3(entry))
+      continue;
+    const name = readString(entry, "name");
+    if (!name)
+      continue;
+    const description = readString(entry, "description");
+    out.push({ name, ...description ? { description } : {}, hasInput: entry.input != null });
+  }
+  return out;
+}
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -31865,8 +32075,17 @@ function isGenericToolTitle(kind, title) {
   }
   return false;
 }
+var USAGE_BREAKDOWN_FIELDS;
 var init_streaming_prompt = __esm(() => {
   init_tool_kind_emoji();
+  USAGE_BREAKDOWN_FIELDS = [
+    ["inputTokens", ["inputTokens", "input_tokens"]],
+    ["outputTokens", ["outputTokens", "output_tokens"]],
+    ["cachedReadTokens", ["cachedReadTokens", "cacheReadInputTokens", "cache_read_input_tokens"]],
+    ["cachedWriteTokens", ["cachedWriteTokens", "cacheCreationInputTokens", "cache_creation_input_tokens"]],
+    ["thoughtTokens", ["thoughtTokens", "thought_tokens"]],
+    ["totalTokens", ["totalTokens", "total_tokens"]]
+  ];
 });
 
 // src/transport/acpx-cli/node-pty-helper.ts
@@ -31959,6 +32178,31 @@ var init_agent_session_list = __esm(() => {
   init_path();
 });
 
+// src/transport/acpx-session-files.ts
+import { readdir as readdir3, unlink as unlink2 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { join as join19 } from "node:path";
+async function deleteAcpxSessionFiles(options) {
+  const dir = options.sessionsDir ?? join19(homedir9(), ".acpx", "sessions");
+  const safeId = encodeURIComponent(options.acpxRecordId);
+  await unlink2(join19(dir, `${safeId}.json`)).catch(() => {
+    return;
+  });
+  let entries;
+  try {
+    entries = await readdir3(dir);
+  } catch {
+    return;
+  }
+  const streamFiles = entries.filter((name) => name.startsWith(`${safeId}.stream.`));
+  for (const name of streamFiles) {
+    await unlink2(join19(dir, name)).catch(() => {
+      return;
+    });
+  }
+}
+var init_acpx_session_files = () => {};
+
 // src/transport/acpx-cli/acpx-cli-transport.ts
 import { createRequire as createRequire5 } from "node:module";
 import { spawn as spawn9 } from "node:child_process";
@@ -32217,6 +32461,16 @@ ${baseText}` : "" };
     const detail = normalizeCommandError(result) ?? `command failed with exit code ${result.code}`;
     throw new Error(detail);
   }
+  async deleteSession(session3) {
+    let acpxRecordId;
+    try {
+      ({ acpxRecordId } = await this.readSessionRecord(session3));
+    } catch {
+      return;
+    }
+    await this.removeSession(session3);
+    await deleteAcpxSessionFiles({ acpxRecordId });
+  }
   async hasSession(session3) {
     const result = await this.runCommand(this.command, this.buildArgs(session3, [
       "sessions",
@@ -32253,7 +32507,7 @@ ${baseText}` : "" };
       const parsed = JSON.parse(result.stdout);
       const acpxRecordId = typeof parsed.acpxRecordId === "string" ? parsed.acpxRecordId : typeof parsed.id === "string" ? parsed.id : undefined;
       const agentSessionId = typeof parsed.agentSessionId === "string" ? parsed.agentSessionId : undefined;
-      if (acpxRecordId) {
+      if (acpxRecordId && /^[\w.:-]+$/.test(acpxRecordId) && acpxRecordId.length >= 8) {
         return { acpxRecordId, agentSessionId };
       }
     } catch {
@@ -32532,6 +32786,7 @@ var init_acpx_cli_transport = __esm(() => {
   init_terminate_process_tree();
   init_acpx_queue_owner_launcher();
   init_agent_session_list();
+  init_acpx_session_files();
   require4 = createRequire5(import.meta.url);
 });
 
@@ -33003,8 +33258,8 @@ function createControlEventBus(logger2) {
 
 // src/transport/native-session-history.ts
 import { readFile as readFile14 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { join as join19 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join20 } from "node:path";
 function classifyToolKind(name) {
   const n = name.toLowerCase();
   if (/(^|[^a-z])(read|cat|view|open)([^a-z]|$)/.test(n))
@@ -33116,8 +33371,8 @@ function mapAcpxMessagesToHistory(raw) {
 }
 async function readNativeSessionHistory(opts) {
   try {
-    const dir = opts.sessionsDir ?? join19(opts.homeDir ?? homedir9(), ".acpx", "sessions");
-    const indexRaw = await readFile14(join19(dir, "index.json"), "utf8").catch(() => null);
+    const dir = opts.sessionsDir ?? join20(opts.homeDir ?? homedir10(), ".acpx", "sessions");
+    const indexRaw = await readFile14(join20(dir, "index.json"), "utf8").catch(() => null);
     if (!indexRaw)
       return [];
     const index = JSON.parse(indexRaw);
@@ -33126,7 +33381,7 @@ async function readNativeSessionHistory(opts) {
     for (const entry of candidates) {
       if (!entry.file)
         continue;
-      const recRaw = await readFile14(join19(dir, entry.file), "utf8").catch(() => null);
+      const recRaw = await readFile14(join20(dir, entry.file), "utf8").catch(() => null);
       if (!recRaw)
         continue;
       const record3 = JSON.parse(recRaw);
@@ -33144,14 +33399,14 @@ var init_native_session_history = () => {};
 // src/control/workspace-fs.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { homedir as homedir10 } from "node:os";
-import { readdir as readdir3, realpath, stat as stat3, open as open5 } from "node:fs/promises";
+import { homedir as homedir11 } from "node:os";
+import { readdir as readdir4, realpath, stat as stat3, open as open5 } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
 function expandHome2(p) {
   if (p === "~")
-    return homedir10();
+    return homedir11();
   if (p.startsWith("~/") || p.startsWith("~" + sep))
-    return resolve3(homedir10(), p.slice(2));
+    return resolve3(homedir11(), p.slice(2));
   return p;
 }
 
@@ -33186,7 +33441,7 @@ class WorkspaceFs {
   }
   async listDirectory(workspace3, relPath) {
     const { abs, rel } = await this.resolve(workspace3, relPath);
-    const dirents = await readdir3(abs, { withFileTypes: true });
+    const dirents = await readdir4(abs, { withFileTypes: true });
     const entries = [];
     for (const d of dirents.slice(0, MAX_ENTRIES)) {
       if (d.isDirectory()) {
@@ -33240,7 +33495,7 @@ class WorkspaceFs {
       const dir = queue.shift();
       let dirents;
       try {
-        dirents = await readdir3(dir, { withFileTypes: true });
+        dirents = await readdir4(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -33340,24 +33595,29 @@ var init_workspace_fs = __esm(() => {
 });
 
 // src/control/control-service.ts
+import path15 from "node:path";
+
 class ControlService {
   deps;
   constructor(deps) {
     this.deps = deps;
   }
   workspaceFs = new WorkspaceFs(() => this.deps.workspaces.list().map((w) => ({ name: w.name, cwd: w.cwd })));
-  listDirectory(workspace3, path15) {
-    return this.workspaceFs.listDirectory(workspace3, path15);
+  listDirectory(workspace3, path16) {
+    return this.workspaceFs.listDirectory(workspace3, path16);
   }
-  readWorkspaceFile(workspace3, path15) {
-    return this.workspaceFs.readFile(workspace3, path15);
+  readWorkspaceFile(workspace3, path16) {
+    return this.workspaceFs.readFile(workspace3, path16);
   }
-  workspaceGitDiff(workspace3, path15) {
-    return this.workspaceFs.gitDiff(workspace3, path15);
+  workspaceGitDiff(workspace3, path16) {
+    return this.workspaceFs.gitDiff(workspace3, path16);
   }
   searchWorkspace(workspace3, query) {
     return this.workspaceFs.search(workspace3, query);
   }
+  async uploadFile(input) {
+    return this.deps.uploadStore.save(input.filename, input.content, input.mimeType);
+  }
   async getSessionModel(chatKey, alias) {
     const session3 = await this.resolveControlSession(chatKey, alias);
     if (!session3)
@@ -33389,7 +33649,8 @@ class ControlService {
       agent: session3.agent,
       workspace: session3.workspace,
       transportSession: session3.transportSession,
-      running: this.deps.activeTurns.isActiveAnywhere(session3.alias)
+      running: this.deps.activeTurns.isActiveAnywhere(session3.alias),
+      archived: session3.archived === true
     }));
   }
   async listNativeSessions(_chatKey, agent3, workspace3) {
@@ -33419,15 +33680,26 @@ class ControlService {
       agent: session3.agent,
       workspace: session3.workspace,
       transportSession: session3.transportSession,
-      running: false
+      running: false,
+      archived: false
     };
   }
   async removeSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
-    const result = await this.deps.sessions.removeSession(internalAlias);
+    const result = await this.deps.removeSessionWithTransport(internalAlias);
     this.deps.events.emit({ type: "sessions-changed" });
     return result;
   }
+  async archiveSession(chatKey, alias) {
+    const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
+    await this.deps.archiveSessionWithTransport(internalAlias);
+    this.deps.events.emit({ type: "sessions-changed" });
+  }
+  async unarchiveSession(chatKey, alias) {
+    const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
+    await this.deps.unarchiveSession(internalAlias);
+    this.deps.events.emit({ type: "sessions-changed" });
+  }
   listAgents() {
     return this.deps.agents.list();
   }
@@ -33489,7 +33761,8 @@ class ControlService {
       text: input.text,
       senderId: input.senderId,
       ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
-      ...input.accountId !== undefined ? { accountId: input.accountId } : {}
+      ...input.accountId !== undefined ? { accountId: input.accountId } : {},
+      ...input.media !== undefined ? { media: input.media } : {}
     });
   }
   async runScheduledTurn(input) {
@@ -33561,6 +33834,32 @@ ${chunk}` : chunk
       });
       emittedChunk = true;
     };
+    const incomingMedia = params.media ?? [];
+    const sandboxedMedia = incomingMedia.length ? (() => {
+      const uploadRoot = path15.resolve(this.deps.uploadStore.root);
+      const kept = incomingMedia.filter((ref) => {
+        const resolved = path15.resolve(ref.filePath);
+        return resolved === uploadRoot || resolved.startsWith(uploadRoot + path15.sep);
+      });
+      const dropped = incomingMedia.length - kept.length;
+      if (dropped > 0) {
+        console.warn(`[control] dropped ${dropped} media ref(s) with filePath outside the upload sandbox`);
+      }
+      return kept;
+    })() : incomingMedia;
+    const chatMedia = sandboxedMedia.map((ref) => ({
+      kind: ref.kind,
+      filePath: ref.filePath,
+      mimeType: ref.mimeType,
+      ...ref.fileName ? { fileName: ref.fileName } : {},
+      sizeBytes: ref.size,
+      source: {
+        channelId: "relay",
+        accountId: params.accountId ?? "control",
+        chatKey: params.chatKey,
+        messageId: ref.id
+      }
+    }));
     try {
       const response = await this.deps.agent.chat({
         accountId: params.accountId ?? "control",
@@ -33568,6 +33867,7 @@ ${chunk}` : chunk
         text: params.text,
         metadata: buildControlMetadata(params.senderId, params.isOwner),
         abortSignal: controller.signal,
+        ...chatMedia.length > 0 ? { media: chatMedia } : {},
         reply: async (chunk) => {
           emitChunk(chunk);
         },
@@ -33601,7 +33901,17 @@ ${chunk}` : chunk
             chatKey: params.chatKey,
             sessionAlias: params.sessionAlias,
             used: usage.used,
-            size: usage.size
+            size: usage.size,
+            ...usage.cost ? { cost: usage.cost } : {},
+            ...usage.breakdown ? { breakdown: usage.breakdown } : {}
+          });
+        },
+        onCommands: (commands) => {
+          this.deps.events.emit({
+            type: "agent-commands",
+            chatKey: params.chatKey,
+            sessionAlias: params.sessionAlias,
+            commands
           });
         }
       });
@@ -33690,18 +34000,97 @@ var init_control_service = __esm(() => {
   init_workspace_fs();
 });
 
+// src/control/upload-store.ts
+import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm10, stat as stat4, writeFile as writeFile8 } from "node:fs/promises";
+import { homedir as homedir12 } from "node:os";
+import path16 from "node:path";
+function defaultRootDir() {
+  const home = process.env.HOME ?? homedir12();
+  return path16.join(coreHomeDir(home), "runtime", "uploads");
+}
+function sanitizeUploadFilename(raw) {
+  const base = path16.basename(raw).replace(/[/\\]/g, "").replace(/^\.+/, "");
+  const cleaned = base.trim();
+  return cleaned.length > 0 ? cleaned : "file";
+}
+
+class UploadStore {
+  rootDir;
+  maxBytes;
+  ttlMs;
+  now;
+  constructor(opts = {}) {
+    this.rootDir = opts.rootDir ?? defaultRootDir();
+    this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.now = opts.now ?? (() => new Date);
+  }
+  get root() {
+    return this.rootDir;
+  }
+  async save(filename, base642, mimeType) {
+    if (base642.length > Math.ceil(this.maxBytes * 4 / 3) + 4)
+      throw new Error("file-too-large");
+    const bytes = Buffer.from(base642, "base64");
+    if (bytes.byteLength === 0)
+      throw new Error("empty-file");
+    if (bytes.byteLength > this.maxBytes)
+      throw new Error("file-too-large");
+    const safeName = sanitizeUploadFilename(filename);
+    const { mkdir: mkdir9 } = await import("node:fs/promises");
+    await mkdir9(this.rootDir, { recursive: true });
+    const dir = await mkdtemp2(path16.join(this.rootDir, "u-"));
+    const filePath = path16.join(dir, safeName);
+    await writeFile8(filePath, bytes);
+    return {
+      id: path16.basename(dir),
+      path: filePath,
+      filename: safeName,
+      mimeType,
+      size: bytes.byteLength
+    };
+  }
+  async cleanup() {
+    let entries;
+    try {
+      entries = await readdir5(this.rootDir);
+    } catch {
+      return 0;
+    }
+    const cutoff = this.now().getTime() - this.ttlMs;
+    let removed = 0;
+    for (const name of entries) {
+      const dir = path16.join(this.rootDir, name);
+      try {
+        const info = await stat4(dir);
+        if (info.mtimeMs < cutoff) {
+          await rm10(dir, { recursive: true, force: true });
+          removed += 1;
+        }
+      } catch {}
+    }
+    return removed;
+  }
+}
+var DEFAULT_MAX_BYTES, DEFAULT_TTL_MS;
+var init_upload_store = __esm(() => {
+  init_core_home();
+  DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+  DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+});
+
 // src/config/agent-catalog.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { delimiter as delimiter2, join as join20 } from "node:path";
+import { delimiter as delimiter2, join as join21 } from "node:path";
 function isBinaryOnPath(binary) {
-  const path15 = process.env.PATH ?? "";
+  const path17 = process.env.PATH ?? "";
   const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
-  for (const dir of path15.split(delimiter2)) {
+  for (const dir of path17.split(delimiter2)) {
     if (!dir)
       continue;
     for (const ext of exts) {
       try {
-        if (existsSync3(join20(dir, binary + ext)))
+        if (existsSync3(join21(dir, binary + ext)))
           return true;
       } catch {}
     }
@@ -33741,8 +34130,8 @@ __export(exports_main, {
   buildApp: () => buildApp
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname12, join as join21 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname12, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger2, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
@@ -34233,6 +34622,9 @@ async function buildApp(paths, deps = {}) {
   const router3 = new CommandRouter(sessions, transport, config4, configStore, logger2, undefined, orchestration3, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined, deps.channel?.nativeSessionListFormat ? deps.channel.nativeSessionListFormat.bind(deps.channel) : undefined, activeTurns);
   const agent3 = new ConsoleAgent(router3, logger2);
   const controlEvents = createControlEventBus(logger2);
+  const uploadStore = new UploadStore;
+  uploadStore.cleanup();
+  const uploadCleanupInterval = setInterval(() => void uploadStore.cleanup().catch(() => {}), 60 * 60 * 1000);
   const control = new ControlService({
     agent: agent3,
     sessions,
@@ -34240,6 +34632,9 @@ async function buildApp(paths, deps = {}) {
     createSessionWithTransport: (internalAlias, agent4, workspace3, model) => router3.createSessionWithTransport(internalAlias, agent4, workspace3, model),
     listNativeSessions: (agent4, workspace3) => router3.listNativeSessionsForControl(agent4, workspace3),
     attachNativeSessionWithTransport: (internalAlias, agent4, workspace3, agentSessionId, nativeMeta) => router3.attachNativeSessionWithTransport(internalAlias, agent4, workspace3, agentSessionId, nativeMeta),
+    removeSessionWithTransport: (internalAlias) => router3.removeSessionWithTransport(internalAlias),
+    archiveSessionWithTransport: (internalAlias) => router3.archiveSessionWithTransport(internalAlias),
+    unarchiveSession: (internalAlias) => router3.unarchiveSession(internalAlias),
     activeTurns,
     scheduled: scheduledService,
     orchestration: orchestration3,
@@ -34272,7 +34667,8 @@ async function buildApp(paths, deps = {}) {
         const updated = await configStore.removeWorkspace(name);
         replaceRuntimeConfig(config4, updated);
       }
-    }
+    },
+    uploadStore
   });
   const scheduledScheduler = new ScheduledTaskScheduler(scheduledService, {
     dispatchTask: buildScheduledDispatchTask({
@@ -34342,6 +34738,7 @@ async function buildApp(paths, deps = {}) {
     reapStaleQueueOwners: () => reapWarmQueueOwners("startup"),
     dispose: async () => {
       scheduledScheduler.stop();
+      clearInterval(uploadCleanupInterval);
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
@@ -34402,8 +34799,8 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config4) {
-  const runtimeDir = join21(dirname12(configPath), "runtime");
-  const mediaRootDir = join21(runtimeDir, "media");
+  const runtimeDir = join22(dirname12(configPath), "runtime");
+  const mediaRootDir = join22(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
     console.error("[xacpx] media cleanup failed:", error2 instanceof Error ? error2.message : String(error2));
@@ -34412,16 +34809,16 @@ async function prepareChannelMedia(configPath, config4) {
   return { mediaStore, channelDeps: { mediaStore, allowedMediaRoots } };
 }
 function resolveRuntimePaths() {
-  const home = process.env.HOME ?? homedir11();
+  const home = process.env.HOME ?? homedir13();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
-  const configPath = coreEnv("CONFIG") ?? join21(coreHomeDir(home), "config.json");
-  const runtimeDir = join21(dirname12(configPath), "runtime");
+  const configPath = coreEnv("CONFIG") ?? join22(coreHomeDir(home), "config.json");
+  const runtimeDir = join22(dirname12(configPath), "runtime");
   return {
     configPath,
-    statePath: coreEnv("STATE") ?? join21(coreHomeDir(home), "state.json"),
-    perfLogPath: join21(runtimeDir, "perf.log"),
+    statePath: coreEnv("STATE") ?? join22(coreHomeDir(home), "state.json"),
+    perfLogPath: join22(runtimeDir, "perf.log"),
     orchestrationSocketPath: coreEnv("ORCHESTRATION_SOCKET") ?? resolveDaemonOrchestrationSocketPath(runtimeDir)
   };
 }
@@ -34433,13 +34830,13 @@ function resolveBridgeEntryPath() {
 }
 function resolveAppLogPath(configPath) {
   const rootDir = dirname12(configPath);
-  const runtimeDir = join21(rootDir, "runtime");
-  return join21(runtimeDir, "app.log");
+  const runtimeDir = join22(rootDir, "runtime");
+  return join22(runtimeDir, "app.log");
 }
 function resolvePerfLogPath(configPath) {
   const rootDir = dirname12(configPath);
-  const runtimeDir = join21(rootDir, "runtime");
-  return join21(runtimeDir, "perf.log");
+  const runtimeDir = join22(rootDir, "runtime");
+  return join22(runtimeDir, "perf.log");
 }
 function resolveOrchestrationSocketPathFromConfigPath(configPath) {
   const runtimeDir = resolveRuntimeDirFromConfigPath(configPath);
@@ -34484,6 +34881,7 @@ var init_main = __esm(async () => {
   init_render_text();
   init_quota_manager();
   init_control_service();
+  init_upload_store();
   init_agent_catalog();
   init_perf_tracer();
   init_bootstrap();
@@ -34677,12 +35075,12 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
-import { readdir as readdir4, readFile as readFile15, rm as rm10 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile15, rm as rm11 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { homedir as homedir12 } from "node:os";
-import { join as join22 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join23 } from "node:path";
 async function checkDaemon(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir12();
+  const home = options.home ?? process.env.HOME ?? homedir14();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -34782,7 +35180,7 @@ async function detectStaleConsumerLockFix(runtimeDir, deps) {
     if (!fileName.endsWith(CONSUMER_LOCK_SUFFIX)) {
       continue;
     }
-    const lockPath = join22(runtimeDir, fileName);
+    const lockPath = join23(runtimeDir, fileName);
     const lock2 = await deps.readConsumerLock(lockPath);
     if (lock2 && !deps.isProcessRunning(lock2.pid)) {
       stalePaths.push(lockPath);
@@ -34816,22 +35214,22 @@ async function detectStaleConsumerLockFix(runtimeDir, deps) {
 }
 async function defaultListConsumerLocks(runtimeDir) {
   try {
-    return await readdir4(runtimeDir);
+    return await readdir6(runtimeDir);
   } catch {
     return [];
   }
 }
-async function defaultReadConsumerLock(path15) {
+async function defaultReadConsumerLock(path17) {
   try {
-    const raw = await readFile15(path15, "utf8");
+    const raw = await readFile15(path17, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
   } catch {
     return null;
   }
 }
-async function defaultRemoveConsumerLock(path15) {
-  await rm10(path15, { force: true });
+async function defaultRemoveConsumerLock(path17) {
+  await rm11(path17, { force: true });
 }
 function resolveCliEntryPath() {
   return process.argv[1] ?? fileURLToPath6(import.meta.url);
@@ -34846,11 +35244,11 @@ var init_daemon_check = __esm(() => {
 });
 
 // src/doctor/checks/logs-check.ts
-import { stat as stat4, readdir as readdir5 } from "node:fs/promises";
-import { basename as basename3, join as join23 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { stat as stat5, readdir as readdir7 } from "node:fs/promises";
+import { basename as basename3, join as join24 } from "node:path";
+import { homedir as homedir15 } from "node:os";
 async function checkLogs(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir13();
+  const home = options.home ?? process.env.HOME ?? homedir15();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -34882,13 +35280,13 @@ async function checkLogs(options = {}) {
   const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
   const files = [];
   for (const name of matched) {
-    const path15 = join23(paths.runtimeDir, name);
+    const path17 = join24(paths.runtimeDir, name);
     try {
-      const fileStat = await probe.stat(path15);
+      const fileStat = await probe.stat(path17);
       if (fileStat.isDirectory()) {
         continue;
       }
-      files.push({ name, path: path15, size: fileStat.size });
+      files.push({ name, path: path17, size: fileStat.size });
     } catch {
       continue;
     }
@@ -34962,8 +35360,8 @@ function formatBytes(bytes) {
 }
 function createLogsFsProbe() {
   return {
-    stat: async (path15) => await stat4(path15),
-    readdir: async (path15) => await readdir5(path15)
+    stat: async (path17) => await stat5(path17),
+    readdir: async (path17) => await readdir7(path17)
   };
 }
 function formatError6(error2) {
@@ -35032,9 +35430,9 @@ var init_orchestration_health = __esm(() => {
 });
 
 // src/doctor/checks/orchestration-socket-check.ts
-import { homedir as homedir14 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 async function checkOrchestrationSocket(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir14();
+  const home = options.home ?? process.env.HOME ?? homedir16();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -35207,11 +35605,11 @@ var init_plugin_check = __esm(async () => {
 
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
-import { access as access4, stat as stat5 } from "node:fs/promises";
+import { access as access4, stat as stat6 } from "node:fs/promises";
 import { dirname as dirname13 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { homedir as homedir17 } from "node:os";
 async function checkRuntime(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir15();
+  const home = options.home ?? process.env.HOME ?? homedir17();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -35305,107 +35703,107 @@ function formatMode(mode) {
 }
 function createRuntimeFsProbe() {
   return {
-    stat: async (path15) => await stat5(path15),
-    access: async (path15, mode) => await access4(path15, mode)
+    stat: async (path17) => await stat6(path17),
+    access: async (path17, mode) => await access4(path17, mode)
   };
 }
-async function checkDirectoryCreatable(label, path15, probe, platform) {
+async function checkDirectoryCreatable(label, path17, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path17);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (exists but is not a directory)`
+        detail: `${label}: ${path17} (exists but is not a directory)`
       };
     }
-    await probe.access(path15, directoryAccessMode(platform));
+    await probe.access(path17, directoryAccessMode(platform));
     return {
       ok: true,
-      detail: `${label}: ${path15} (writable)`
+      detail: `${label}: ${path17} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
+        detail: `${label}: ${path17} (unusable: ${formatError9(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(path15, probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(path17, probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path17} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path17} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkFileCreatable(label, path15, probe, platform) {
+async function checkFileCreatable(label, path17, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path17);
     if (stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (exists but is a directory)`
+        detail: `${label}: ${path17} (exists but is a directory)`
       };
     }
-    await probe.access(path15, constants.W_OK);
+    await probe.access(path17, constants.W_OK);
     return {
       ok: true,
-      detail: `${label}: ${path15} (writable)`
+      detail: `${label}: ${path17} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
+        detail: `${label}: ${path17} (unusable: ${formatError9(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname13(path15), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname13(path17), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path17} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path17} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkCreatableAncestorDirectory(path15, probe, platform) {
+async function checkCreatableAncestorDirectory(path17, probe, platform) {
   try {
-    const stats = await probe.stat(path15);
+    const stats = await probe.stat(path17);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path17,
+        blockingPath: path17
       };
     }
-    await probe.access(path15, directoryAccessMode(platform));
+    await probe.access(path17, directoryAccessMode(platform));
     return {
       ok: true,
-      creatableFrom: path15
+      creatableFrom: path17
     };
   } catch (error2) {
     if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path17,
+        blockingPath: path17
       };
     }
-    const parent = dirname13(path15);
-    if (parent === path15) {
+    const parent = dirname13(path17);
+    if (parent === path17) {
       return {
         ok: false,
-        creatableFrom: path15,
-        blockingPath: path15
+        creatableFrom: path17,
+        blockingPath: path17
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(parent, probe, platform);
@@ -35844,10 +36242,10 @@ var init_render_doctor = __esm(() => {
 });
 
 // src/doctor/doctor.ts
-import { homedir as homedir16 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { join as join25 } from "node:path";
 async function runDoctor(options = {}, deps = {}) {
-  const home = deps.home ?? process.env.HOME ?? homedir16();
+  const home = deps.home ?? process.env.HOME ?? homedir18();
   const runtimePaths = resolveDoctorRuntimePaths(home, deps.resolveRuntimePaths);
   const sharedLoadConfig = createSharedLoadConfig(runtimePaths, deps.loadConfig ?? loadConfig);
   const runners = [
@@ -36000,8 +36398,8 @@ function resolveDoctorRuntimePaths(home, resolver) {
     return resolveRuntimePaths();
   }
   return {
-    configPath: join24(coreHomeDir(home), "config.json"),
-    statePath: join24(coreHomeDir(home), "state.json")
+    configPath: join25(coreHomeDir(home), "config.json"),
+    statePath: join25(coreHomeDir(home), "state.json")
   };
 }
 function depsUseExplicitRuntimeOverrides() {
@@ -36184,8 +36582,8 @@ var init_doctor2 = __esm(async () => {
 // src/cli.ts
 init_core_home();
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname14, join as join25, sep as sep2 } from "node:path";
+import { homedir as homedir19 } from "node:os";
+import { dirname as dirname14, join as join26, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -52439,7 +52837,7 @@ async function createCliScheduledTaskService() {
   return new ScheduledTaskService(state, stateStore);
 }
 function resolveConfigPathForCurrentEnv() {
-  return coreEnv("CONFIG") ?? join25(coreHomeDir(requireHome2()), "config.json");
+  return coreEnv("CONFIG") ?? join26(coreHomeDir(requireHome2()), "config.json");
 }
 function resolveDaemonPathsForCurrentConfig() {
   const configPath = resolveConfigPathForCurrentEnv();
@@ -52790,7 +53188,7 @@ function decodeFirstRunOnboarding(raw) {
   return null;
 }
 function requireHome2() {
-  const home = process.env.HOME ?? homedir17();
+  const home = process.env.HOME ?? homedir19();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -52814,7 +53212,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join25(dirname14(configPath), "runtime", "app.log"),
+      appLog: join26(dirname14(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {