@hydra-acp/cli 0.1.45 → 0.1.46

package/dist/index.js

@@ -173,7 +173,7 @@ var DaemonConfig = z.object({
   // 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.
@@ -233,7 +233,13 @@ var TuiConfig = z.object({
   // 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)
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -287,7 +293,8 @@ var HydraConfig = z.object({
     cwdColumnMaxWidth: 24,
     progressIndicator: true,
     defaultEnterAction: "amend",
-    showThoughts: true
+    showThoughts: true,
+    promptHistoryMaxEntries: 2e3
   })
 });
 function extensionList(config) {
@@ -2284,6 +2291,11 @@ var HYDRA_COMMANDS = [
     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)"
   }
 ];
 var VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
@@ -2370,7 +2382,9 @@ var Session = class {
   // 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();
@@ -2436,6 +2450,7 @@ var Session = class {
   // and noisy state churn keep a quiet session alive forever.
   lastRecordedAt;
   spawnReplacementAgent;
+  listSessions;
   logger;
   transformChain;
   // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
@@ -2467,6 +2482,23 @@ var Session = class {
   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
@@ -2499,7 +2531,7 @@ var Session = class {
     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];
@@ -2513,6 +2545,7 @@ var Session = class {
     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) {
@@ -2531,6 +2564,9 @@ var Session = class {
   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", {
@@ -2595,7 +2631,8 @@ var Session = class {
   // 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)) {
@@ -2683,8 +2720,8 @@ var Session = class {
       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);
@@ -2877,8 +2914,8 @@ var Session = class {
         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"
       };
@@ -2890,8 +2927,8 @@ var Session = class {
       }
       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;
@@ -3430,6 +3467,23 @@ var Session = class {
       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.
@@ -3754,6 +3808,9 @@ var Session = class {
     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 {
@@ -3773,7 +3830,7 @@ var Session = class {
     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;
@@ -3797,10 +3854,11 @@ var Session = class {
     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 {
       }
     }
@@ -3810,16 +3868,16 @@ var Session = class {
   // 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);
@@ -3854,16 +3912,9 @@ var Session = class {
       }
     };
   }
-  // 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
@@ -3929,6 +3980,26 @@ var Session = class {
   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);
   }
@@ -4011,6 +4082,8 @@ var Session = class {
         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}`
@@ -4020,6 +4093,92 @@ var Session = class {
       }
     }
   }
+  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.
@@ -4141,6 +4300,57 @@ var Session = class {
     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
@@ -4757,6 +4967,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(
@@ -5548,6 +5774,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,
@@ -5649,6 +5876,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,
@@ -5662,6 +5905,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
@@ -5669,11 +5913,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
@@ -5700,6 +5948,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,
@@ -5713,15 +5970,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
@@ -5923,13 +6181,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)}`
           );
         }
       }
@@ -6106,6 +6366,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.
@@ -6167,7 +6430,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,
@@ -6319,6 +6582,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.
@@ -6708,6 +6972,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 [];
@@ -8513,7 +8818,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");
@@ -9677,6 +9990,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 };
       });
@@ -9892,16 +10213,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) {
@@ -9915,6 +10233,7 @@ function registerAcpWsEndpoint(app, deps) {
           ...resurrectParams,
           onInstallProgress: makeInstallProgressForwarder(connection)
         });
+        wireDefaultTransformers(session, deps);
       }
       const client = bindClientToSession(
         connection,
@@ -10004,6 +10323,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,
@@ -10156,6 +10476,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");
@@ -10206,6 +10527,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}`);
@@ -10478,6 +10825,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;