@saadnvd1/agent-os 0.3.742 → 0.3.744

package/components/Analyst/PairChip.tsx

@@ -121,9 +121,16 @@ export function PairChip({
         <DropdownMenuSeparator />
         <DropdownMenuItem
           variant="destructive"
+          className="min-h-11"
           onSelect={() => end.mutate(true, { onError: fail })}
         >
-          Unlink and finish the analyst
+          <span className="flex flex-col gap-0.5">
+            <span>End analyst</span>
+            <span className="text-muted-foreground text-[11px] font-normal whitespace-normal">
+              Stops the reviews and moves the analyst to Done. Its conversation
+              is kept; nothing is deleted.
+            </span>
+          </span>
         </DropdownMenuItem>
       </DropdownMenuContent>
     </DropdownMenu>

package/lib/chat/demo.ts

@@ -7,10 +7,18 @@
 import { randomUUID } from "crypto";
 import { clientSend } from "./client-send";
 import type { ChatConversation } from "./driver";
-import type { ChatClientMessage, ChatServerMessage } from "./events";
+import type {
+  ChatClientMessage,
+  ChatServerMessage,
+  ChatState,
+  ModelWait,
+} from "./events";
 import { demoConversation } from "./drivers/demo";
+import { DEMO_SCRIPT_PROMPT, parseDemoScript } from "./drivers/demo-script";
+import { ModelWaitTracker } from "./model-wait";
+import type { WorkerEvent } from "./worker/protocol";
 import { emit, getSession } from "./registry";
-import { saveItem } from "./store";
+import { deleteItems, saveItem } from "./store";
 import { DEMO_REFUSAL, DEMO_VISITOR_TEXT } from "../security/demo";
 
 const conversations = new Map<string, ChatConversation>();
@@ -21,13 +29,34 @@ export const setDemoReplyStep = (ms: number) => (stepMs = ms);
 export const MAX_SENDS = 50;
 const sends = new Map<string, number>();
 
+// What a demo chat is doing, for a watcher that connects mid-turn (the stored
+// items alone would show a running step as stopped).
+const live = new Map<string, { state: ChatState; wait: ModelWait | null }>();
+
+/** The demo chat's running turn, or null with none. */
+export function demoLive(sessionId: string) {
+  return live.get(sessionId) ?? null;
+}
+
 function conversation(sessionId: string): ChatConversation {
   let c = conversations.get(sessionId);
   if (c) return c;
   c = demoConversation(stepMs);
   conversations.set(sessionId, c);
+  let tracker = new ModelWaitTracker();
   void (async () => {
     for await (const e of c.events) {
+      // Each turn follows its own waits, whatever the last one left.
+      if (e.type === "state" && e.state === "running")
+        tracker = new ModelWaitTracker();
+      if (tracker.on(e as WorkerEvent))
+        emit(sessionId, { type: "model_wait", wait: tracker.wait });
+      if (e.type === "state") {
+        if (e.state === "idle") live.delete(sessionId);
+        else live.set(sessionId, { state: e.state, wait: tracker.wait });
+      }
+      const state = live.get(sessionId);
+      if (state) state.wait = tracker.wait;
       if (e.type === "item") {
         if (!("streaming" in e.item && e.item.streaming))
           saveItem(sessionId, e.item);
@@ -49,16 +78,24 @@ export function sendDemoChat(
   const count = sends.get(sessionId) ?? 0;
   if (count >= MAX_SENDS) throw new Error(DEMO_REFUSAL);
   sends.set(sessionId, count + 1);
+  // The scripted turn (drivers/demo-script) is canned text a visitor can only
+  // trigger, never change, so its prompt is shown as is.
+  const script = parseDemoScript(trimmed) !== null;
+  // A scripted turn starts a clean chat, so screenshots never show the last.
+  if (script) {
+    deleteItems(sessionId);
+    live.delete(sessionId);
+  }
   const item = {
     id,
     kind: "user" as const,
-    text: DEMO_VISITOR_TEXT,
+    text: script ? DEMO_SCRIPT_PROMPT : DEMO_VISITOR_TEXT,
     tagged: true as const,
     createdAt: Date.now(),
   };
   saveItem(sessionId, item);
   emit(sessionId, { type: "item", item });
-  conversation(sessionId).send(DEMO_VISITOR_TEXT);
+  conversation(sessionId).send(script ? trimmed : DEMO_VISITOR_TEXT);
 }
 
 /** After a re-seed: stub conversations and send counts start over. */
@@ -69,6 +106,7 @@ export function resetDemoChat(): void {
     emit(sessionId, { type: "state", state: "idle" });
   }
   conversations.clear();
+  live.clear();
   sends.clear();
 }
 

package/lib/chat/drivers/demo-script.ts

@@ -0,0 +1,148 @@
+/**
+ * The demo's scripted running turn: typed into a demo chat, it holds a state
+ * a screenshot needs (a tool streaming partial output, a long wait on the
+ * model, a retry) for a set time, then finishes. Demo only: the demo driver
+ * is the one place that reads it (AGENTOS_DEMO=1; no real session gets here).
+ *
+ *     demo: running turn [step|wait|retry] [hold=<seconds>]
+ */
+
+import type { DriverEvent } from "../events";
+
+export type DemoPhase = "step" | "wait" | "retry";
+
+export interface DemoScript {
+  // Hold only this state; none runs all three, one after the other.
+  phase?: DemoPhase;
+  holdMs: number;
+}
+
+export const DEFAULT_HOLD_S = 30;
+export const MAX_HOLD_S = 120;
+const TRIGGER = /^demo: running turn(?: (step|wait|retry))?(?: hold=(\d+))?$/;
+
+export function parseDemoScript(text: string): DemoScript | null {
+  const m = TRIGGER.exec(text.trim());
+  if (!m) return null;
+  const seconds = m[2] === undefined ? DEFAULT_HOLD_S : Number(m[2]);
+  return {
+    phase: m[1] as DemoPhase | undefined,
+    holdMs: Math.min(seconds, MAX_HOLD_S) * 1000,
+  };
+}
+
+export const DEMO_SCRIPT_PROMPT =
+  "Run the checkout tests and fix whatever fails.";
+
+const COMMAND = "npx vitest run src/checkout";
+const LINES = [
+  " RUN  v3.2.4 ~/code/storefront",
+  " ✓ src/checkout/discount.test.ts (6 tests) 12ms",
+  " ✓ src/checkout/tax.test.ts (9 tests) 18ms",
+  " ✓ src/checkout/cart.test.ts (14 tests) 41ms",
+  " ✓ src/checkout/shipping.test.ts (8 tests) 22ms",
+  " ✓ src/checkout/coupons.test.ts (11 tests) 35ms",
+  " ✓ src/checkout/currency.test.ts (7 tests) 9ms",
+  " ❯ src/checkout/totals.test.ts (12 tests | 1 running)",
+];
+
+export interface ScriptRun {
+  push: (e: DriverEvent) => void;
+  stopped: () => boolean;
+  sleep: (ms: number) => Promise<void>;
+}
+
+// Waits `ms`, in slices so an interrupt ends it.
+async function hold(run: ScriptRun, ms: number) {
+  for (let left = ms; left > 0 && !run.stopped(); left -= 100)
+    await run.sleep(Math.min(100, left));
+}
+
+async function runningStep(run: ScriptRun, id: string, holdMs: number) {
+  const tool = {
+    id,
+    kind: "tool" as const,
+    name: "Bash",
+    title: COMMAND,
+    input: { command: COMMAND },
+    createdAt: Date.now(),
+  };
+  const show = (n: number) =>
+    run.push({
+      type: "item",
+      item: {
+        ...tool,
+        status: "running",
+        output: LINES.slice(0, Math.max(1, n)).join("\n"),
+      },
+    });
+  // A line every half second, then the last line stays until the hold ends.
+  const end = Date.now() + holdMs;
+  show(1);
+  for (let n = 2; n <= LINES.length && !run.stopped(); n++) {
+    if (Date.now() >= end) break;
+    await hold(run, 500);
+    show(n);
+  }
+  await hold(run, Math.max(0, end - Date.now()));
+  const stopped = run.stopped();
+  run.push({
+    type: "item",
+    item: {
+      ...tool,
+      status: stopped ? "stopped" : "done",
+      output: stopped
+        ? undefined
+        : `${LINES.slice(0, -1).join("\n")}\n 1 passed`,
+      endedAt: Date.now(),
+    },
+  });
+}
+
+export async function runDemoScript(
+  script: DemoScript,
+  run: ScriptRun,
+  runId = String(Date.now())
+): Promise<void> {
+  const started = Date.now();
+  const phases: DemoPhase[] = script.phase
+    ? [script.phase]
+    : ["step", "wait", "retry"];
+  run.push({ type: "state", state: "running" });
+  run.push({ type: "turn_start" });
+  run.push({
+    type: "item",
+    item: {
+      id: `demo-a-${runId}`,
+      kind: "assistant",
+      text: "I'll run the checkout tests first.",
+      createdAt: started,
+    },
+  });
+  run.push({ type: "prompt_tokens", tokens: 48_200 });
+  for (const phase of phases) {
+    if (run.stopped()) break;
+    if (phase === "step")
+      await runningStep(run, `demo-t-${runId}`, script.holdMs);
+    else {
+      if (phase === "retry")
+        run.push({
+          type: "model_retry",
+          attempt: 2,
+          message: "The model is overloaded",
+        });
+      await hold(run, script.holdMs);
+    }
+  }
+  run.push({
+    type: "item",
+    item: {
+      id: `demo-end-${runId}`,
+      kind: "turn_end",
+      durationMs: Date.now() - started,
+      interrupted: run.stopped() || undefined,
+      createdAt: Date.now(),
+    },
+  });
+  run.push({ type: "state", state: "idle" });
+}

package/lib/chat/drivers/demo.ts

@@ -1,16 +1,18 @@
 /**
  * The demo's stand-in for an agent (AGENTOS_DEMO=1): no process, no tools,
  * just a short canned reply streamed the way a real one is, so the chat
- * flow still works end to end.
+ * flow still works end to end. A typed `demo: running turn` runs the
+ * scripted turn in demo-script.ts instead.
  */
 
 import type { ChatConversation, ChatDriver } from "../driver";
 import type { DriverEvent } from "../events";
+import { parseDemoScript, runDemoScript, type DemoScript } from "./demo-script";
 
 export const DEMO_REPLY =
   "This is a demo, so agents don't run here. On your own machine, this is where the agent would answer and get to work.";
 
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
 // Events pushed by sends and read by one consumer, in order.
 function channel() {
@@ -89,12 +91,27 @@ export function demoConversation(stepMs = 40): ChatConversation {
     });
     out.push({ type: "state", state: "idle" });
   };
+  // A scripted turn that a newer one took over from says nothing more.
+  let generation = 0;
+  const script = async (s: DemoScript, mine: number) => {
+    if (closed) return;
+    stopped = false;
+    await runDemoScript(s, {
+      push: (e) => mine === generation && out.push(e),
+      stopped: () => stopped || closed,
+      sleep,
+    });
+  };
   const refuse = async () => {
     throw new Error("Not available in the demo.");
   };
   return {
-    send() {
-      turn = turn.then(reply);
+    send(text) {
+      const s = parseDemoScript(text);
+      // A scripted turn takes over from one still running.
+      const mine = s ? ++generation : generation;
+      if (s) stopped = true;
+      turn = turn.then(s ? () => script(s, mine) : reply);
       return undefined;
     },
     async interrupt() {

package/lib/chat/drivers/index.ts

@@ -6,7 +6,7 @@ import { openCodeDriver } from "./opencode";
 import { piDriver } from "./pi";
 import { copilotDriver } from "./copilot";
 import { demoDriver } from "./demo";
-import { demoMode } from "../../security/demo";
+import { demoChatMode, demoMode } from "../../security/demo";
 
 // One driver per agent CLI. Adding a CLI means a driver here and its agent
 // type in CHAT_AGENT_TYPES.
@@ -21,5 +21,5 @@ const DRIVERS: Record<(typeof CHAT_AGENT_TYPES)[number], ChatDriver> = {
 export function chatDriverFor(agentType: string): ChatDriver | null {
   const driver = DRIVERS[agentType as keyof typeof DRIVERS] ?? null;
   // A demo never starts a real agent (lib/chat/demo runs this one).
-  return driver && demoMode() ? demoDriver : driver;
+  return driver && (demoMode() || demoChatMode()) ? demoDriver : driver;
 }

package/lib/chat/runner-watch.ts

@@ -5,6 +5,7 @@ import { recentTasks, settle } from "./store";
 import { readPage, toolBody, type ItemPage } from "./page";
 import { listQueue } from "./queued";
 import { runningWorkers } from "./worker/client";
+import { demoLive } from "./demo";
 
 function savedContext(sessionId: string): ChatContext | null {
   const raw = getSession(sessionId).chat_context;
@@ -21,6 +22,7 @@ function savedContext(sessionId: string): ChatContext | null {
 function present(sessionId: string, items: ChatItem[]): ChatItem[] {
   const live = registry.live.get(sessionId);
   if (live) return items.map((i) => live.streaming.get(i.id) ?? i);
+  if (demoLive(sessionId)) return items;
   return runningWorkers().includes(sessionId) ? items : settle(items);
 }
 
@@ -28,6 +30,7 @@ function present(sessionId: string, items: ChatItem[]): ChatItem[] {
 // client gets the latest page and asks for older ones.
 export function watchChat(sessionId: string, listener: Listener): () => void {
   const live = registry.live.get(sessionId);
+  const demo = demoLive(sessionId);
   const page = readPage(sessionId);
   const onPage = new Set(page.items.map((i) => i.id));
   // The composer lists background work still going or just done, even when
@@ -40,9 +43,9 @@ export function watchChat(sessionId: string, listener: Listener): () => void {
     cursor: page.cursor,
     hasMore: page.hasMore,
     tasks: present(sessionId, tasks),
-    state: live?.state ?? "idle",
+    state: live?.state ?? demo?.state ?? "idle",
     compacting: live?.compacting ?? null,
-    modelWait: live?.modelWait ?? null,
+    modelWait: live?.modelWait ?? demo?.wait ?? null,
     queue: listQueue(sessionId),
     suggestion: getSession(sessionId).chat_suggestion ?? null,
   });

package/lib/security/demo.ts

@@ -23,6 +23,14 @@ type Env = Record<string, string | undefined>;
 
 export const demoMode = (env: Env = process.env) => env.AGENTOS_DEMO === "1";
 
+/**
+ * Only the chat is a stand-in (AGENTOS_DEMO_CHAT=1): the screenshot server's
+ * scripted turns (lib/chat/drivers/demo-script). The rest of the server is a
+ * normal one, so it is held to the same sandbox as the demo (server.ts).
+ */
+export const demoChatMode = (env: Env = process.env) =>
+  env.AGENTOS_DEMO_CHAT === "1";
+
 const within = (child: string, parent: string) => {
   const rel = path.relative(parent, child);
   return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));

package/lib/tasks/move-testing.ts

@@ -57,7 +57,12 @@ export function setupMoveRepo(): MoveFixture {
     restore: () => {
       process.env.HOME = saved.HOME;
       delete process.env.CLAUDE_CONFIG_DIR;
-      fs.rmSync(tmp, { recursive: true, force: true });
+      fs.rmSync(tmp, {
+        recursive: true,
+        force: true,
+        maxRetries: 5,
+        retryDelay: 100,
+      });
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.742",
+  "version": "0.3.744",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/screenshots/run.ts

@@ -5,6 +5,7 @@
  *     npm run screenshots              # everything
  *     npm run screenshots -- --keep    # leave the demo server up afterwards
  *     npm run screenshots -- --only hero,tasks
+ *     npm run screenshots -- --only running-turn   # a held running turn
  */
 import fs from "fs";
 import path from "path";
@@ -13,6 +14,7 @@ import { spawnServer } from "@/lib/dev-instance";
 import { BASE_URL, PORT, REPO, ROOT, demoEnv } from "./config";
 import { seed, teardownTmux } from "./seed";
 import { shoot } from "./shoot";
+import { SHOTS } from "./shots";
 import { frame } from "./frame";
 import { startPeer } from "./peer";
 
@@ -37,7 +39,7 @@ async function waitForServer(server: ChildProcess): Promise<void> {
   throw new Error(`Demo server did not answer on ${BASE_URL}`);
 }
 
-function startServer(): ChildProcess {
+function startServer(demoChat: boolean): ChildProcess {
   const log = fs.openSync(path.join(ROOT, "server.log"), "w");
   // Loopback only: the demo never listens on another network.
   return spawnServer({
@@ -49,6 +51,8 @@ function startServer(): ChildProcess {
       AGENTOS_BIND: "127.0.0.1",
       AGENTOS_ORCHESTRATOR: "off",
       AGENTOS_STACKS: "off",
+      // Scripted chat turns (lib/chat/drivers/demo-script), for on-demand shots.
+      ...(demoChat ? { AGENTOS_DEMO_CHAT: "1" } : {}),
     }),
     stdio: ["ignore", log, log],
     detached: true,
@@ -64,21 +68,41 @@ function stopServer(server: ChildProcess): void {
   }
 }
 
+// An on-demand shot has no README frame; its raw captures would go with the
+// demo root, so they are copied to .agentos/screenshots (git-ignored there).
+function keepOnDemand(raw: Awaited<ReturnType<typeof shoot>>): void {
+  const names = new Set(SHOTS.filter((s) => s.onDemand).map((s) => s.name));
+  const dir = path.join(process.cwd(), ".agentos", "screenshots");
+  for (const shot of raw) {
+    if (!names.has(shot.name)) continue;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(path.dirname(dir), ".gitignore"), "*\n");
+    for (const file of shot.files) {
+      fs.copyFileSync(file, path.join(dir, path.basename(file)));
+      console.log(`  .agentos/screenshots/${path.basename(file)}`);
+    }
+  }
+}
+
 async function main() {
   const only = arg("--only")?.split(",");
+  const onDemand = !!only?.some(
+    (n) => SHOTS.find((s) => s.name === n)?.onDemand
+  );
   const reuse = has("--reuse");
   let server: ChildProcess | null = null;
   const peer = reuse ? null : startPeer();
   try {
     if (!reuse) {
       console.log("Seeding demo data");
-      await seed();
+      await seed(onDemand);
       console.log(`Starting demo server on :${PORT}`);
-      server = startServer();
+      server = startServer(onDemand);
       await waitForServer(server);
     }
     console.log("Shooting");
     const raw = await shoot(only);
+    keepOnDemand(raw);
     console.log("Framing");
     await frame(raw);
   } finally {

package/scripts/screenshots/running-turn.ts

@@ -0,0 +1,54 @@
+import type { Page } from "playwright";
+import type { Part, Shot } from "./shots";
+
+// A running turn, held on screen by the demo's scripted turn
+// (lib/chat/drivers/demo-script): `npm run screenshots -- --only running-turn`.
+// Each part sends the trigger for one state and waits for it to show.
+
+const SESSION = "running-turn";
+const HOLD_S = 60;
+
+const PHASES = [
+  { phase: "step", marker: /npx vitest run src\/checkout/ },
+  { phase: "wait", marker: /Waiting for/ },
+  { phase: "retry", marker: /Retrying model request/ },
+] as const;
+
+async function startTurn(
+  page: Page,
+  phase: string,
+  marker: RegExp,
+  phone: boolean
+): Promise<void> {
+  if (phone) {
+    await page.locator("button:has(svg.lucide-menu)").first().click();
+    await page.waitForTimeout(800);
+  }
+  await page.getByText(SESSION, { exact: true }).first().click();
+  await page.waitForTimeout(2500);
+  await page.locator(".chat-composer [contenteditable]").first().click();
+  await page.keyboard.type(`demo: running turn ${phase} hold=${HOLD_S}`);
+  // Enter is a new line on a phone: the send button sends.
+  if (phone)
+    await page.locator("button:has(svg.lucide-arrow-up)").last().click();
+  else await page.keyboard.press("Enter");
+  await page.getByText(marker).first().waitFor({ timeout: 30000 });
+  await page.waitForTimeout(1500);
+}
+
+const parts = (device: Part["device"]): Part[] =>
+  PHASES.map(({ phase, marker }) => ({
+    id: `${phase}-${device}`,
+    device,
+    themes: ["dark", "light"],
+    keepFocus: true,
+    setup: (page) => startTurn(page, phase, marker, device === "phone"),
+  }));
+
+export const RUNNING_TURN_SHOTS: Shot[] = [
+  {
+    name: "running-turn",
+    onDemand: true,
+    parts: [...parts("desktop"), ...parts("phone")],
+  },
+];

package/scripts/screenshots/seed.ts

@@ -44,6 +44,9 @@ interface SessionSeed {
   minutesAgo: number;
   task?: { prompt: string; status: "running" | "merged"; branch: string };
   chat?: (start: number) => ChatItem[];
+  // Seeded only for the on-demand shots (shots.ts), so it never shows in the
+  // README's sidebar.
+  onDemand?: boolean;
 }
 
 const WORKSPACES = [
@@ -55,6 +58,14 @@ const WORKSPACES = [
 ];
 
 const SESSIONS: SessionSeed[] = [
+  {
+    key: "running",
+    name: "running-turn",
+    project: "storefront",
+    view: "chat",
+    minutesAgo: 1,
+    onDemand: true,
+  },
   {
     key: "checkout",
     name: "checkout-totals",
@@ -241,7 +252,7 @@ function tmux(args: string[]): void {
   execFileSync("tmux", demoTmuxArgs(args), { env: demoEnv(), stdio: "pipe" });
 }
 
-async function seedDb(): Promise<void> {
+async function seedDb(onDemand: boolean): Promise<void> {
   process.env.DB_PATH = DB_PATH;
   const { getDb, insertSessionRow } = await import("../../lib/db");
   const db = getDb();
@@ -266,6 +277,7 @@ async function seedDb(): Promise<void> {
   const sessionIds = new Map<string, string>();
   const now = Date.now();
   for (const s of SESSIONS) {
+    if (s.onDemand && !onDemand) continue;
     const id = randomUUID();
     sessionIds.set(s.key, id);
     const tmuxName = `claude-${id}`;
@@ -441,14 +453,14 @@ function seedLinkedMachine(db: Db): void {
   ).run(PEER_HOST.id, `http://127.0.0.1:${PEER_PORT}`);
 }
 
-export async function seed(): Promise<void> {
+export async function seed(onDemand = false): Promise<void> {
   teardownTmux();
   fs.rmSync(ROOT, { recursive: true, force: true });
   fs.mkdirSync(SCREENS, { recursive: true });
   fs.mkdirSync(TMUX_TMPDIR, { recursive: true, mode: 0o700 });
   writeHome();
   createRepos();
-  await seedDb();
+  await seedDb(onDemand);
   console.log(`  seeded ${DB_PATH}`);
 }
 

package/scripts/screenshots/shoot.ts

@@ -104,7 +104,9 @@ export async function shoot(only?: string[]): Promise<Raw[]> {
   const browser = await launch();
   const results: Raw[] = [];
   try {
-    for (const shot of SHOTS.filter((s) => !only || only.includes(s.name))) {
+    for (const shot of SHOTS.filter((s) =>
+      only ? only.includes(s.name) : !s.onDemand
+    )) {
       results.push({ name: shot.name, files: await take(browser, shot) });
     }
   } finally {

package/scripts/screenshots/shots.ts

@@ -1,4 +1,5 @@
 import type { Page } from "playwright";
+import { RUNNING_TURN_SHOTS } from "./running-turn";
 
 // Each shot is one or more raw captures; frame.ts composes them.
 export interface Part {
@@ -15,6 +16,9 @@ export interface Part {
 export interface Shot {
   name: string;
   parts: Part[];
+  // Only with --only <name>: it changes the demo (a session is added, a turn
+  // is started) and is not one of the README's pictures.
+  onDemand?: boolean;
 }
 
 const CHAT = "checkout-totals";
@@ -57,6 +61,7 @@ async function openDialog(page: Page, button: RegExp): Promise<void> {
 }
 
 export const SHOTS: Shot[] = [
+  ...RUNNING_TURN_SHOTS,
   {
     name: "hero",
     parts: [

package/server.ts

@@ -39,6 +39,7 @@ import {
   assertDemoSandbox,
   demoAllowsUpgrade,
   admitDemoSocket,
+  demoChatMode,
   demoMode,
   gateDemoRequest,
   refuseDemoUpgrade,
@@ -116,7 +117,9 @@ if (!live) {
 claimAgentosEnv(port);
 // Demo mode: seeded data, nothing that runs code (lib/security/demo).
 const demo = demoMode();
-if (demo) assertDemoSandbox();
+// The screenshot server's scripted chat turns: the sandbox, not the lockdown.
+const demoChat = demoChatMode();
+if (demo || demoChat) assertDemoSandbox();
 // Fixed for this process and handed to the chat workers it starts.
 buildId();
 if (!demo) {
@@ -252,7 +255,12 @@ app.prepare().then(async () => {
   });
   chatWss.on("connection", (ws: WebSocket, request: IncomingMessage) => {
     const params = new URL(request.url ?? "", "http://x").searchParams;
-    serveChatSocket(ws, params, (json) => sendBounded(ws, json), demo);
+    serveChatSocket(
+      ws,
+      params,
+      (json) => sendBounded(ws, json),
+      demo || demoChat
+    );
   });
 
   // Handle WebSocket upgrades