@spencerboucher/switchyard 0.5.0 → 0.6.0

package/dist/switchyard.mjs

@@ -283,6 +283,8 @@ var RuntimeCapabilities = z3.object({
   costAccounting: z3.boolean(),
   /** The host runs sessions as interactive Pi in a terminal that clients can attach to. */
   terminal: z3.boolean().optional(),
+  /** The host answers session.models, session.commands, session.setModel, session.setThinking and session.compact. */
+  sessionControls: z3.boolean().optional(),
   unsupported: z3.array(z3.object({ capability: z3.string(), reason: z3.string() }))
 });
 var ProjectScan = z3.object({
@@ -364,6 +366,28 @@ var Workspace = z3.object({
   updatedAt: Iso
 });
 var ThinkingLevel = z3.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var SessionModel = z3.object({
+  provider: z3.string(),
+  id: z3.string(),
+  name: z3.string().nullable(),
+  contextWindow: z3.number().nullable(),
+  reasoning: z3.boolean(),
+  /** In Pi's scoped (favorite) model list; set only when Pi has one. */
+  scoped: z3.boolean().optional(),
+  /** Effort levels this model accepts, in Pi's order; ["off"] without reasoning. */
+  thinkingLevels: z3.array(ThinkingLevel)
+});
+var SlashCommand = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().nullable(),
+  source: z3.enum(["extension", "prompt", "skill"])
+});
+var ContextUsage = z3.object({
+  /** Estimated tokens in context; null right after compaction until the next reply. */
+  tokens: z3.number().nullable(),
+  window: z3.number(),
+  percent: z3.number().nullable()
+});
 var FORBIDDEN_EXTRA_ARGS = ["--mode", "--fork", "--no-session", "-e", "--extension"];
 var ExtraArg = z3.string().refine((a) => a.startsWith("--") || !a.startsWith("-"), "extra args must be long flags").refine((a) => !FORBIDDEN_EXTRA_ARGS.includes(a.split("=")[0]) && !a.startsWith("--session"), "this flag is managed by Switchyard");
 var Profile = z3.object({
@@ -373,7 +397,9 @@ var Profile = z3.object({
   model: z3.string().nullable(),
   thinking: ThinkingLevel.nullable(),
   projectTrust: z3.enum(["ask", "approve", "ignore"]),
-  extraArgs: z3.array(ExtraArg)
+  extraArgs: z3.array(ExtraArg),
+  /** "vanilla": --no-extensions --no-skills --no-prompt-templates. Undefined means "all". */
+  resources: z3.enum(["all", "vanilla"]).optional()
 });
 var RuntimeState = z3.enum([
   "starting",
@@ -387,7 +413,8 @@ var RuntimeState = z3.enum([
 var NativeHandle = z3.object({ sessionId: z3.string(), sessionFile: z3.string() });
 var SessionStats = z3.object({
   tokens: z3.number().nullable(),
-  costUsd: z3.number().nullable()
+  costUsd: z3.number().nullable(),
+  context: ContextUsage.nullable().optional()
 });
 var Session = z3.object({
   id: Id,
@@ -410,6 +437,12 @@ var Session = z3.object({
   archivedAt: Iso.nullable(),
   queue: z3.object({ steering: z3.array(z3.string()), followUp: z3.array(z3.string()) }),
   stats: SessionStats.nullable(),
+  /** The live model (host-owned; last known when stopped). */
+  model: SessionModel.nullable().optional(),
+  /** The live effort (Pi's thinking level). */
+  thinking: ThinkingLevel.nullable().optional(),
+  /** Pi is compacting the context. */
+  compacting: z3.boolean().optional(),
   lastAssistantText: z3.string().nullable(),
   createdAt: Iso,
   /** A live terminal session: `switchyard tui` can attach to its Pi terminal. */
@@ -848,7 +881,8 @@ var ProfileInput = z4.object({
   model: z4.string().nullable().default(null),
   thinking: ThinkingLevel.nullable().default(null),
   projectTrust: z4.enum(["ask", "approve", "ignore"]).default("ask"),
-  extraArgs: z4.array(ExtraArg).default([])
+  extraArgs: z4.array(ExtraArg).default([]),
+  resources: z4.enum(["all", "vanilla"]).default("all")
 });
 var CreateWorkspaceRequest = z4.object({
   checkoutId: z4.string(),
@@ -879,6 +913,18 @@ var PromptRequest = z4.object({
   clientMessageId: z4.string().optional()
 });
 var RenameRequest = z4.object({ title: z4.string().min(1).max(200) });
+var SetModelRequest = z4.object({
+  provider: z4.string().min(1),
+  modelId: z4.string().min(1)
+});
+var SetThinkingRequest = z4.object({ level: ThinkingLevel });
+var CompactRequest = z4.object({ instructions: z4.string().max(4e3).optional() });
+var SessionModelsResult = z4.object({ models: z4.array(SessionModel) });
+var SessionCommandsResult = z4.object({ commands: z4.array(SlashCommand) });
+var ModelStateResult = z4.object({
+  model: SessionModel.nullable(),
+  thinking: ThinkingLevel.nullable()
+});
 var ImportSessionRequest = z4.object({
   hostId: z4.string(),
   sessionFile: z4.string(),
@@ -1253,6 +1299,20 @@ var HostCommand = z8.discriminatedUnion("type", [
   z8.object({ type: z8.literal("session.importable") }),
   z8.object({ type: z8.literal("session.readNative"), sessionFile: z8.string() }),
   z8.object({ type: z8.literal("session.snapshot"), sessionId: z8.string() }),
+  z8.object({ type: z8.literal("session.models"), sessionId: z8.string() }),
+  z8.object({ type: z8.literal("session.commands"), sessionId: z8.string() }),
+  z8.object({
+    type: z8.literal("session.setModel"),
+    sessionId: z8.string(),
+    provider: z8.string().min(1),
+    modelId: z8.string().min(1)
+  }),
+  z8.object({ type: z8.literal("session.setThinking"), sessionId: z8.string(), level: ThinkingLevel }),
+  z8.object({
+    type: z8.literal("session.compact"),
+    sessionId: z8.string(),
+    instructions: z8.string().nullable()
+  }),
   z8.object({ type: z8.literal("checkout.inspect"), path: z8.string() }),
   z8.object({ type: z8.literal("projects.scan"), folder: z8.string().min(1) }),
   z8.object({
@@ -4278,7 +4338,7 @@ function resolveProfile(ctx, profileId, project) {
   const id = profileId ?? project?.defaultProfileId ?? null;
   if (id)
     return ctx.store.profiles.require(id);
-  const first = ctx.store.profiles.list(void 0, [], "created_at")[0];
+  const first = ctx.store.profiles.list(void 0, [], "created_at, rowid")[0];
   if (!first)
     throw new SwitchyardError("invalid_request", "No Pi profile configured");
   return first;
@@ -7437,6 +7497,9 @@ var HOST_SESSION_FIELDS = [
   "runtimeDetail",
   "queue",
   "stats",
+  "model",
+  "thinking",
+  "compacting",
   "lastAssistantText",
   "lastActivityAt",
   "terminal"
@@ -7955,7 +8018,7 @@ var HostHub = class {
         projectId: ws?.projectId ?? null,
         cwd: "",
         nativeHandle: null,
-        profileSnapshot: this.store.profiles.list(void 0, [], "created_at")[0] ?? FALLBACK_PROFILE,
+        profileSnapshot: this.store.profiles.list(void 0, [], "created_at, rowid")[0] ?? FALLBACK_PROFILE,
         runtime: "idle",
         runtimeDetail: null,
         runId: null,
@@ -9133,23 +9196,39 @@ function registerOpsRoutes(app, ctx) {
 
 // packages/coordinator/dist/routes/profiles.js
 var ProfilePatch = Profile.omit({ id: true }).partial();
-function seedDefaultProfile(ctx) {
+function seedDefaultProfiles(ctx) {
   ctx.store.tx(() => {
-    if (ctx.store.profiles.count() > 0)
+    if (ctx.store.profiles.count() === 0) {
+      ctx.store.putProfile({
+        id: newId("prf"),
+        name: "Default",
+        provider: null,
+        model: null,
+        thinking: null,
+        projectTrust: "ask",
+        extraArgs: []
+      });
+    }
+    if (ctx.store.getSetting("profiles.vanillaSeeded", false))
       return;
-    ctx.store.putProfile({
-      id: newId("prf"),
-      name: "Default",
-      provider: null,
-      model: null,
-      thinking: null,
-      projectTrust: "ask",
-      extraArgs: []
-    });
+    const has = ctx.store.profiles.list().some((p) => p.resources === "vanilla");
+    if (!has) {
+      ctx.store.putProfile({
+        id: newId("prf"),
+        name: "Vanilla",
+        provider: null,
+        model: null,
+        thinking: null,
+        projectTrust: "ask",
+        extraArgs: [],
+        resources: "vanilla"
+      });
+    }
+    ctx.store.setSetting("profiles.vanillaSeeded", true);
   });
 }
 function registerProfileRoutes(app, ctx) {
-  app.get("/api/profiles", async () => ctx.store.profiles.list(void 0, [], "created_at"));
+  app.get("/api/profiles", async () => ctx.store.profiles.list(void 0, [], "created_at, rowid"));
   app.get("/api/profiles/:id", async (req) => ctx.store.profiles.require(req.params.id));
   app.post("/api/profiles", async (req, reply) => {
     const body = parse(ProfileInput, req.body);
@@ -9316,6 +9395,20 @@ function registerProjectRoutes(app, ctx) {
 
 // packages/coordinator/dist/routes/sessions.js
 import { z as z16 } from "zod";
+function requireLiveSession(ctx, s) {
+  if (s.readOnly)
+    throw new SwitchyardError("forbidden", SUBAGENT_READ_ONLY);
+  if (!LIVE_RUNTIMES2.includes(s.runtime) || s.runtime === "starting") {
+    throw new SwitchyardError("conflict", s.runtime === "starting" ? "Session is still starting" : `Session ${s.runtime}: Resume to send`);
+  }
+  requireConnected(ctx, s.hostId);
+}
+function requireSessionControls(ctx, s) {
+  requireLiveSession(ctx, s);
+  if (ctx.store.hosts.get(s.hostId)?.capabilities?.sessionControls !== true) {
+    throw new SwitchyardError("invalid_request", "Update Switchyard on this host to change the model, effort or commands from here");
+  }
+}
 var ListQuery5 = z16.object({
   projectId: z16.string().optional(),
   hostId: z16.string().optional(),
@@ -9449,12 +9542,7 @@ function registerSessionRoutes(app, ctx) {
   app.post("/api/sessions/:id/prompt", async (req) => {
     const s = get(idOf(req));
     const body = parse(PromptRequest, req.body);
-    if (s.readOnly)
-      throw new SwitchyardError("forbidden", SUBAGENT_READ_ONLY);
-    if (!LIVE_RUNTIMES2.includes(s.runtime) || s.runtime === "starting") {
-      throw new SwitchyardError("conflict", s.runtime === "starting" ? "Session is still starting" : `Session ${s.runtime}: Resume to send`);
-    }
-    requireConnected(ctx, s.hostId);
+    requireLiveSession(ctx, s);
     const run = ctx.store.runForSession(s);
     const result = await ctx.hostHub.request(s.hostId, {
       type: "session.prompt",
@@ -9472,6 +9560,53 @@ function registerSessionRoutes(app, ctx) {
       automationActive: run?.controlMode === "automation"
     };
   });
+  app.get("/api/sessions/:id/models", async (req) => {
+    const s = get(idOf(req));
+    requireSessionControls(ctx, s);
+    return SessionModelsResult.parse(await ctx.hostHub.request(s.hostId, { type: "session.models", sessionId: s.id }));
+  });
+  app.get("/api/sessions/:id/commands", async (req) => {
+    const s = get(idOf(req));
+    requireSessionControls(ctx, s);
+    return SessionCommandsResult.parse(await ctx.hostHub.request(s.hostId, { type: "session.commands", sessionId: s.id }));
+  });
+  app.post("/api/sessions/:id/model", async (req) => {
+    const s = get(idOf(req));
+    const body = parse(SetModelRequest, req.body);
+    requireSessionControls(ctx, s);
+    return ModelStateResult.parse(await ctx.hostHub.request(s.hostId, {
+      type: "session.setModel",
+      sessionId: s.id,
+      provider: body.provider,
+      modelId: body.modelId
+    }));
+  });
+  app.post("/api/sessions/:id/thinking", async (req) => {
+    const s = get(idOf(req));
+    const body = parse(SetThinkingRequest, req.body);
+    requireSessionControls(ctx, s);
+    return ModelStateResult.parse(await ctx.hostHub.request(s.hostId, {
+      type: "session.setThinking",
+      sessionId: s.id,
+      level: body.level
+    }));
+  });
+  app.post("/api/sessions/:id/compact", async (req) => {
+    const s = get(idOf(req));
+    const body = parse(CompactRequest, req.body ?? {});
+    requireSessionControls(ctx, s);
+    if (s.runtime !== "idle") {
+      throw new SwitchyardError("conflict", "Wait for the run to finish before compacting");
+    }
+    if (s.compacting)
+      throw new SwitchyardError("conflict", "Compaction is already running");
+    await ctx.hostHub.request(s.hostId, {
+      type: "session.compact",
+      sessionId: s.id,
+      instructions: body.instructions?.trim() || null
+    });
+    return { ok: true };
+  });
   app.post("/api/sessions/:id/abort", async (req) => {
     const s = get(idOf(req));
     const body = parse(AbortRequest, req.body);
@@ -10356,7 +10491,7 @@ var Store2 = class {
       projects: this.projects.list(void 0, [], "created_at"),
       checkouts: this.checkouts.list(),
       workspaces: this.workspaces.list("archived_at IS NULL"),
-      profiles: this.profiles.list(void 0, [], "created_at"),
+      profiles: this.profiles.list(void 0, [], "created_at, rowid"),
       sessions,
       tasks,
       runs,
@@ -10546,7 +10681,7 @@ function createCoordinator(opts) {
     auth: new RateLimiter(limits ? limits.auth ?? AUTH_RATE_LIMIT : Number.POSITIVE_INFINITY, 6e4, storeClock),
     hosts: new RateLimiter(limits ? limits.hosts ?? HOSTS_RATE_LIMIT : Number.POSITIVE_INFINITY, 6e4, storeClock)
   };
-  seedDefaultProfile({ store });
+  seedDefaultProfiles({ store });
   const attention = new AttentionService(store, hub);
   const hostHub = new HostHub(store, hub, attention, log.child({ mod: "host-hub" }), {
     unreachableAfterMs: config.unreachableAfterMs,
@@ -12776,7 +12911,7 @@ function toErrorBody(err) {
 function queueKey(command) {
   if (command.type === "checks.run")
     return `checks:${command.sessionId}`;
-  if (command.type === "session.answer" || command.type === "session.abort" || command.type === "session.setControl" || command.type === "session.adapterAction" || command.type === "session.snapshot") {
+  if (command.type === "session.answer" || command.type === "session.abort" || command.type === "session.setControl" || command.type === "session.adapterAction" || command.type === "session.snapshot" || command.type === "session.models" || command.type === "session.commands") {
     return `control:${command.sessionId}`;
   }
   if ("sessionId" in command && typeof command.sessionId === "string") {
@@ -12931,6 +13066,16 @@ var CommandRouter = class {
         return sup.readNative(c.sessionFile);
       case "session.snapshot":
         return sup.snapshot(c.sessionId);
+      case "session.models":
+        return sup.models(c.sessionId);
+      case "session.commands":
+        return sup.commands(c.sessionId);
+      case "session.setModel":
+        return sup.setModel(c.sessionId, c.provider, c.modelId);
+      case "session.setThinking":
+        return sup.setThinking(c.sessionId, c.level);
+      case "session.compact":
+        return sup.compact(c.sessionId, c.instructions);
       case "checkout.inspect":
         return inspectCheckout2(c.path);
       case "projects.scan":
@@ -13871,6 +14016,45 @@ function createLogger2(opts = {}) {
 // packages/host-agent/dist/main.js
 import { readFileSync as readFileSync8 } from "node:fs";
 
+// packages/pi-runtime/dist/bridge/pi-model.js
+var PI_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function supportedThinkingLevels(model) {
+  const known = PI_THINKING_LEVELS;
+  if (Array.isArray(model?.thinkingLevels)) {
+    return model.thinkingLevels.filter((l) => typeof l === "string" && known.includes(l));
+  }
+  if (!model?.reasoning)
+    return ["off"];
+  return PI_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null)
+      return false;
+    if (level === "xhigh" || level === "max")
+      return mapped !== void 0;
+    return true;
+  });
+}
+function modelInfo(model) {
+  if (!model || typeof model.provider !== "string" || typeof model.id !== "string")
+    return null;
+  return {
+    provider: model.provider,
+    id: model.id,
+    name: typeof model.name === "string" && model.name ? model.name : null,
+    contextWindow: typeof model.contextWindow === "number" ? model.contextWindow : null,
+    reasoning: model.reasoning === true,
+    thinkingLevels: supportedThinkingLevels(model)
+  };
+}
+
 // packages/pi-runtime/dist/capabilities.js
 import { execFile as execFile2 } from "node:child_process";
 import semver from "semver";
@@ -13889,6 +14073,7 @@ var PI_RPC_CAPABILITIES = {
   widgetsComponent: false,
   tokenAccounting: true,
   costAccounting: true,
+  sessionControls: true,
   unsupported: [
     { capability: "customUi", reason: "ctx.ui.custom() returns undefined in RPC mode" },
     {
@@ -13912,6 +14097,7 @@ function noCapabilities(reason) {
     widgetsComponent: false,
     tokenAccounting: false,
     costAccounting: false,
+    sessionControls: false,
     unsupported: [{ capability: "all", reason }]
   };
 }
@@ -15099,6 +15285,11 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
   items = /* @__PURE__ */ new Map();
   partialToolOutput = /* @__PURE__ */ new Map();
   runAssistantText = null;
+  _model = null;
+  scoped = null;
+  _thinking = null;
+  _compacting = false;
+  lastModelJson = "";
   constructor(opts) {
     super();
     this.opts = opts;
@@ -15149,6 +15340,12 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
   get remoteDialogs() {
     return this.proc instanceof PiTerminalProcess ? this.proc.remoteDialogs : true;
   }
+  get modelState() {
+    return { model: this._model ? { ...this._model } : null, thinking: this._thinking };
+  }
+  get compacting() {
+    return this._compacting;
+  }
   get isAlive() {
     return this.proc !== null && this.proc.exited === null;
   }
@@ -15175,6 +15372,9 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
       args.push("--approve");
     else if (profile.projectTrust === "ignore")
       args.push("--no-approve");
+    if (profile.resources === "vanilla") {
+      args.push("--no-extensions", "--no-skills", "--no-prompt-templates");
+    }
     args.push(...profile.extraArgs);
     args.push(...this.opts.extraArgs ?? []);
     for (const ext of this.opts.extensions ?? [])
@@ -15245,6 +15445,9 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
     this._native = { sessionId: state.sessionId, sessionFile: state.sessionFile };
     this.started = true;
     this.busy = state.isStreaming;
+    this.applyModel(state.model);
+    this.applyThinking(state.thinkingLevel);
+    this.emitModelIfChanged();
     this.emit("native", { ...this._native });
     this.setRuntime();
   }
@@ -15272,6 +15475,9 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
     }
     this.started = true;
     this.busy = state.isStreaming;
+    this.applyModel(state.model);
+    this.applyThinking(state.thinkingLevel);
+    this.emitModelIfChanged();
     this.setRuntime();
   }
   /** Terminal transport: let go of the holder; Pi keeps running and no exit is reported. */
@@ -15341,10 +15547,115 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
   async rename(title) {
     await this.call(this.requireAlive(), { type: "set_session_name", name: title });
   }
+  /** Models Pi can use right now. */
+  async models() {
+    const data = await this.call(this.requireAlive(), {
+      type: "get_available_models"
+    });
+    const out = [];
+    for (const raw of data?.models ?? []) {
+      const m = this.toSessionModel(raw);
+      if (!m)
+        continue;
+      if (this.scoped && this.scoped.size > 0)
+        m.scoped = this.scoped.has(`${m.provider}/${m.id}`);
+      out.push(m);
+    }
+    return out.sort((a, b) => a.provider.localeCompare(b.provider) || (a.name ?? a.id).localeCompare(b.name ?? b.id));
+  }
+  /** Slash commands Pi knows (extension commands, prompt templates, skills). */
+  async commands() {
+    const data = await this.call(this.requireAlive(), {
+      type: "get_commands"
+    });
+    const out = [];
+    for (const c of data?.commands ?? []) {
+      if (typeof c?.name !== "string" || !c.name)
+        continue;
+      if (c.source !== "extension" && c.source !== "prompt" && c.source !== "skill")
+        continue;
+      out.push({
+        name: c.name,
+        description: typeof c.description === "string" ? c.description : null,
+        source: c.source
+      });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async setModel(provider, modelId) {
+    await this.call(this.requireAlive(), { type: "set_model", provider, modelId });
+    await this.refreshModelState();
+    return this.modelState;
+  }
+  async setThinking(level) {
+    await this.call(this.requireAlive(), { type: "set_thinking_level", level });
+    await this.refreshModelState();
+    return this.modelState;
+  }
+  /** Start a manual compaction. Terminal sessions answer at once; Pi's RPC answers when done. */
+  async compact(instructions) {
+    const proc = this.requireAlive();
+    const cmd = { type: "compact", ...instructions ? { customInstructions: instructions } : {} };
+    if (this.transport === "terminal") {
+      await this.call(proc, cmd, 1e4);
+    } else {
+      this.call(proc, cmd, 30 * 6e4).catch(() => {
+      });
+    }
+  }
+  async refreshModelState() {
+    const s = await this.state();
+    this.applyModel(s.model);
+    this.applyThinking(s.thinkingLevel);
+    this.emitModelIfChanged();
+  }
+  toSessionModel(raw) {
+    const info = modelInfo(raw);
+    if (!info)
+      return null;
+    return {
+      ...info,
+      thinkingLevels: info.thinkingLevels.flatMap((l) => {
+        const r = ThinkingLevel.safeParse(l);
+        return r.success ? [r.data] : [];
+      })
+    };
+  }
+  applyScoped(raw) {
+    if (Array.isArray(raw))
+      this.scoped = new Set(raw.filter((x) => typeof x === "string"));
+  }
+  applyModel(raw) {
+    this._model = this.toSessionModel(raw);
+  }
+  applyThinking(raw) {
+    const r = ThinkingLevel.safeParse(raw);
+    this._thinking = r.success ? r.data : null;
+  }
+  emitModelIfChanged() {
+    const json = JSON.stringify(this.modelState);
+    if (json === this.lastModelJson)
+      return;
+    this.lastModelJson = json;
+    this.emit("model", this.modelState);
+  }
+  setCompacting(v) {
+    if (this._compacting === v)
+      return;
+    this._compacting = v;
+    this.emit("compacting", v);
+  }
   /** Token and cost totals (`get_session_stats`). */
   async stats() {
     const raw = await this.call(this.requireAlive(), { type: "get_session_stats" });
+    const cu = raw?.contextUsage;
+    const context = cu && typeof cu.contextWindow === "number" ? {
+      tokens: typeof cu.tokens === "number" ? cu.tokens : null,
+      window: cu.contextWindow,
+      percent: typeof cu.percent === "number" ? cu.percent : null
+    } : null;
     return {
+      context,
       tokens: typeof raw?.tokens?.total === "number" ? raw.tokens.total : null,
       costUsd: typeof raw?.cost === "number" ? raw.cost : null,
       raw
@@ -15478,6 +15789,12 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
       this.emit("bridge", msg);
       if (msg.type === "ui_prompt_end")
         this.onPromptEnd(msg);
+      if (msg.type === "model_state") {
+        this.applyScoped(msg.scoped);
+        this.applyModel(msg.model);
+        this.applyThinking(msg.thinkingLevel);
+        this.emitModelIfChanged();
+      }
     });
     proc.on("stderr", (text) => this.emit("stderr", text));
     proc.on("protocol_error", (err, line) => {
@@ -15520,6 +15837,7 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
       this.emit("ui_resolved", { id, by: "exit", request: req });
     this.pending.clear();
     this.current = null;
+    this.setCompacting(false);
     const wasBusy = this.busy;
     this.busy = false;
     if (this.terminal === "failed") {
@@ -15686,15 +16004,29 @@ var ManagedSession = class _ManagedSession extends EventEmitter5 {
           this.notice("error", `Retry failed: ${ev.finalError ?? "unknown error"}`);
         break;
       case "compaction_start":
+        this.setCompacting(true);
         this.notice("info", `Compacting context (${ev.reason ?? "manual"})`);
         break;
       case "compaction_end":
+        this.setCompacting(false);
         if (ev.result)
           this.notice("info", "Context compacted");
         else if (ev.aborted)
           this.notice("warning", "Compaction aborted");
-        else
-          this.notice("error", `Compaction failed: ${ev.errorMessage ?? "unknown error"}`);
+        else {
+          const msg = String(ev.errorMessage ?? "unknown error").replace(/^Compaction failed:\s*/, "");
+          this.notice("error", `Compaction failed: ${msg}`);
+        }
+        break;
+      case "model_state":
+        this.applyScoped(ev.scoped);
+        this.applyModel(ev.model);
+        this.applyThinking(ev.thinkingLevel);
+        this.emitModelIfChanged();
+        break;
+      case "thinking_level_changed":
+        this.applyThinking(ev.level);
+        this.emitModelIfChanged();
         break;
       case "extension_error":
         this.emit("diagnostic", {
@@ -15987,6 +16319,7 @@ var SessionSupervisor = class {
   markLost(rec, expireSummary) {
     rec.runtime = "interrupted";
     rec.runtimeDetail = "Host agent restarted";
+    rec.compacting = false;
     rec.queue = { steering: [], followUp: [] };
     rec.terminal = null;
     this.expirePending(rec.id, expireSummary);
@@ -16116,6 +16449,9 @@ var SessionSupervisor = class {
       archivedAt: null,
       queue: rec.queue,
       stats: rec.stats,
+      model: rec.model ?? null,
+      thinking: rec.thinking ?? null,
+      compacting: rec.compacting ?? false,
       lastAssistantText: rec.lastAssistantText,
       createdAt: rec.createdAt,
       terminal: rec.terminal != null
@@ -16241,6 +16577,9 @@ var SessionSupervisor = class {
       nextOrder,
       queue: { steering: [], followUp: [] },
       stats: prev?.stats ?? null,
+      model: prev?.model ?? null,
+      thinking: prev?.thinking ?? null,
+      compacting: false,
       lastAssistantText: prev?.lastAssistantText ?? null,
       lastActivityAt: now,
       createdAt: prev?.createdAt ?? now
@@ -16331,6 +16670,28 @@ var SessionSupervisor = class {
     this.db.tx(() => this.saveAndEmit(rec));
     return { title };
   }
+  async models(sessionId) {
+    return { models: await this.requireLive(sessionId).models() };
+  }
+  async commands(sessionId) {
+    return { commands: await this.requireLive(sessionId).commands() };
+  }
+  async setModel(sessionId, provider, modelId) {
+    return this.requireLive(sessionId).setModel(provider, modelId);
+  }
+  async setThinking(sessionId, level) {
+    return this.requireLive(sessionId).setThinking(level);
+  }
+  async compact(sessionId, instructions) {
+    const ms = this.requireLive(sessionId);
+    if (ms.compacting)
+      throw new SwitchyardError("conflict", "Compaction is already running");
+    if (ms.runtime !== "idle") {
+      throw new SwitchyardError("conflict", "Wait for the run to finish before compacting");
+    }
+    await ms.compact(instructions);
+    return { ok: true };
+  }
   async adapterAction(sessionId, adapterId, actionId, payload) {
     const l = this.live.get(sessionId);
     if (!l?.adapters) {
@@ -16585,6 +16946,18 @@ var SessionSupervisor = class {
         this.db.tx(() => this.saveAndEmit(rec));
       }
     });
+    ms.on("model", (m) => {
+      rec.model = m.model;
+      rec.thinking = m.thinking;
+      this.db.tx(() => this.saveAndEmit(rec));
+      void this.refreshStats(l);
+    });
+    ms.on("compacting", (c) => {
+      rec.compacting = c;
+      this.db.tx(() => this.saveAndEmit(rec));
+      if (!c)
+        void this.refreshStats(l);
+    });
     ms.on("diagnostic", (d) => this.diagnostic(rec.id, null, d.level, d.message));
     ms.on("stderr", (text) => this.opts.log.debug({ sessionId: rec.id, stderr: text.slice(0, 2e3) }, "pi stderr"));
     ms.on("ui_request", (req) => this.enqueue(l, () => this.onUiRequest(l, req)));
@@ -16619,7 +16992,7 @@ var SessionSupervisor = class {
       return;
     try {
       const s = await ms.stats();
-      const stats = { tokens: s.tokens, costUsd: s.costUsd };
+      const stats = { tokens: s.tokens, costUsd: s.costUsd, context: s.context };
       if (JSON.stringify(stats) === JSON.stringify(l.rec.stats))
         return;
       l.rec.stats = stats;
@@ -16664,6 +17037,8 @@ var SessionSupervisor = class {
         return;
       case "message_end": {
         const m = ev.message;
+        if (m?.role === "assistant")
+          void this.refreshStats(l);
         if (adapters && m?.role === "custom" && typeof m.customType === "string") {
           await adapters.onCustomMessage({
             customType: m.customType,