@saadnvd1/agent-os 0.3.715 → 0.3.728

package/README.md

@@ -19,6 +19,7 @@ and check on all of it from your phone.
 - **Other machines in the same list.** Link another machine that runs AgentOS and start or move work there. [More](docs/reference/machines.md)
 - **Built for your phone.** The whole app works on a phone; pair it with a QR code. [More](docs/guides/phone.md)
 - **Phone to orchestrator.** A paired phone can send a shake report or a shared page or file to a workspace's orchestrator (`POST /api/orchestrators/:workspaceId/intake`, saved under `intake/` beside the database, shared content marked untrusted), and fetch names to improve dictation (`GET /api/voice/vocab?workspace=`). [More](docs/guides/phone.md)
+- **An analyst beside your coding agent.** Pair a chat with a second one that reviews each turn, explains it in plain English, flags issues and drafts the next prompt, which you send, edit or dismiss. Side by side on a desktop, a switch on a phone. [More](docs/decisions/2026-10-21-analyst-sessions.md)
 - **Agents that talk to each other.** Sessions message each other with `aos`, and you see every conversation in Messages. [More](docs/guides/agent-network.md)
 - **Chat or terminal, same conversation.** Streaming replies, steps and diffs, plan mode, slash commands, `@file`, undo. [More](docs/guides/chat.md)
 - **Bookmarks.** Star any message, tool call or turn, then find it again from the chat or across every chat, with a search. [More](docs/guides/chat.md)
@@ -28,6 +29,7 @@ and check on all of it from your phone.
 - **Project config.** `agentos.json` gives each session its own ports, environment, files and a private Postgres copy. [More](docs/reference/project-config.md)
 - **Schedules and recipes.** Start work on a timer, or save a job that comes up again. [More](docs/guides/schedules.md)
 - **Plans in pieces and stacks.** A plan splits into several PRs only for a real reason; a board can run as stacked PRs. [More](docs/guides/tasks.md#plans-in-pieces)
+- **Export a session for AI.** A whole chat or a range of its turns as Markdown, JSON or HTML, with a compact mode, the same masking as Share, a size and token estimate, and every cut labelled. [More](docs/guides/export.md)
 - **Machine load and status.** A load gauge, each session's share of CPU and memory, and Needs you, Working, In review and Done as it changes. [More](docs/guides/sessions.md)
 - **A health watcher.** Zero-token checks on the orchestrator's tick catch a red machine load, a held queue, a quiet background job, a restart loop, slow CI, a PR armed for hours and a piece started twice. Each trip wakes one short, tool-less Sonnet call that judges it and posts one line to the orchestrator; only a thing you alone can clear reaches your phone. Settings → Health lists what is open, the history, the notes on what normal looks like and the thresholds. Report only: it never acts. [More](docs/reference/health.md)
 - **Workspaces.** Group projects, finish work with Done, and get a log of every merged task. [More](docs/reference/workspaces.md)

package/app/api/agent-roles/route.test.ts

@@ -0,0 +1,67 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { db } from "@/lib/db";
+import { GET, PUT } from "./route";
+import { TRUST_HEADER } from "@/lib/security/auth";
+
+const url = "http://localhost/api/agent-roles";
+const put = (body: unknown, trusted = true) =>
+  PUT(
+    new NextRequest(url, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      headers: trusted ? { [TRUST_HEADER]: "loopback" } : {},
+    })
+  );
+const get = (q = "") => GET(new NextRequest(`${url}${q}`));
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM settings WHERE key LIKE 'models%'`).run();
+});
+
+describe("/api/agent-roles", () => {
+  it("lists the four roles with the model in force", async () => {
+    const { roles } = await (await get()).json();
+    expect(roles.map((r: { id: string }) => r.id)).toEqual([
+      "developer",
+      "analyst",
+      "reviewer",
+      "supervisor",
+    ]);
+    expect(roles[0].binding).toMatchObject({ source: "default" });
+  });
+
+  it("saves a role and shows it back", async () => {
+    const res = await put({
+      scope: "settings",
+      roles: { analyze: "anthropic/claude-sonnet-5-5" },
+    });
+    expect(res.status).toBe(200);
+    const { roles } = await res.json();
+    expect(roles.find((r: { id: string }) => r.id === "analyst")).toMatchObject(
+      {
+        value: "anthropic/claude-sonnet-5-5",
+        binding: { source: "settings" },
+      }
+    );
+  });
+
+  it("refuses a request that isn't from this machine or the tailnet", async () => {
+    expect((await put({ scope: "settings", roles: {} }, false)).status).toBe(
+      403
+    );
+  });
+
+  it("refuses a Pi model for a role that can't run it", async () => {
+    const res = await put({
+      scope: "settings",
+      roles: { orchestrator: "pi/local/qwen3-27b" },
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("404s an unknown project and 400s a bad scope", async () => {
+    expect((await get("?scope=project&id=nope")).status).toBe(404);
+    expect((await get("?scope=galaxy")).status).toBe(400);
+  });
+});

package/app/api/agent-roles/route.ts

@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { agentRolesView, saveAgentRoles } from "@/lib/models/agent-roles-view";
+import { roleMapSchema } from "@/lib/models/config";
+import { getProject } from "@/lib/projects";
+import { getWorkspace } from "@/lib/workspaces";
+import { requireLocalTrust } from "@/lib/security/route-guard";
+
+const scopeQuery = z.object({
+  scope: z.enum(["settings", "workspace", "project"]).default("settings"),
+  id: z.string().min(1).optional(),
+});
+
+function known({ scope, id }: z.infer<typeof scopeQuery>): string | null {
+  if (scope === "settings") return null;
+  if (!id) return `${scope} needs an id`;
+  if (scope === "workspace" && !getWorkspace(id)) return "Workspace not found";
+  if (scope === "project" && !getProject(id)) return "Project not found";
+  return null;
+}
+
+// GET /api/agent-roles?scope=settings|workspace|project&id= - the four
+// agent roles and the internal ones: what's saved at the scope, the model in
+// force and where it came from, and the model's locality and availability.
+export async function GET(request: NextRequest) {
+  const q = scopeQuery.safeParse(
+    Object.fromEntries(request.nextUrl.searchParams)
+  );
+  if (!q.success)
+    return NextResponse.json({ error: "Bad scope" }, { status: 400 });
+  const missing = known(q.data);
+  if (missing) return NextResponse.json({ error: missing }, { status: 404 });
+  return NextResponse.json(agentRolesView(q.data));
+}
+
+const body = scopeQuery.extend({
+  roles: roleMapSchema,
+  fallbacks: roleMapSchema.optional(),
+});
+
+// PUT /api/agent-roles {scope, id?, roles, fallbacks?} - replaces the roles
+// saved at the scope. Only from this machine or the tailnet, like Settings.
+export async function PUT(request: NextRequest) {
+  const refused = requireLocalTrust(request);
+  if (refused) return refused;
+  try {
+    const b = body.parse(await request.json());
+    const missing = known(b);
+    if (missing) return NextResponse.json({ error: missing }, { status: 404 });
+    saveAgentRoles(b, b.roles, b.fallbacks);
+    return NextResponse.json(agentRolesView(b));
+  } catch (error) {
+    const message =
+      error instanceof z.ZodError
+        ? error.issues.map((i) => i.message).join("; ")
+        : error instanceof Error
+          ? error.message
+          : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/analyst/[id]/recommendations/[recId]/again/route.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { askAgain } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/again - Ask again, for a
+// reply that carried no valid recommendation.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, z.object({}), async () => {
+    await askAgain(id, recId);
+    return { ok: true };
+  });
+}

package/app/api/analyst/[id]/recommendations/[recId]/dismiss/route.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { dismissRecommendation } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/dismiss - 409 once decided.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, z.object({}), () => ({
+    recommendation: dismissRecommendation(id, recId),
+  }));
+}

package/app/api/analyst/[id]/recommendations/[recId]/send/route.ts

@@ -0,0 +1,13 @@
+import { sendRecommendation, sendSchema } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/send { text? } - Send to
+// Coding Agent, edited when text is given. 409 once decided.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, sendSchema, async (b) => ({
+    recommendation: await sendRecommendation(id, recId, b.text),
+  }));
+}

package/app/api/analyst/[id]/review/route.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { AnalystError, getLinkOrThrow, pushDigest } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// POST /api/analyst/:id/review - Review now: the turns since the last
+// review, or the last turn again.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, z.object({}), async () => {
+    const link = getLinkOrThrow(id);
+    if (link.endedAt) throw new AnalystError("This pairing has ended", 409);
+    const result = await pushDigest(id, { force: true });
+    if (result === "nothing")
+      throw new AnalystError(
+        "The coding agent hasn't finished a turn yet",
+        409
+      );
+    return { result };
+  });
+}

package/app/api/analyst/[id]/route.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import {
+  AnalystError,
+  endLink,
+  linkView,
+  patchLinkSchema,
+  setPaused,
+} from "@/lib/analyst";
+import { analystRoute, run } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+const view = (id: string) => {
+  const link = linkView(id);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  return { link };
+};
+
+// GET /api/analyst/:id - the pairing, both sessions and its latest cards.
+export async function GET(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return run(() => view(id));
+}
+
+// PATCH /api/analyst/:id { paused } - stop or resume sending turns.
+export async function PATCH(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, patchLinkSchema, (b) => {
+    setPaused(id, b.paused);
+    return view(id);
+  });
+}
+
+const unlink = z.object({ endAnalyst: z.boolean().optional() });
+
+// DELETE /api/analyst/:id { endAnalyst? } - unlink; the analyst is settled
+// unless endAnalyst is false. History is kept.
+export async function DELETE(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, unlink, (b) => {
+    endLink(id, b);
+    return view(id);
+  });
+}

package/app/api/analyst/route.ts

@@ -0,0 +1,10 @@
+import { createLink, createLinkSchema, linkView } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+// POST /api/analyst { coderSessionId | newCoder, analystModel?, reviewLast? }
+// - pairs an analyst chat with a coding chat (a new one with newCoder).
+export async function POST(request: Request) {
+  return analystRoute(request, createLinkSchema, async (b) => ({
+    link: linkView((await createLink(b)).id),
+  }));
+}

package/app/api/bus/spawn/route.ts

@@ -5,7 +5,8 @@ import { startOrQueue, stampPriority } from "@/lib/tasks/queue";
 import { isPriority } from "@/lib/tasks/schedule-types";
 import { hostIdNamed } from "@/lib/hosts";
 import { resolveGroup } from "@/lib/session-groups";
-import { startView } from "@/lib/sessions/launch";
+import { launchSession, startView } from "@/lib/sessions/launch";
+import { isAgentRole } from "@/lib/models/agent-roles";
 import { callerSession, starterOf } from "@/lib/tasks/starter";
 import { callingDevice } from "@/lib/security/device-me";
 import {
@@ -35,6 +36,7 @@ export async function POST(request: NextRequest) {
       cwd,
       piece,
       group,
+      agentRole,
     } = await request.json();
     // Whoever called: a session (by `from`, else the worktree it runs in) or a person.
     const starter = starterOf(
@@ -103,6 +105,25 @@ export async function POST(request: NextRequest) {
         ? NextResponse.json({ queued: out.queued, builds }, { status: 202 })
         : NextResponse.json({ session: out.started, builds }, { status: 201 });
     }
+    if (agentRole !== undefined) {
+      if (mode !== "session") throw new Error("--role works for spawn only");
+      if (!isAgentRole(agentRole))
+        throw new Error("--role is developer, analyst, reviewer or supervisor");
+      const { session } = await launchSession({
+        projectId: target.id,
+        agentType: "claude",
+        prompt,
+        name: given,
+        model: typeof model === "string" ? model : null,
+        autoApprove: true,
+        startedBy,
+        startedVia: starter.startedVia,
+        parentSessionId: starter.parentSessionId,
+        groupId,
+        agentRole,
+      });
+      return NextResponse.json({ session }, { status: 201 });
+    }
     const session = await spawnSession({
       project: String(project ?? ""),
       prompt,

package/app/api/loops/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { loopSummary } from "@/lib/loops";
+
+// GET /api/loops - the pill for every task that has had a loop in the last
+// day, by task id.
+export async function GET() {
+  const since = Date.now() - 24 * 60 * 60 * 1000;
+  const ids = db
+    .prepare(
+      `SELECT DISTINCT session_id FROM task_loops WHERE state = 'running' OR COALESCE(ended_at, 0) >= ?`
+    )
+    .all(since) as { session_id: string }[];
+  const loops: Record<string, ReturnType<typeof loopSummary>> = {};
+  for (const { session_id } of ids) loops[session_id] = loopSummary(session_id);
+  return NextResponse.json({ loops });
+}

package/app/api/models/availability/route.ts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from "next/server";
+import { modelAvailability } from "@/lib/models/availability-refs";
+
+// GET /api/models/availability?refresh=1 - whether each local model's
+// server answers now (ref to state). Cloud models aren't probed.
+export async function GET(request: NextRequest) {
+  const refresh = request.nextUrl.searchParams.has("refresh");
+  return NextResponse.json(await modelAvailability(refresh));
+}

package/app/api/models/choices/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+import { modelCatalog } from "@/lib/models/catalog";
+
+// GET /api/models/choices - every model a picker offers, from the server:
+// the enabled providers' models and the ones Pi reaches, each with its
+// locality (local or cloud) and the last availability check.
+export async function GET() {
+  return NextResponse.json({ choices: modelCatalog() });
+}

package/app/api/sessions/[id]/analyst/route.ts

@@ -0,0 +1,11 @@
+import { sessionLinkView } from "@/lib/analyst";
+import { run } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// GET /api/sessions/:id/analyst - the live pairing this session is in, as
+// coder or analyst, or null.
+export async function GET(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return run(() => ({ link: sessionLinkView(id) }));
+}

package/app/api/sessions/[id]/crew/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { crewMembers } from "@/lib/sessions/crew";
+import { modelCatalog } from "@/lib/models/catalog";
+
+type RouteParams = { params: Promise<{ id: string }> };
+
+// GET /api/sessions/:id/crew - the session's role and the sessions it works
+// with (same crew), each with its model and whether that is local or cloud.
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  const { id } = await params;
+  const row = db
+    .prepare(`SELECT agent_role, crew_id FROM session_rows WHERE id = ?`)
+    .get(id) as
+    { agent_role: string | null; crew_id: string | null } | undefined;
+  if (!row)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  const choices = new Map(modelCatalog().map((c) => [c.ref, c]));
+  const members = row.crew_id
+    ? crewMembers(row.crew_id).map((m) => {
+        const ref = m.model
+          ? `${m.agentType === "pi" ? "pi" : (m.modelProvider ?? "anthropic")}/${m.model}`
+          : null;
+        const choice = ref ? choices.get(ref) : undefined;
+        return {
+          ...m,
+          ref,
+          locality: choice?.locality ?? "cloud",
+          availability: choice?.availability.state ?? "unknown",
+        };
+      })
+    : [];
+  return NextResponse.json({
+    agentRole: row.agent_role,
+    crewId: row.crew_id,
+    members,
+  });
+}

package/app/api/sessions/[id]/export/estimate/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { parseExportRequest } from "@/lib/export/request";
+import { estimate } from "@/lib/export/service";
+import { readJson, refuseDemo, toResponse } from "@/lib/share/route";
+
+// POST /api/sessions/:id/export/estimate - what an export would hold: size,
+// tokens, the turns to pick from, and warnings. No file text.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const { id } = await params;
+    const req = parseExportRequest(read.body);
+    return NextResponse.json(await estimate(id, req));
+  } catch (err) {
+    return toResponse(err);
+  }
+}

package/app/api/sessions/[id]/export/route.test.ts

@@ -0,0 +1,125 @@
+import { randomUUID } from "crypto";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+
+process.env.AGENTOS_ARTIFACTS_DIR = tempDir("agentos-export-art-");
+const file = await import("./route");
+const estimate = await import("./estimate/route");
+const { saveItem } = await import("@/lib/chat/store");
+const { seedSession } = await import("@/lib/orchestrator/testing");
+const { createProject } = await import("@/lib/projects");
+
+const secret = ["gh", "p_", "c".repeat(36)].join("");
+const body = {
+  format: "md",
+  mode: "compact",
+  redact: "all",
+};
+
+const post = (b: unknown) =>
+  new Request("http://localhost/x", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(b),
+  });
+const params = (id: string) => ({ params: Promise.resolve({ id }) });
+
+function session(view: "chat" | "terminal" = "chat") {
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp/p",
+  });
+  const id = seedSession({ projectId: project.id, name: "Export me", view });
+  let t = 1;
+  const add = (i: Record<string, unknown>) =>
+    saveItem(id, { id: `x${t}`, createdAt: t++, ...i } as never);
+  add({ kind: "user", text: `key ${secret}` });
+  add({ kind: "assistant", text: "ok" });
+  add({ kind: "user", text: "second" });
+  add({ kind: "assistant", text: "done" });
+  return id;
+}
+
+afterEach(() => vi.unstubAllEnvs());
+
+describe("POST /api/sessions/:id/export", () => {
+  it("returns each format as a named download with size headers", async () => {
+    const id = session();
+    for (const [format, type, ext] of [
+      ["md", "text/markdown", "md"],
+      ["json", "application/json", "json"],
+      ["html", "text/html", "html"],
+    ]) {
+      const res = await file.POST(post({ ...body, format }), params(id));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain(type);
+      expect(res.headers.get("content-disposition")).toBe(
+        `attachment; filename="export-me-all.${ext}"`
+      );
+      expect(res.headers.get("cache-control")).toBe("no-store");
+      const text = await res.text();
+      expect(Number(res.headers.get("x-export-bytes"))).toBe(
+        Buffer.byteLength(text)
+      );
+      expect(Number(res.headers.get("x-export-tokens"))).toBeGreaterThan(0);
+      expect(text).not.toContain(secret);
+    }
+  });
+
+  it("exports a range and names it", async () => {
+    const id = session();
+    const res = await file.POST(
+      post({ ...body, range: { from: 2, to: 2 } }),
+      params(id)
+    );
+    expect(res.headers.get("content-disposition")).toContain("-turn-2.md");
+    const text = await res.text();
+    expect(text).toContain("second");
+    expect(text).not.toContain("## Turn 1");
+  });
+
+  it("404s an unknown session and 400s a terminal one", async () => {
+    expect((await file.POST(post(body), params("nope"))).status).toBe(404);
+    const res = await file.POST(post(body), params(session("terminal")));
+    expect(res.status).toBe(400);
+  });
+
+  it("400s a bad format, mode, redaction or range", async () => {
+    const id = session();
+    for (const bad of [
+      { ...body, format: "pdf" },
+      { ...body, mode: "tiny" },
+      { ...body, redact: "none" },
+      { ...body, range: { from: 0, to: 2 } },
+      { ...body, range: { from: 9, to: 12 } },
+      { ...body, range: { last: -1 } },
+    ])
+      expect((await file.POST(post(bad), params(id))).status).toBe(400);
+  });
+
+  it("refuses in the demo", async () => {
+    vi.stubEnv("AGENTOS_DEMO", "1");
+    const res = await file.POST(post(body), params(session()));
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("POST /api/sessions/:id/export/estimate", () => {
+  it("returns sizes, turns and warnings, and no body text", async () => {
+    const id = session();
+    const res = await estimate.POST(post(body), params(id));
+    expect(res.status).toBe(200);
+    const text = await res.text();
+    const j = JSON.parse(text);
+    expect(j.turns.map((t: { n: number }) => t.n)).toEqual([1, 2]);
+    expect(j.selected).toMatchObject({ from: 1, to: 2, of: 2, turns: 2 });
+    expect(j.estimate.compact.bytes).toBeGreaterThan(0);
+    expect(j.estimate.full.bytes).toBeGreaterThan(0);
+    expect(j.hits.secret).toBe(1);
+    expect(j.warnings.map((w: { code: string }) => w.code)).toContain(
+      "sensitive"
+    );
+    expect(text).not.toContain("done");
+    expect(text).not.toContain(secret);
+  });
+});

package/app/api/sessions/[id]/export/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { parseExportRequest } from "@/lib/export/request";
+import { buildFile } from "@/lib/export/service";
+import { TOO_BIG, exportFileName } from "@/lib/export/view";
+import { fail, readJson, refuseDemo, toResponse } from "@/lib/share/route";
+
+// POST /api/sessions/:id/export - the session (or a range of its turns) as a
+// Markdown, JSON or HTML file, redacted. Local work only.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const { id } = await params;
+    const req = parseExportRequest(read.body);
+    const file = await buildFile(id, req);
+    if (file.tooBig) return fail(TOO_BIG, 413);
+    return new NextResponse(file.body, {
+      headers: {
+        "Content-Type": file.contentType,
+        "Content-Disposition": `attachment; filename="${exportFileName(file.title, file.slug, req.format)}"`,
+        "Cache-Control": "no-store",
+        "X-Export-Bytes": String(file.bytes),
+        "X-Export-Tokens": String(file.tokens),
+      },
+    });
+  } catch (err) {
+    return toResponse(err);
+  }
+}

package/app/api/sessions/[id]/model/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "@/lib/db";
+import { setChatModel } from "@/lib/chat/settings";
+import { providerFor, sessionRole } from "@/lib/models/resolve";
+import { switchSessionModel } from "@/lib/models/session-model";
+import { PI } from "@/lib/models/providers";
+import { formatModelRef, parseModelRef } from "@/lib/models/roles";
+
+// POST /api/sessions/:id/model {ref} - move a running session to another
+// model ("provider/model", or "pi/<provider>/<model>" for a Pi session),
+// keeping its conversation.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const { ref } = (await request.json().catch(() => ({}))) as { ref?: unknown };
+  const session = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(id) as Session | undefined;
+  if (!session)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  if (typeof ref !== "string" || !ref.trim())
+    return NextResponse.json({ error: "ref is required" }, { status: 400 });
+  try {
+    const parsed = parseModelRef(ref);
+    if (session.agent_type === "pi") {
+      if (parsed.provider !== PI)
+        throw new Error(
+          "A Pi session runs on a Pi model (pi/<provider>/<model>)"
+        );
+      await setChatModel(id, parsed.model);
+    } else {
+      if (parsed.provider === PI)
+        throw new Error("Only a Pi session can move to a Pi model");
+      await switchSessionModel(id, {
+        role: sessionRole(session),
+        ref: formatModelRef(parsed),
+        provider: providerFor(parsed.provider),
+        model: parsed.model,
+        source: "task",
+      });
+    }
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}