@hydra-acp/cli 0.1.45 → 0.1.46

package/dist/cli.js

@@ -271,7 +271,7 @@ var init_config = __esm({
       // Compaction trims to this many on a periodic basis; reads also slice
       // to the tail at this length as a defensive measure against older
       // daemons that may have written unbounded files.
-      sessionHistoryMaxEntries: z.number().int().positive().default(1e3),
+      sessionHistoryMaxEntries: z.number().int().positive().default(1e4),
       // Bytes of trailing agent stderr buffered per AgentInstance so the
       // daemon can include it in the diagnostic message when a spawn fails.
       // Bump if your agents emit large tracebacks you want surfaced.
@@ -331,7 +331,13 @@ var init_config = __esm({
       // streaming lines beneath the live thinking block. Set false to
       // suppress them — the TUI hotkey ^T toggles this at runtime without
       // persisting back to config.
-      showThoughts: z.boolean().default(true)
+      showThoughts: z.boolean().default(true),
+      // Cap on entries kept in the cross-session global prompt-history file
+      // (~/.hydra-acp/prompt-history). This is the ^P / ^R recall list
+      // shared across all sessions; it's append-only on disk, so long-lived
+      // installs can grow past this — it's enforced at load time and per
+      // append in memory.
+      promptHistoryMaxEntries: z.number().int().positive().default(2e3)
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -385,7 +391,8 @@ var init_config = __esm({
         cwdColumnMaxWidth: 24,
         progressIndicator: true,
         defaultEnterAction: "amend",
-        showThoughts: true
+        showThoughts: true,
+        promptHistoryMaxEntries: 2e3
       })
     });
   }
@@ -1826,6 +1833,11 @@ var init_hydra_commands = __esm({
         verb: "kill",
         name: "hydra kill",
         description: "Close this session (kills the agent; record is kept so it can be resumed later)"
+      },
+      {
+        verb: "restart",
+        name: "hydra restart",
+        description: "Restart the agent with a fresh session/new while preserving conversation history (useful when the proxy has changed available models)"
       }
     ];
     VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
@@ -2182,7 +2194,9 @@ var init_session = __esm({
       // stale-prone for snapshot-shaped events).
       currentModel;
       currentMode;
-      currentUsage;
+      // Raw per-agent-life usage. Never read directly outside this class —
+      // always access via the currentUsage getter which adds cumulativeCost.
+      _currentUsage;
       updatedAt;
       createdAt;
       clients = /* @__PURE__ */ new Map();
@@ -2248,6 +2262,7 @@ var init_session = __esm({
       // and noisy state churn keep a quiet session alive forever.
       lastRecordedAt;
       spawnReplacementAgent;
+      listSessions;
       logger;
       transformChain;
       // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
@@ -2279,6 +2294,23 @@ var init_session = __esm({
       modeHandlers = [];
       usageHandlers = [];
       cumulativeCost = 0;
+      // Total cost across all agent lives. costAmount in the returned snapshot
+      // is cumulativeCost + the current agent's raw amount so every consumer
+      // gets the right figure without knowing about the internal split.
+      // cumulativeCost is stripped from the return value so it never leaks
+      // into persistence paths via session.currentUsage.
+      get currentUsage() {
+        if (!this._currentUsage && !this.cumulativeCost) {
+          return void 0;
+        }
+        const base = this._currentUsage ?? {};
+        const total = this.cumulativeCost + (base.costAmount ?? 0);
+        return {
+          ...base,
+          costAmount: total || void 0,
+          cumulativeCost: void 0
+        };
+      }
       // Set by amendPrompt at the start of a cancel-and-resubmit dance.
       // broadcastTurnComplete reads it to attach the _meta.amended marker
       // to the cancelled turn's turn_complete notification, and to fire the
@@ -2311,7 +2343,7 @@ var init_session = __esm({
         this.title = init.title;
         this.currentModel = init.currentModel;
         this.currentMode = init.currentMode;
-        this.currentUsage = init.currentUsage;
+        this._currentUsage = init.currentUsage;
         this.cumulativeCost = init.currentUsage?.cumulativeCost ?? 0;
         if (init.agentCommands && init.agentCommands.length > 0) {
           this.agentAdvertisedCommands = [...init.agentCommands];
@@ -2325,6 +2357,7 @@ var init_session = __esm({
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.idleEventTimeoutMs = init.idleEventTimeoutMs ?? 3e4;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
+        this.listSessions = init.listSessions;
         this.logger = init.logger;
         this.transformChain = init.transformChain ?? [];
         if (init.firstPromptSeeded) {
@@ -2343,6 +2376,9 @@ var init_session = __esm({
       broadcastMergedCommands() {
         const merged = [
           ...hydraCommandsAsAdvertised(),
+          { name: "model <model-id>", description: "Switch model; omit arg to list available models" },
+          { name: "sessions", description: "List all sessions" },
+          { name: "help", description: "Show available commands" },
           ...this.agentAdvertisedCommands
         ];
         this.recordAndBroadcast("session/update", {
@@ -2407,7 +2443,8 @@ var init_session = __esm({
       // then recordAndBroadcast. All state mutation happens after the chain exits.
       // See forwardRequest for originatedBy / startIdx semantics.
       async runResponseChain(params, originatedBy = /* @__PURE__ */ new Set(), startIdx = 0) {
-        let envelope = params;
+        const rawParams = params;
+        let envelope = this.injectCumulativeCost(params);
         for (let i = startIdx; i < this.transformChain.length; i++) {
           const t = this.transformChain[i];
           if (originatedBy.has(t.name)) {
@@ -2495,8 +2532,8 @@ var init_session = __esm({
           this.recordAndBroadcast("session/update", envelope);
           return;
         }
-        if (this.maybeApplyAgentUsage(envelope)) {
-          this.recordAndBroadcast("session/update", this.injectCumulativeCost(envelope));
+        if (this.maybeApplyAgentUsage(rawParams)) {
+          this.recordAndBroadcast("session/update", envelope);
           return;
         }
         this.maybeApplyAgentSessionInfo(envelope);
@@ -2689,8 +2726,8 @@ var init_session = __esm({
             recordedAt
           });
         }
-        if (this.currentUsage !== void 0 || this.cumulativeCost > 0) {
-          const u = this.currentUsage ?? {};
+        if (this.currentUsage !== void 0) {
+          const u = this.currentUsage;
           const update = {
             sessionUpdate: "usage_update"
           };
@@ -2702,8 +2739,8 @@ var init_session = __esm({
           }
           if (typeof u.costAmount === "number" || typeof u.costCurrency === "string") {
             const cost = {};
-            if (typeof u.costAmount === "number" || this.cumulativeCost) {
-              cost.amount = this.cumulativeCost + (u.costAmount ?? 0);
+            if (typeof u.costAmount === "number") {
+              cost.amount = u.costAmount;
             }
             if (typeof u.costCurrency === "string") {
               cost.currency = u.costCurrency;
@@ -3242,6 +3279,23 @@ var init_session = __esm({
           sessionId: this.upstreamSessionId
         });
       }
+      // Add a transformer to this session's chain retroactively. No-ops if it's
+      // already present. Fires session.opened on the new transformer so it gets
+      // the same lifecycle signal it would have received at session creation.
+      addTransformer(ref) {
+        const existing = this.transformChain.findIndex((t) => t.name === ref.name);
+        if (existing >= 0) {
+          this.transformChain[existing] = ref;
+        } else {
+          this.transformChain.push(ref);
+        }
+        if (ref.intercepts.has("lifecycle:session.opened")) {
+          void ref.connection.notify("transformer/session_event", {
+            event: "session.opened",
+            sessionId: this.sessionId
+          }).catch(() => void 0);
+        }
+      }
       // Walk the request-side chain then forward to the agent.
       // originatedBy: transformer names already in the lineage — skipped for loop
       //   prevention and to implement resume-routing on re-entry from emit_message.
@@ -3566,6 +3620,9 @@ var init_session = __esm({
         if (!trimmed || trimmed === this.currentMode) {
           return true;
         }
+        this.logger?.info(
+          `current_mode_update: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+        );
         this.currentMode = trimmed;
         for (const handler of this.modeHandlers) {
           try {
@@ -3585,7 +3642,7 @@ var init_session = __esm({
         if (update.sessionUpdate !== "usage_update") {
           return false;
         }
-        const next = { ...this.currentUsage ?? {} };
+        const next = { ...this._currentUsage ?? {} };
         let changed = false;
         if (typeof update.used === "number" && next.used !== update.used) {
           next.used = update.used;
@@ -3609,10 +3666,11 @@ var init_session = __esm({
         if (!changed) {
           return true;
         }
-        this.currentUsage = next;
+        this._currentUsage = next;
+        const total = this.currentUsage ?? next;
         for (const handler of this.usageHandlers) {
           try {
-            handler(next);
+            handler(total);
           } catch {
           }
         }
@@ -3622,16 +3680,16 @@ var init_session = __esm({
       // next agent life starts accumulating from $0. Fires usageHandlers so
       // meta.json is updated before the new agent starts emitting.
       accumulateAndResetCost() {
-        const amount = this.currentUsage?.costAmount;
+        const amount = this._currentUsage?.costAmount;
         if (!amount)
           return;
         this.cumulativeCost += amount;
         const next = {
-          ...this.currentUsage ?? {},
+          ...this._currentUsage ?? {},
           cumulativeCost: this.cumulativeCost,
           costAmount: void 0
         };
-        this.currentUsage = next;
+        this._currentUsage = next;
         for (const handler of this.usageHandlers) {
           try {
             handler(next);
@@ -3666,16 +3724,9 @@ var init_session = __esm({
           }
         };
       }
-      // Total cost across all agent lives for this hydra session. Used by
-      // session/list so list rows show the accumulated figure.
+      // Deprecated alias — currentUsage already returns the total.
       get totalUsage() {
-        if (!this.currentUsage && !this.cumulativeCost)
-          return void 0;
-        const base = this.currentUsage ?? {};
-        return {
-          ...base,
-          costAmount: this.cumulativeCost + (this.currentUsage?.costAmount ?? 0)
-        };
+        return this.currentUsage;
       }
       // Update the cached agent command list, fire persist handlers, and
       // broadcast the merged list to attached clients. Idempotent on a
@@ -3741,6 +3792,26 @@ var init_session = __esm({
       onModeChange(handler) {
         this.modeHandlers.push(handler);
       }
+      // Apply a mode change initiated by a client request (session/set_mode)
+      // when the agent doesn't emit a current_mode_update notification on its
+      // own. Fires modeHandlers so the persistence hook and any other listeners
+      // see the change, identical to the agent-notification path.
+      applyModeChange(modeId) {
+        const trimmed = modeId.trim();
+        if (!trimmed || trimmed === this.currentMode) {
+          return;
+        }
+        this.logger?.info(
+          `applyModeChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+        );
+        this.currentMode = trimmed;
+        for (const handler of this.modeHandlers) {
+          try {
+            handler(trimmed);
+          } catch {
+          }
+        }
+      }
       onUsageChange(handler) {
         this.usageHandlers.push(handler);
       }
@@ -3823,6 +3894,8 @@ var init_session = __esm({
             return this.runAgentCommand(arg);
           case "kill":
             return this.runKillCommand();
+          case "restart":
+            return this.runRestartCommand();
           default: {
             const err = new Error(
               `no dispatcher for /hydra verb ${verb}`
@@ -3832,6 +3905,92 @@ var init_session = __esm({
           }
         }
       }
+      async handleSessionsCommand() {
+        let text;
+        if (!this.listSessions) {
+          text = "_(session listing not available)_";
+        } else {
+          const sessions = await this.listSessions();
+          if (sessions.length === 0) {
+            text = "_(no sessions)_";
+          } else {
+            const lines = sessions.map((s) => {
+              const id = s.sessionId.replace(/^hydra_session_/, "").slice(0, 12);
+              const model = s.currentModel ? ` \xB7 ${s.currentModel}` : "";
+              const marker = s.sessionId === this.sessionId ? " \u25C0" : "";
+              const title = s.title ? `  ${s.title}` : "";
+              return `\`${id}\`  ${s.cwd}${model}${marker}${title}`;
+            });
+            text = `Sessions (${sessions.length}):
+${lines.join("\n")}`;
+          }
+        }
+        this.recordAndBroadcast("session/update", {
+          sessionId: this.upstreamSessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `
+${text}
+` },
+            _meta: { "hydra-acp": { synthetic: true } }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      handleHelpCommand() {
+        const commands = this.mergedAvailableCommands();
+        const lines = commands.map((c) => {
+          const desc = c.description ? `  ${c.description}` : "";
+          return `\`/${c.name}\`${desc}`;
+        });
+        const text = lines.length > 0 ? `Available commands:
+${lines.join("\n")}` : "_(no commands advertised)_";
+        this.recordAndBroadcast("session/update", {
+          sessionId: this.upstreamSessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `
+${text}
+` },
+            _meta: { "hydra-acp": { synthetic: true } }
+          }
+        });
+        return Promise.resolve({ stopReason: "end_turn" });
+      }
+      async handleModelCommand(text) {
+        const arg = text.slice("/model".length).trim();
+        if (arg === "") {
+          const models = this.agentAdvertisedModels;
+          const current = this.currentModel;
+          let body;
+          if (models.length === 0) {
+            body = current ? `Current model: ${current}` : "_(no models advertised yet)_";
+          } else {
+            const lines = models.map((m) => {
+              const marker = m.modelId === current ? " \u25C0" : "";
+              const desc = m.name && m.name !== m.modelId ? `  ${m.name}` : "";
+              return `${m.modelId}${marker}${desc}`;
+            });
+            body = lines.join("\n");
+          }
+          this.recordAndBroadcast("session/update", {
+            sessionId: this.upstreamSessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: `
+${body}
+` },
+              _meta: { "hydra-acp": { synthetic: true } }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        await this.forwardRequest("session/set_model", {
+          sessionId: this.sessionId,
+          modelId: arg
+        });
+        return { stopReason: "end_turn" };
+      }
       // Runs as a normal queued prompt (so it serializes after any in-flight
       // turn). With an arg, sets the title directly. Without one, runs a
       // suppressed sub-prompt to the agent and uses its reply as the title.
@@ -3953,6 +4112,57 @@ var init_session = __esm({
         await this.close({ deleteRecord: false });
         return { stopReason: "end_turn" };
       }
+      // Restart the underlying agent with a fresh session/new, preserving the
+      // conversation history. Unlike /hydra agent, this allows the same agentId
+      // — useful when the proxy has changed available models (e.g. opus became
+      // available after a quota reset) and the resumed session is locked to a
+      // stale model list.
+      runRestartCommand() {
+        if (!this.spawnReplacementAgent) {
+          throw withCode(
+            new Error("agent restart not configured for this session"),
+            JsonRpcErrorCodes.InternalError
+          );
+        }
+        const spawnAgent = this.spawnReplacementAgent;
+        const agentId = this.agentId;
+        return this.enqueuePrompt(async () => {
+          const transcript = await this.buildSwitchTranscript(agentId);
+          const fresh = await spawnAgent({
+            agentId,
+            cwd: this.cwd,
+            agentArgs: this.agentArgs
+          });
+          this.accumulateAndResetCost();
+          this.wireAgent(fresh.agent);
+          const oldAgent = this.agent;
+          this.agent = fresh.agent;
+          this.upstreamSessionId = fresh.upstreamSessionId;
+          this.agentMeta = fresh.agentMeta;
+          this.agentCapabilities = fresh.agentCapabilities;
+          this.agentAdvertisedCommands = [];
+          this.broadcastMergedCommands();
+          if (this.agentAdvertisedModels.length > 0) {
+            this.setAgentAdvertisedModels([]);
+          }
+          if (this.agentAdvertisedModes.length > 0) {
+            this.setAgentAdvertisedModes([]);
+          }
+          await oldAgent.kill().catch(() => void 0);
+          if (transcript) {
+            await this.runInternalPrompt(transcript).catch(() => void 0);
+          }
+          this.broadcastAgentSwitch(agentId, agentId);
+          const info = { agentId, upstreamSessionId: this.upstreamSessionId };
+          for (const handler of this.agentChangeHandlers) {
+            try {
+              handler(info);
+            } catch {
+            }
+          }
+          return { stopReason: "end_turn" };
+        });
+      }
       // Walk the persisted history and produce a labeled transcript suitable
       // for handing to a fresh agent. Includes user prompts, agent replies,
       // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop
@@ -4569,6 +4779,22 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           return entry.task();
         }
         this.broadcastPromptReceived(entry);
+        const promptText = extractPromptText(entry.prompt).trim();
+        if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/sessions" || promptText === "/help") {
+          let result;
+          if (promptText === "/sessions") {
+            result = await this.handleSessionsCommand();
+          } else if (promptText === "/help") {
+            result = await this.handleHelpCommand();
+          } else {
+            result = await this.handleModelCommand(promptText);
+          }
+          if (!this.closed) {
+            this.broadcastTurnComplete(entry.clientId, result, entry.messageId, entry.wasAmend);
+          }
+          this.clearAmendIfMatches(entry.messageId);
+          return result;
+        }
         let response;
         try {
           response = await this.agent.connection.request(
@@ -4690,12 +4916,11 @@ function buildCombinedHistory(global, session) {
   const filteredGlobal = global.filter((e) => !sessionSet.has(e));
   return [...filteredGlobal, ...session];
 }
-var HISTORY_CAP, GLOBAL_HISTORY_CAP;
+var HISTORY_CAP;
 var init_history = __esm({
   "src/tui/history.ts"() {
     "use strict";
     HISTORY_CAP = 500;
-    GLOBAL_HISTORY_CAP = 2e3;
   }
 });
 
@@ -5083,7 +5308,15 @@ function mapModel(u) {
   if (!model) {
     return null;
   }
-  return { kind: "model-changed", model: sanitizeSingleLine(model) };
+  const raw = u.availableModels;
+  const availableModels = Array.isArray(raw) ? raw.map(
+    (m) => typeof m === "object" && m !== null ? m.modelId : typeof m === "string" ? m : void 0
+  ).filter((id) => typeof id === "string" && id.length > 0) : void 0;
+  return {
+    kind: "model-changed",
+    model: sanitizeSingleLine(model),
+    ...availableModels && availableModels.length > 0 ? { availableModels } : {}
+  };
 }
 function mapTurnComplete(u) {
   const stopReason = readString(u, "stopReason");
@@ -11681,6 +11914,16 @@ function parseReattachResponse(result) {
   if (typeof r.clientId === "string" && r.clientId.length > 0) {
     out.clientId = r.clientId;
   }
+  const meta = r._meta;
+  if (meta && typeof meta === "object") {
+    const hydra = meta["hydra-acp"];
+    if (hydra && typeof hydra === "object") {
+      const ts = hydra.turnStartedAt;
+      if (typeof ts === "number") {
+        out.turnStartedAt = ts;
+      }
+    }
+  }
   return out;
 }
 var init_reconnect_state = __esm({
@@ -12767,8 +13010,8 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
   const globalHistoryFile = paths.globalTuiHistoryFile();
   let history = await loadHistory(historyFile).catch(() => []);
   let globalHistory = await loadHistory(globalHistoryFile).catch(() => []);
-  if (globalHistory.length > GLOBAL_HISTORY_CAP) {
-    globalHistory = globalHistory.slice(globalHistory.length - GLOBAL_HISTORY_CAP);
+  if (globalHistory.length > config.tui.promptHistoryMaxEntries) {
+    globalHistory = globalHistory.slice(globalHistory.length - config.tui.promptHistoryMaxEntries);
   }
   const dispatcher = new InputDispatcher({
     history: buildCombinedHistory(globalHistory, history)
@@ -12782,7 +13025,7 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     const nextSession = appendEntry(history, trimmed);
     const sessionChanged = nextSession !== history;
     history = nextSession;
-    const nextGlobal = appendEntry(globalHistory, trimmed, GLOBAL_HISTORY_CAP);
+    const nextGlobal = appendEntry(globalHistory, trimmed, config.tui.promptHistoryMaxEntries);
     const globalChanged = nextGlobal !== globalHistory;
     globalHistory = nextGlobal;
     dispatcher.setHistory(buildCombinedHistory(globalHistory, history));
@@ -13754,40 +13997,6 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
           }
         ]);
         return true;
-      case "/model": {
-        const arg = space === -1 ? "" : trimmed.slice(space + 1).trim();
-        if (arg === "") {
-          screen.appendLines([
-            {
-              prefix: "  ",
-              body: "Usage: /model <model-id>",
-              bodyStyle: "info"
-            }
-          ]);
-          return true;
-        }
-        conn.request("session/set_model", {
-          sessionId: resolvedSessionId,
-          modelId: arg
-        }).then(() => {
-          screen.appendLines([
-            {
-              prefix: "  ",
-              body: `model set to ${arg}`,
-              bodyStyle: "system"
-            }
-          ]);
-        }).catch((err) => {
-          screen.appendLines([
-            {
-              prefix: "  ",
-              body: `set_model failed: ${err.message}`,
-              bodyStyle: "tool-status-fail"
-            }
-          ]);
-        });
-        return true;
-      }
       default:
         return false;
     }
@@ -14279,12 +14488,13 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
     reconnectReplayBuffer = [];
     let appliedPolicy;
     let attachErr;
+    let fields;
     try {
       const resp = await stream.request(attachReq);
       if (resp.error) {
         throw new Error(resp.error.message);
       }
-      const fields = parseReattachResponse(resp.result);
+      fields = parseReattachResponse(resp.result);
       appliedPolicy = fields.appliedPolicy;
       if (fields.clientId !== void 0) {
         ownClientId = fields.clientId;
@@ -14318,6 +14528,9 @@ async function runSession(term, config, target, opts, exitHint, viewPrefs) {
         handleSessionUpdate(params);
       }
     }
+    if (fields && fields.turnStartedAt === void 0 && pendingTurns > 0) {
+      adjustPendingTurns(-pendingTurns);
+    }
     screen.setBanner({
       status: pendingTurns > 0 ? "busy" : "ready",
       elapsedMs: pendingTurns > 0 ? 0 : void 0
@@ -16234,6 +16447,7 @@ var SessionManager = class {
       idleEventTimeoutMs: this.idleEventTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel,
@@ -16335,6 +16549,22 @@ var SessionManager = class {
     } else {
       agent.connection.drainBuffered("session/update");
     }
+    const agentReportedMode = extractInitialCurrentMode(loadResult ?? {});
+    const advertisedModes = params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {}));
+    this.logger?.info(
+      `resurrect: sessionId=${params.hydraSessionId} persistedMode=${JSON.stringify(params.currentMode)} agentReportedMode=${JSON.stringify(agentReportedMode)} advertisedModes=${JSON.stringify(advertisedModes?.map((m) => m.id))}`
+    );
+    const effectiveMode = await restoreCurrentMode({
+      agent,
+      upstreamSessionId: params.upstreamSessionId,
+      persistedMode: params.currentMode,
+      agentReportedMode,
+      advertisedModes,
+      logger: this.logger
+    });
+    this.logger?.info(
+      `resurrect: effectiveMode=${JSON.stringify(effectiveMode)} for sessionId=${params.hydraSessionId}`
+    );
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd: params.cwd,
@@ -16348,6 +16578,7 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer what we previously stored from a current_model_update; if
@@ -16355,11 +16586,15 @@ var SessionManager = class {
       // this fix), fall back to the model the agent ships in its
       // session/load response body.
       currentModel: params.currentModel ?? extractInitialModel(loadResult ?? {}),
-      currentMode: params.currentMode ?? extractInitialCurrentMode(loadResult ?? {}),
+      currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
-      agentModes: params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {})),
-      agentModels: params.agentModels ?? nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})),
+      agentModes: advertisedModes,
+      // Always prefer the fresh list from session/load over the persisted
+      // snapshot — the proxy's available models can change between daemon
+      // restarts (quota resets, rollouts), so meta.json is intentionally
+      // treated as a cold fallback here, not the authoritative source.
+      agentModels: nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})) ?? params.agentModels,
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
@@ -16386,6 +16621,15 @@ var SessionManager = class {
       mcpServers: [],
       onInstallProgress: params.onInstallProgress
     });
+    const advertisedModes = params.agentModes ?? fresh.initialModes;
+    const effectiveMode = await restoreCurrentMode({
+      agent: fresh.agent,
+      upstreamSessionId: fresh.upstreamSessionId,
+      persistedMode: params.currentMode,
+      agentReportedMode: fresh.initialMode,
+      advertisedModes,
+      logger: this.logger
+    });
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd,
@@ -16399,15 +16643,16 @@ var SessionManager = class {
       idleTimeoutMs: this.idleTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer the stored value (set by a previous current_model_update);
       // fall back to whatever the agent ships in its session/new response.
       currentModel: params.currentModel ?? fresh.initialModel,
-      currentMode: params.currentMode ?? fresh.initialMode,
+      currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
-      agentModes: params.agentModes ?? fresh.initialModes,
+      agentModes: advertisedModes,
       agentModels: params.agentModels ?? fresh.initialModels,
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
@@ -16609,13 +16854,15 @@ var SessionManager = class {
               modelId: desired
             });
             initialModel = desired;
-          } catch {
+          } catch (err) {
+            this.logger?.warn(
+              `defaultModels[${params.agentId}]=${JSON.stringify(desired)} rejected by agent (${err.message}); session will use ${JSON.stringify(initialModel)}`
+            );
           }
         } else {
           const known = initialModels.map((m) => m.modelId).join(", ");
-          process.stderr.write(
-            `hydra-acp: defaultModels[${params.agentId}]=${JSON.stringify(desired)} is not in the agent's availableModels (${known}); skipping session/set_model
-`
+          this.logger?.warn(
+            `defaultModels[${params.agentId}]=${JSON.stringify(desired)} not in agent's availableModels ([${known}]); skipping session/set_model, session will use ${JSON.stringify(initialModel)}`
           );
         }
       }
@@ -16792,6 +17039,9 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  liveSessions() {
+    return this.sessions.values();
+  }
   // Snapshot of which agent versions are currently in use by live
   // sessions, keyed by agentId. Read by the registry-fetch prune sweep
   // so it can skip install dirs that still back a running process.
@@ -16853,7 +17103,7 @@ var SessionManager = class {
         title: session.title,
         agentId: session.agentId,
         currentModel: session.currentModel,
-        currentUsage: session.totalUsage,
+        currentUsage: session.currentUsage,
         parentSessionId: session.parentSessionId,
         updatedAt: used,
         attachedClients: session.attachedCount,
@@ -17005,6 +17255,7 @@ var SessionManager = class {
         currentMode: args.bundle.session.currentMode,
         currentUsage: args.bundle.session.currentUsage,
         agentCommands: args.bundle.session.agentCommands,
+        agentModes: args.bundle.session.agentModes,
         createdAt: args.preservedCreatedAt ?? now,
         // Fallback path for historyMtimeIso (used when the history file
         // is missing). Keep this consistent with the utimes stamp above.
@@ -17394,6 +17645,47 @@ function extractInitialCurrentMode(result) {
   }
   return void 0;
 }
+async function restoreCurrentMode(opts) {
+  const {
+    agent,
+    upstreamSessionId,
+    persistedMode,
+    agentReportedMode,
+    advertisedModes,
+    logger
+  } = opts;
+  if (!persistedMode) {
+    return agentReportedMode;
+  }
+  if (persistedMode === agentReportedMode) {
+    return persistedMode;
+  }
+  if (advertisedModes && advertisedModes.length > 0 && !advertisedModes.some((m) => m.id === persistedMode)) {
+    const known = advertisedModes.map((m) => m.id).join(", ");
+    logger?.warn(
+      `resurrect: persisted currentMode=${JSON.stringify(persistedMode)} not in agent's availableModes ([${known}]); skipping session/set_mode, session will use ${JSON.stringify(agentReportedMode)}`
+    );
+    return agentReportedMode;
+  }
+  try {
+    logger?.info(
+      `resurrect: pushing persisted modeId=${JSON.stringify(persistedMode)} to agent (agentReported=${JSON.stringify(agentReportedMode)})`
+    );
+    await agent.connection.request("session/set_mode", {
+      sessionId: upstreamSessionId,
+      modeId: persistedMode
+    });
+    logger?.info(
+      `resurrect: session/set_mode accepted, effectiveMode=${JSON.stringify(persistedMode)}`
+    );
+    return persistedMode;
+  } catch (err) {
+    logger?.warn(
+      `resurrect: session/set_mode rejected by agent for modeId=${JSON.stringify(persistedMode)} (${err.message}); session will use ${JSON.stringify(agentReportedMode)}`
+    );
+    return agentReportedMode;
+  }
+}
 function parseModesList(list) {
   if (!Array.isArray(list)) {
     return [];
@@ -19927,6 +20219,14 @@ function registerAcpWsEndpoint(app, deps) {
             connection,
             intercepts
           );
+          if (deps.manager?.defaultTransformers.includes(processIdentity.name)) {
+            const ref = deps.transformers.resolveChain([processIdentity.name])[0];
+            if (ref) {
+              for (const session of deps.manager.liveSessions()) {
+                session.addTransformer(ref);
+              }
+            }
+          }
         }
         return { ack: true };
       });
@@ -20142,16 +20442,13 @@ function registerAcpWsEndpoint(app, deps) {
         let resurrectParams = fromDisk;
         if (hydraHints) {
           resurrectParams = {
+            ...fromDisk,
             hydraSessionId: params.sessionId,
             upstreamSessionId: hydraHints.upstreamSessionId,
             agentId: hydraHints.agentId,
             cwd: hydraHints.cwd,
-            title: hydraHints.title ?? fromDisk?.title,
-            agentArgs: hydraHints.agentArgs ?? fromDisk?.agentArgs,
-            currentModel: fromDisk?.currentModel,
-            currentMode: fromDisk?.currentMode,
-            agentCommands: fromDisk?.agentCommands,
-            createdAt: fromDisk?.createdAt
+            ...hydraHints.title !== void 0 ? { title: hydraHints.title } : {},
+            ...hydraHints.agentArgs !== void 0 ? { agentArgs: hydraHints.agentArgs } : {}
           };
         }
         if (!resurrectParams) {
@@ -20165,6 +20462,7 @@ function registerAcpWsEndpoint(app, deps) {
           ...resurrectParams,
           onInstallProgress: makeInstallProgressForwarder(connection)
         });
+        wireDefaultTransformers(session, deps);
       }
       const client = bindClientToSession(
         connection,
@@ -20254,6 +20552,7 @@ function registerAcpWsEndpoint(app, deps) {
           `session/prompt auto-resurrecting cold sessionId=${params.sessionId}`
         );
         session = await deps.manager.resurrect(fromDisk);
+        wireDefaultTransformers(session, deps);
         const client = bindClientToSession(
           connection,
           session,
@@ -20406,6 +20705,7 @@ function registerAcpWsEndpoint(app, deps) {
           throw err;
         }
         session = await deps.manager.resurrect(fromDisk);
+        wireDefaultTransformers(session, deps);
       }
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "pending_only");
@@ -20456,6 +20756,32 @@ function registerAcpWsEndpoint(app, deps) {
       app.log.info(decision.logMessage);
       return decision.session.forwardRequest("session/set_model", rawParams);
     });
+    connection.onRequest("session/set_mode", async (rawParams) => {
+      const params = rawParams;
+      const sessionIdField = params?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_mode");
+      }
+      if (!params || typeof params.sessionId !== "string") {
+        const err = new Error("session/set_mode requires string sessionId");
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      if (typeof params.modeId !== "string") {
+        const err = new Error("session/set_mode requires string modeId");
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      const session = deps.manager.get(params.sessionId);
+      if (!session) {
+        const err = new Error(`session ${params.sessionId} not found`);
+        err.code = JsonRpcErrorCodes.SessionNotFound;
+        throw err;
+      }
+      const result = await session.forwardRequest("session/set_mode", rawParams);
+      session.applyModeChange(params.modeId);
+      return result;
+    });
     connection.setDefaultHandler(async (rawParams, method) => {
       if (!method.startsWith("session/") || rawParams === null || typeof rawParams !== "object") {
         const err = new Error(`Method not found: ${method}`);
@@ -20728,6 +21054,17 @@ function buildInitializeResult() {
     })
   };
 }
+function wireDefaultTransformers(session, deps) {
+  if (!deps.transformers || !deps.manager) {
+    return;
+  }
+  for (const name of deps.manager.defaultTransformers) {
+    const ref = deps.transformers.resolveChain([name])[0];
+    if (ref) {
+      session.addTransformer(ref);
+    }
+  }
+}
 function bindClientToSession(connection, session, state, clientInfo, callerClientId) {
   void state;
   void session;
@@ -21026,6 +21363,39 @@ async function printTail(logPath, fileSize, lines) {
   }
   return fileSize;
 }
+function splitNameFromLogTailArgs(args) {
+  const flagsWithValue = /* @__PURE__ */ new Set(["--tail", "-n"]);
+  let name;
+  const rest = [];
+  let i = 0;
+  while (i < args.length) {
+    const tok = args[i];
+    if (tok === void 0) {
+      break;
+    }
+    if (tok.startsWith("-")) {
+      rest.push(tok);
+      if (flagsWithValue.has(tok) && i + 1 < args.length) {
+        const v = args[i + 1];
+        if (v !== void 0) {
+          rest.push(v);
+        }
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    if (name === void 0) {
+      name = tok;
+      i += 1;
+      continue;
+    }
+    rest.push(tok);
+    i += 1;
+  }
+  return { name, rest };
+}
 function parseLogTailFlags(argv) {
   let tail = 50;
   let follow = false;
@@ -22025,16 +22395,17 @@ async function postLifecycleAll(verb) {
     process.exit(1);
   }
 }
-async function runExtensionsLogs(name, argv) {
+async function runExtensionsLogs(argv) {
+  const { name, rest } = splitNameFromLogTailArgs(argv);
   if (!name) {
     process.stderr.write(
-      "Usage: hydra-acp extensions logs <name> [--tail N] [--follow]\n"
+      "Usage: hydra-acp extensions log <name> [--tail N] [--follow]\n"
     );
     process.exit(2);
     return;
   }
   const logPath = paths.extensionLogFile(name);
-  await runLogTail(logPath, argv, "No log file (extension never ran?)");
+  await runLogTail(logPath, rest, "No log file (extension never ran?)");
 }
 function parseAddFlags(argv) {
   let command = [];
@@ -22480,16 +22851,17 @@ async function postLifecycleAll2(verb) {
     process.exit(1);
   }
 }
-async function runTransformersLogs(name, argv) {
+async function runTransformersLogs(argv) {
+  const { name, rest } = splitNameFromLogTailArgs(argv);
   if (!name) {
     process.stderr.write(
-      "Usage: hydra-acp transformers logs <name> [--tail N] [--follow]\n"
+      "Usage: hydra-acp transformers log <name> [--tail N] [--follow]\n"
     );
     process.exit(2);
     return;
   }
   const logPath = paths.transformerLogFile(name);
-  await runLogTail(logPath, argv, "No log file (transformer never ran?)");
+  await runLogTail(logPath, rest, "No log file (transformer never ran?)");
 }
 async function readRawConfig2() {
   const raw = await fsp12.readFile(paths.config(), "utf8");
@@ -24123,8 +24495,8 @@ async function main() {
         await runExtensionsRestart(name2);
         return;
       }
-      if (sub === "logs") {
-        await runExtensionsLogs(name2, rest);
+      if (sub === "log" || sub === "logs") {
+        await runExtensionsLogs(tail.slice(1));
         return;
       }
       process.stderr.write(`Unknown extension subcommand: ${sub}
@@ -24163,8 +24535,8 @@ async function main() {
         await runTransformersRestart(name2);
         return;
       }
-      if (sub === "logs") {
-        await runTransformersLogs(name2, rest);
+      if (sub === "log" || sub === "logs") {
+        await runTransformersLogs(tail.slice(1));
         return;
       }
       process.stderr.write(`Unknown transformer subcommand: ${sub}
@@ -24384,12 +24756,12 @@ function printHelp() {
       "  hydra-acp extension add <name> [opts]       Add an extension to config",
       "  hydra-acp extension remove <name>           Remove an extension from config",
       "  hydra-acp extension start|stop|restart <n>|all   Lifecycle on one or all",
-      "  hydra-acp extension logs <name> [-f] [-n N]      Tail or follow an extension's log",
+      "  hydra-acp extension log <name> [-f] [-n N]       Tail or follow an extension's log",
       "  hydra-acp transformer list                  List configured transformers and live state",
       "  hydra-acp transformer add <name> [opts]     Add a transformer to config (--command, --args, --env, --disabled)",
       "  hydra-acp transformer remove <name>         Remove a transformer from config",
       "  hydra-acp transformer start|stop|restart <n>|all  Lifecycle on one or all",
-      "  hydra-acp transformer logs <name> [-f] [-n N]     Tail or follow a transformer's log",
+      "  hydra-acp transformer log <name> [-f] [-n N]      Tail or follow a transformer's log",
       "  hydra-acp agent [list]                      List agents in the cached registry",
       "  hydra-acp agent refresh                     Force a registry re-fetch",
       "  hydra-acp agent install <id>                Pre-install <id> from the registry (else lazy on first session)",