From 246a0ac6118b6a4b866346b0941aa438af4d8ae0 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 16:19:32 -0700
Subject: [PATCH 01/13] apps system phase 1: storage + daemon serving/watching
 + server routes + status app + bb app CLI

Per-thread Apps system foundation (no frontend yet): apps/<id>/ layout
(manifest.json + served assets/ + file-based data/ + logo.*), daemon-owned
asset serving + data/ watcher, server routes (entry/assets/icon/data CRUD/
message + WS relay on thread:<id>:app:<id>:data), injected window.bb bridge
(capability-gated, advisory for v1), default seeded `status` app, and
bb app new|list|open|rm. STATUS remains in place; teardown is Phase 3.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 apps/app/src/components/ui/icon.tsx           |    2 +
 apps/cli/src/__tests__/command-output.test.ts |  129 ++
 apps/cli/src/commands/app.ts                  |  283 ++++
 apps/cli/src/index.ts                         |    2 +
 .../src/app-data-change-reporter.test.ts      |  212 +++
 .../src/app-data-change-reporter.ts           |  384 ++++++
 apps/host-daemon/src/app-data-files.ts        |  280 ++++
 apps/host-daemon/src/app.ts                   |   15 +
 apps/host-daemon/src/command-dispatch.ts      |    5 +
 .../src/command-handlers/file-list.test.ts    |   21 +
 .../src/command-handlers/file-list.ts         |    1 +
 .../src/command-handlers/file-read.ts         |    3 +
 .../src/command-handlers/file-write.ts        |   73 +
 .../src/command-handlers/host-files.test.ts   |   45 +
 .../src/command-handlers/host-files.ts        |   11 +
 apps/host-daemon/src/command-router.ts        |   10 +-
 apps/host-daemon/src/runtime-manager.ts       |   23 +
 apps/host-daemon/src/server-client.ts         |   44 +
 apps/server/src/internal/app-data-changes.ts  |  110 ++
 .../src/internal/command-result-owners.ts     |    1 +
 apps/server/src/routes/relative-route-path.ts |   92 ++
 apps/server/src/routes/threads/apps.ts        | 1205 +++++++++++++++++
 apps/server/src/routes/threads/data.ts        |  126 +-
 apps/server/src/routes/threads/index.ts       |    2 +
 apps/server/src/server.ts                     |    2 +
 .../src/services/threads/app-client-script.ts |  445 ++++++
 .../apps/status/assets/index.html             |  273 ++++
 .../apps/status/data/state.json               |    7 +
 .../apps/status/manifest.json                 |    9 +
 .../threads/manager-storage-templates.ts      |   75 +-
 apps/server/src/ws/hub.ts                     |    9 +
 apps/server/test/app/hub.test.ts              |   46 +
 .../internal/internal-app-data-change.test.ts |  173 +++
 .../test/public/public-thread-apps.test.ts    |  851 ++++++++++++
 .../threads/app-client-script.test.ts         |  204 +++
 .../threads/manager-storage-templates.test.ts |   47 +-
 packages/domain/src/apps.ts                   |   52 +
 packages/domain/src/index.ts                  |    3 +
 packages/host-daemon-contract/src/commands.ts |   21 +-
 packages/host-daemon-contract/src/index.ts    |    9 +
 packages/host-daemon-contract/src/session.ts  |   83 ++
 .../test/contract.test.ts                     |   87 ++
 .../host-watcher/src/host-watcher-types.ts    |   16 +-
 .../host-watcher/src/parcel-host-watcher.ts   |   55 +-
 .../test/thread-storage-watch.test.ts         |   44 +
 packages/server-contract/src/api-types.ts     |  299 +++-
 packages/server-contract/src/index.ts         |   48 +
 packages/server-contract/src/public-api.ts    |   41 +
 .../server-contract/test/contract.test.ts     |   75 +
 49 files changed, 5935 insertions(+), 118 deletions(-)
 create mode 100644 apps/cli/src/commands/app.ts
 create mode 100644 apps/host-daemon/src/app-data-change-reporter.test.ts
 create mode 100644 apps/host-daemon/src/app-data-change-reporter.ts
 create mode 100644 apps/host-daemon/src/app-data-files.ts
 create mode 100644 apps/server/src/internal/app-data-changes.ts
 create mode 100644 apps/server/src/routes/relative-route-path.ts
 create mode 100644 apps/server/src/routes/threads/apps.ts
 create mode 100644 apps/server/src/services/threads/app-client-script.ts
 create mode 100644 apps/server/src/services/threads/default-template/apps/status/assets/index.html
 create mode 100644 apps/server/src/services/threads/default-template/apps/status/data/state.json
 create mode 100644 apps/server/src/services/threads/default-template/apps/status/manifest.json
 create mode 100644 apps/server/test/internal/internal-app-data-change.test.ts
 create mode 100644 apps/server/test/public/public-thread-apps.test.ts
 create mode 100644 apps/server/test/services/threads/app-client-script.test.ts
 create mode 100644 packages/domain/src/apps.ts

diff --git a/apps/app/src/components/ui/icon.tsx b/apps/app/src/components/ui/icon.tsx
index 1a8ee25ae..d0d07da61 100644
--- a/apps/app/src/components/ui/icon.tsx
+++ b/apps/app/src/components/ui/icon.tsx
@@ -40,6 +40,7 @@ import {
   FolderRemoveIcon,
   GitBranchIcon,
   GitMergeIcon,
+  GridViewIcon,
   InformationCircleIcon,
   LaptopIcon,
   LayoutTwoColumnIcon,
@@ -103,6 +104,7 @@ const ICON_MAP = {
   FolderPlus: FolderAddIcon,
   GitBranch: GitBranchIcon,
   GitMerge: GitMergeIcon,
+  GridView: GridViewIcon,
   Info: InformationCircleIcon,
   Laptop: LaptopIcon,
   ListTodo: CheckListIcon,
diff --git a/apps/cli/src/__tests__/command-output.test.ts b/apps/cli/src/__tests__/command-output.test.ts
index 2ccc34be0..b64008599 100644
--- a/apps/cli/src/__tests__/command-output.test.ts
+++ b/apps/cli/src/__tests__/command-output.test.ts
@@ -44,6 +44,7 @@ vi.mock("../daemon.js", () => ({
 
 import { createClient, unwrap } from "../client.js";
 import { fetchLocalHostId } from "../daemon.js";
+import { registerAppCommands } from "../commands/app.js";
 import { registerEnvironmentCommands } from "../commands/environment.js";
 import { registerGuideCommand } from "../commands/guide.js";
 import { registerHostCommands } from "../commands/host.js";
@@ -1176,6 +1177,134 @@ describe("CLI command output contracts", () => {
     ]);
   });
 
+  it("bb app list renders resolved app summaries", async () => {
+    vi.stubEnv("BB_THREAD_ID", "thr_current");
+    const apps = [
+      {
+        id: "status",
+        name: "Status",
+        entry: { path: "index.html", kind: "html" },
+        capabilities: ["data", "message"],
+        icon: { kind: "builtin", name: "ListTodo" },
+      },
+      {
+        id: "demo",
+        name: "Demo",
+        entry: { path: "readme.md", kind: "md" },
+        capabilities: [],
+        icon: {
+          kind: "logo",
+          url: "/api/v1/threads/thr_current/apps/demo/icon",
+        },
+      },
+    ];
+    const get = vi.fn(async () => apps);
+    createClientMock.mockReturnValue(
+      asServerClient({
+        api: {
+          v1: {
+            threads: {
+              ":id": {
+                apps: {
+                  $get: get,
+                },
+              },
+            },
+          },
+        },
+      }),
+    );
+
+    await runCommand(["app", "list"], (program) =>
+      registerAppCommands(program, () => "http://server"),
+    );
+
+    expect(get).toHaveBeenCalledWith({ param: { id: "thr_current" } });
+    expect(collectLogPayloads(vi.mocked(console.log))).toEqual([
+      "ID                        Name                      Entry                     Capabilities              Icon\n------------------------  ------------------------  ------------------------  ------------------------  ------------------\nstatus                    Status                    html:index.html           data,message              ListTodo\n------------------------  ------------------------  ------------------------  ------------------------  ------------------\ndemo                      Demo                      md:readme.md              -                         logo",
+    ]);
+  });
+
+  it("bb app new targets the current thread and posts the selected template", async () => {
+    vi.stubEnv("BB_THREAD_ID", "thr_current");
+    const created = {
+      id: "demo",
+      name: "Demo",
+      entry: { path: "index.html", kind: "html" },
+      capabilities: ["data", "message"],
+      icon: { kind: "builtin", name: "ListTodo" },
+    };
+    const post = vi.fn(async () => created);
+    createClientMock.mockReturnValue(
+      asServerClient({
+        api: {
+          v1: {
+            threads: {
+              ":id": {
+                apps: {
+                  $post: post,
+                },
+              },
+            },
+          },
+        },
+      }),
+    );
+
+    await runCommand(
+      ["app", "new", "demo", "--template", "status"],
+      (program) => registerAppCommands(program, () => "http://server"),
+    );
+
+    expect(post).toHaveBeenCalledWith({
+      param: { id: "thr_current" },
+      json: { id: "demo", name: "demo", template: "status" },
+    });
+    expect(collectLogPayloads(vi.mocked(console.log))).toEqual([
+      "App created: demo",
+      "  Name:         Demo",
+      "  Entry:        html:index.html",
+      "  Capabilities: data,message",
+      "  Icon:         ListTodo",
+    ]);
+  });
+
+  it("bb app new derives a valid id from a display name", async () => {
+    vi.stubEnv("BB_THREAD_ID", "thr_current");
+    const created = {
+      id: "my-app",
+      name: "My App",
+      entry: { path: "index.html", kind: "html" },
+      capabilities: ["data"],
+      icon: { kind: "builtin", name: "GridView" },
+    };
+    const post = vi.fn(async () => created);
+    createClientMock.mockReturnValue(
+      asServerClient({
+        api: {
+          v1: {
+            threads: {
+              ":id": {
+                apps: {
+                  $post: post,
+                },
+              },
+            },
+          },
+        },
+      }),
+    );
+
+    await runCommand(["app", "new", "My App"], (program) =>
+      registerAppCommands(program, () => "http://server"),
+    );
+
+    expect(post).toHaveBeenCalledWith({
+      param: { id: "thr_current" },
+      json: { id: "my-app", name: "My App", template: "blank" },
+    });
+  });
+
   it("bb manager status includes managed child threads", async () => {
     const managerThread: Thread = makeThread({
       id: "thread-manager-1",
diff --git a/apps/cli/src/commands/app.ts b/apps/cli/src/commands/app.ts
new file mode 100644
index 000000000..28552c8e8
--- /dev/null
+++ b/apps/cli/src/commands/app.ts
@@ -0,0 +1,283 @@
+import { Command } from "commander";
+import { appIdSchema, type AppId } from "@bb/domain";
+import type {
+  AppDetail,
+  AppIcon,
+  AppSummary,
+  AppTemplate,
+  CreateThreadAppRequest,
+} from "@bb/server-contract";
+import { appTemplateSchema } from "@bb/server-contract";
+import { action } from "../action.js";
+import { createClient, unwrap } from "../client.js";
+import { renderBorderlessTable } from "../table.js";
+import {
+  confirmDestructiveAction,
+  outputJson,
+  printContextLabel,
+  requireThreadIdWithLabelOrSelf,
+} from "./helpers.js";
+
+type ResolveServerUrl = () => string;
+
+interface AppThreadCommandOptions {
+  json?: boolean;
+  self?: boolean;
+}
+
+interface AppNewCommandOptions extends AppThreadCommandOptions {
+  id?: string;
+  template?: string;
+}
+
+interface AppRemoveCommandOptions extends AppThreadCommandOptions {
+  yes?: boolean;
+}
+
+interface ResolveAppCommandThreadArgs {
+  options: AppThreadCommandOptions;
+  threadId: string | undefined;
+}
+
+interface AppOpenPayload {
+  app: AppDetail;
+  threadId: string;
+  url: string;
+}
+
+interface ResolveNewAppIdArgs {
+  id: string | undefined;
+  name: string;
+}
+
+function parseAppTemplate(value: string | undefined): AppTemplate {
+  const parsed = appTemplateSchema.safeParse(value ?? "blank");
+  if (!parsed.success) {
+    throw new Error("Invalid app template. Expected 'blank' or 'status'.");
+  }
+  return parsed.data;
+}
+
+function resolveAppCommandThread(args: ResolveAppCommandThreadArgs): string {
+  const resolved = requireThreadIdWithLabelOrSelf(
+    args.threadId,
+    args.options,
+  );
+  printContextLabel(resolved, "Thread", "BB_THREAD_ID", args.options);
+  return resolved.id;
+}
+
+function slugifyAppName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/gu, "-")
+    .replace(/-+/gu, "-")
+    .replace(/^-|-$/gu, "");
+}
+
+function resolveNewAppId(args: ResolveNewAppIdArgs): AppId {
+  const candidate = args.id ?? slugifyAppName(args.name);
+  const parsed = appIdSchema.safeParse(candidate);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  if (args.id !== undefined) {
+    throw new Error(
+      "Invalid app id. Use letters, numbers, underscores, or hyphens.",
+    );
+  }
+  throw new Error(
+    `Could not derive a valid app id from "${args.name}". Pass --id with letters, numbers, underscores, or hyphens.`,
+  );
+}
+
+function appUrl(baseUrl: string, threadId: string, appId: string): string {
+  return `${baseUrl.replace(/\/$/u, "")}/api/v1/threads/${encodeURIComponent(
+    threadId,
+  )}/apps/${encodeURIComponent(appId)}/`;
+}
+
+function formatIcon(icon: AppIcon): string {
+  return icon.kind === "builtin" ? icon.name : "logo";
+}
+
+function printAppsTable(apps: AppSummary[]): void {
+  if (apps.length === 0) {
+    console.log("No apps");
+    return;
+  }
+  console.log(
+    renderBorderlessTable(
+      {
+        head: ["ID", "Name", "Entry", "Capabilities", "Icon"],
+        colWidths: [24, 24, 24, 24, 18],
+        trimTrailingWhitespace: true,
+      },
+      apps.map((app) => [
+        app.id,
+        app.name,
+        `${app.entry.kind}:${app.entry.path}`,
+        app.capabilities.join(",") || "-",
+        formatIcon(app.icon),
+      ]),
+    ),
+  );
+}
+
+function printAppDetail(app: AppDetail): void {
+  console.log(`App created: ${app.id}`);
+  console.log(`  Name:         ${app.name}`);
+  console.log(`  Entry:        ${app.entry.kind}:${app.entry.path}`);
+  console.log(`  Capabilities: ${app.capabilities.join(",") || "-"}`);
+  console.log(`  Icon:         ${formatIcon(app.icon)}`);
+}
+
+export function registerAppCommands(
+  program: Command,
+  getUrl: ResolveServerUrl,
+): void {
+  const app = program.command("app").description("Manage thread apps");
+
+  app
+    .command("new <name> [threadId]")
+    .description("Create a new app in a thread")
+    .option("--id <appId>", "App id. Defaults to a slug derived from name.")
+    .option("--template <template>", "App template: blank or status", "blank")
+    .option("--self", "Target BB_THREAD_ID explicitly")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(
+        async (
+          name: string,
+          threadIdArg: string | undefined,
+          opts: AppNewCommandOptions,
+        ) => {
+          const threadId = resolveAppCommandThread({
+            threadId: threadIdArg,
+            options: opts,
+          });
+          const template = parseAppTemplate(opts.template);
+          const client = createClient(getUrl());
+          const request: CreateThreadAppRequest = {
+            id: resolveNewAppId({ id: opts.id, name }),
+            name,
+            template,
+          };
+          const created = await unwrap<AppDetail>(
+            client.api.v1.threads[":id"].apps.$post({
+              param: { id: threadId },
+              json: request,
+            }),
+          );
+          if (outputJson(opts, created)) return;
+          printAppDetail(created);
+        },
+      ),
+    );
+
+  app
+    .command("list [threadId]")
+    .description("List apps in a thread")
+    .option("--self", "Target BB_THREAD_ID explicitly")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(
+        async (
+          threadIdArg: string | undefined,
+          opts: AppThreadCommandOptions,
+        ) => {
+          const threadId = resolveAppCommandThread({
+            threadId: threadIdArg,
+            options: opts,
+          });
+          const client = createClient(getUrl());
+          const apps = await unwrap<AppSummary[]>(
+            client.api.v1.threads[":id"].apps.$get({
+              param: { id: threadId },
+            }),
+          );
+          if (outputJson(opts, apps)) return;
+          printAppsTable(apps);
+        },
+      ),
+    );
+
+  app
+    .command("open <name> [threadId]")
+    .description("Print an app URL")
+    .option("--self", "Target BB_THREAD_ID explicitly")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(
+        async (
+          name: string,
+          threadIdArg: string | undefined,
+          opts: AppThreadCommandOptions,
+        ) => {
+          const threadId = resolveAppCommandThread({
+            threadId: threadIdArg,
+            options: opts,
+          });
+          const baseUrl = getUrl();
+          const client = createClient(baseUrl);
+          const appDetail = await unwrap<AppDetail>(
+            client.api.v1.threads[":id"].apps[":appId"].$get({
+              param: { id: threadId, appId: name },
+            }),
+          );
+          const payload: AppOpenPayload = {
+            threadId,
+            app: appDetail,
+            url: appUrl(baseUrl, threadId, appDetail.id),
+          };
+          if (outputJson(opts, payload)) return;
+          console.log(payload.url);
+        },
+      ),
+    );
+
+  app
+    .command("rm <name> [threadId]")
+    .description("Remove an app from a thread")
+    .option("--yes", "Skip the confirmation prompt")
+    .option("--self", "Target BB_THREAD_ID explicitly")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(
+        async (
+          name: string,
+          threadIdArg: string | undefined,
+          opts: AppRemoveCommandOptions,
+        ) => {
+          const threadId = resolveAppCommandThread({
+            threadId: threadIdArg,
+            options: opts,
+          });
+          const client = createClient(getUrl());
+          const appDetail = await unwrap<AppDetail>(
+            client.api.v1.threads[":id"].apps[":appId"].$get({
+              param: { id: threadId, appId: name },
+            }),
+          );
+          if (!opts.yes) {
+            const confirmed = await confirmDestructiveAction(
+              `Remove app "${appDetail.name}" from thread ${threadId}? This cannot be undone.`,
+            );
+            if (!confirmed) {
+              console.log(`App ${name} removal cancelled`);
+              return;
+            }
+          }
+          await unwrap<{ ok: true }>(
+            client.api.v1.threads[":id"].apps[":appId"].$delete({
+              param: { id: threadId, appId: name },
+            }),
+          );
+          const payload = { ok: true, threadId, appId: name };
+          if (outputJson(opts, payload)) return;
+          console.log(`App ${name} removed`);
+        },
+      ),
+    );
+}
diff --git a/apps/cli/src/index.ts b/apps/cli/src/index.ts
index f3a4e472f..0cf62003a 100644
--- a/apps/cli/src/index.ts
+++ b/apps/cli/src/index.ts
@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import { registerAppCommands } from "./commands/app.js";
 import { registerEnvironmentCommands } from "./commands/environment.js";
 import { registerGuideCommand } from "./commands/guide.js";
 import { registerHostCommands } from "./commands/host.js";
@@ -65,6 +66,7 @@ registerProjectCommands(program, getUrl);
 registerHostCommands(program, getUrl);
 registerProviderCommands(program, getUrl);
 registerManagerCommands(program, getUrl);
+registerAppCommands(program, getUrl);
 registerThreadCommands(program, getUrl);
 registerReplayCommands(program, getUrl);
 registerEnvironmentCommands(program, getUrl);
diff --git a/apps/host-daemon/src/app-data-change-reporter.test.ts b/apps/host-daemon/src/app-data-change-reporter.test.ts
new file mode 100644
index 000000000..51efe18d7
--- /dev/null
+++ b/apps/host-daemon/src/app-data-change-reporter.test.ts
@@ -0,0 +1,212 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { HostDaemonAppDataChangePayload } from "@bb/host-daemon-contract";
+import type { HostDaemonLogger } from "./logger.js";
+import { AppDataChangeReporter } from "./app-data-change-reporter.js";
+
+const tempDirs: string[] = [];
+
+async function makeTempDir(prefix: string): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function writeJsonFile(filePath: string, value: object): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function createLogger(): HostDaemonLogger {
+  return {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
+}
+
+afterEach(async () => {
+  await Promise.all(
+    tempDirs.splice(0).map(async (dir) => {
+      await fs.rm(dir, { recursive: true, force: true });
+    }),
+  );
+});
+
+describe("AppDataChangeReporter", () => {
+  it("posts changed app data values and suppresses duplicate versions", async () => {
+    const rootPath = await makeTempDir("bb-app-data-reporter-");
+    const statePath = path.join(
+      rootPath,
+      "apps",
+      "status",
+      "data",
+      "state.json",
+    );
+    const posted: HostDaemonAppDataChangePayload[] = [];
+    const reporter = new AppDataChangeReporter({
+      logger: createLogger(),
+      postAppDataChange: async (payload) => {
+        posted.push(payload);
+      },
+      postAppDataResync: async () => undefined,
+    });
+
+    await writeJsonFile(statePath, { workers: [] });
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+
+    expect(posted).toHaveLength(1);
+    expect(posted[0]).toMatchObject({
+      appId: "status",
+      threadId: "thr_one",
+      path: "state.json",
+      deleted: false,
+      value: { workers: [] },
+    });
+    expect(posted[0]?.version).toMatch(/^[a-f0-9]{64}$/u);
+  });
+
+  it("posts deleted events after observed files are removed", async () => {
+    const rootPath = await makeTempDir("bb-app-data-reporter-delete-");
+    const statePath = path.join(
+      rootPath,
+      "apps",
+      "status",
+      "data",
+      "state.json",
+    );
+    const posted: HostDaemonAppDataChangePayload[] = [];
+    const reporter = new AppDataChangeReporter({
+      logger: createLogger(),
+      postAppDataChange: async (payload) => {
+        posted.push(payload);
+      },
+      postAppDataResync: async () => undefined,
+    });
+
+    await writeJsonFile(statePath, { workers: [] });
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+    await fs.rm(statePath);
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+
+    expect(posted).toHaveLength(2);
+    expect(posted[1]).toEqual({
+      appId: "status",
+      threadId: "thr_one",
+      path: "state.json",
+      deleted: true,
+      value: null,
+      version: null,
+    });
+  });
+
+  it("re-primes tracked threads and posts resync hints after reconnect", async () => {
+    const rootPath = await makeTempDir("bb-app-data-reporter-reprime-");
+    const statePath = path.join(
+      rootPath,
+      "apps",
+      "status",
+      "data",
+      "state.json",
+    );
+    const posted: HostDaemonAppDataChangePayload[] = [];
+    const resyncs: Array<{ appId: string; threadId: string }> = [];
+    const reporter = new AppDataChangeReporter({
+      logger: createLogger(),
+      postAppDataChange: async (payload) => {
+        posted.push(payload);
+      },
+      postAppDataResync: async (payload) => {
+        resyncs.push(payload);
+      },
+    });
+
+    await writeJsonFile(statePath, { workers: [] });
+    await reporter.replaceTrackedThreads({
+      targets: [{ threadId: "thr_one", threadStoragePath: rootPath }],
+    });
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+
+    expect(resyncs).toEqual([{ appId: "status", threadId: "thr_one" }]);
+    expect(posted).toHaveLength(0);
+
+    await writeJsonFile(statePath, { workers: [{ id: "worker-1" }] });
+    await reporter.observe({
+      appId: "status",
+      path: "state.json",
+      threadId: "thr_one",
+      threadStoragePath: rootPath,
+    });
+
+    expect(posted).toHaveLength(1);
+    expect(posted[0]).toMatchObject({
+      appId: "status",
+      threadId: "thr_one",
+      path: "state.json",
+      deleted: false,
+      value: { workers: [{ id: "worker-1" }] },
+    });
+  });
+
+  it("posts resync hints for apps whose data disappeared while disconnected", async () => {
+    const rootPath = await makeTempDir("bb-app-data-reporter-delete-resync-");
+    const statePath = path.join(
+      rootPath,
+      "apps",
+      "status",
+      "data",
+      "state.json",
+    );
+    const resyncs: Array<{ appId: string; threadId: string }> = [];
+    const reporter = new AppDataChangeReporter({
+      logger: createLogger(),
+      postAppDataChange: async () => undefined,
+      postAppDataResync: async (payload) => {
+        resyncs.push(payload);
+      },
+    });
+
+    await writeJsonFile(statePath, { workers: [] });
+    await reporter.replaceTrackedThreads({
+      targets: [{ threadId: "thr_one", threadStoragePath: rootPath }],
+    });
+    await fs.rm(statePath);
+    await reporter.replaceTrackedThreads({
+      targets: [{ threadId: "thr_one", threadStoragePath: rootPath }],
+    });
+
+    expect(resyncs).toEqual([
+      { appId: "status", threadId: "thr_one" },
+      { appId: "status", threadId: "thr_one" },
+    ]);
+  });
+});
diff --git a/apps/host-daemon/src/app-data-change-reporter.ts b/apps/host-daemon/src/app-data-change-reporter.ts
new file mode 100644
index 000000000..eea40c909
--- /dev/null
+++ b/apps/host-daemon/src/app-data-change-reporter.ts
@@ -0,0 +1,384 @@
+import type { HostDaemonAppDataChangePayload } from "@bb/host-daemon-contract";
+import {
+  appDataPathSchema,
+  appIdSchema,
+  type AppDataPath,
+  type AppId,
+} from "@bb/domain";
+import { CommandDispatchError } from "./command-dispatch-support.js";
+import { runtimeErrorLogFields } from "./error-utils.js";
+import type { HostDaemonLogger } from "./logger.js";
+import {
+  listThreadAppDataFromRoot,
+  readAppDataFromRoot,
+  type ThreadAppDataEntry,
+} from "./app-data-files.js";
+
+interface CreateAppDataChangeReporterOptions {
+  logger: HostDaemonLogger;
+  postAppDataChange: (
+    payload: HostDaemonAppDataChangePayload,
+  ) => Promise<void>;
+  postAppDataResync: (payload: AppDataResyncPayload) => Promise<void>;
+}
+
+interface AppDataCacheEntry {
+  version: string;
+}
+
+interface AppDataResyncPayload {
+  appId: AppId;
+  threadId: string;
+}
+
+interface AppDataCacheKeyArgs {
+  appId: AppId;
+  path: AppDataPath;
+  threadId: string;
+}
+
+interface ReportObservedDeleteArgs extends AppDataCacheKeyArgs {
+  generation: number;
+}
+
+interface ReportObservedChangeArgs {
+  change: ObserveAppDataChangeArgs;
+  generation: number;
+}
+
+interface AppDataReporterGenerationArgs {
+  generation: number;
+}
+
+interface TrackedAppDataThread {
+  threadId: string;
+  threadStoragePath: string;
+}
+
+interface ReplaceTrackedAppDataThreadsArgs {
+  targets: readonly TrackedAppDataThread[];
+}
+
+interface ReprimeThreadArgs {
+  generation: number;
+  target: TrackedAppDataThread;
+}
+
+interface ApplyThreadSnapshotArgs extends ReprimeThreadArgs {
+  snapshotEntries: readonly ThreadAppDataEntry[];
+  snapshotAppIds: readonly AppId[];
+}
+
+interface CachedAppDataKey {
+  appId: AppId;
+  cacheKey: string;
+  path: AppDataPath;
+}
+
+export interface ObserveAppDataChangeArgs {
+  appId: AppId;
+  path: AppDataPath;
+  threadId: string;
+  threadStoragePath: string;
+}
+
+function appDataCacheKey(args: AppDataCacheKeyArgs): string {
+  return `${args.threadId}\0${args.appId}\0${args.path}`;
+}
+
+function isMissingAppDataEntryError(error: Error): boolean {
+  return error instanceof CommandDispatchError && error.code === "ENOENT";
+}
+
+function isNonReportableAppDataReadError(error: Error): boolean {
+  return (
+    error instanceof CommandDispatchError &&
+    (error.code === "invalid_json" ||
+      error.code === "invalid_path" ||
+      error.code === "file_too_large")
+  );
+}
+
+export class AppDataChangeReporter {
+  private readonly cache = new Map<string, AppDataCacheEntry>();
+  private readonly appIdsByThreadId = new Map<string, Set<AppId>>();
+  private readonly pendingByCacheKey = new Map<string, Promise<void>>();
+  private readonly trackedThreadIds = new Set<string>();
+  private generation = 0;
+
+  constructor(private readonly options: CreateAppDataChangeReporterOptions) {}
+
+  async replaceTrackedThreads(
+    args: ReplaceTrackedAppDataThreadsArgs,
+  ): Promise<void> {
+    this.generation += 1;
+    const generation = this.generation;
+    const nextThreadIds = new Set(
+      args.targets.map((target) => target.threadId),
+    );
+    this.replaceTrackedThreadIds(nextThreadIds);
+    this.pendingByCacheKey.clear();
+    await Promise.all(
+      args.targets.map((target) =>
+        this.reprimeThread({
+          generation,
+          target,
+        }),
+      ),
+    );
+  }
+
+  observe(args: ObserveAppDataChangeArgs): Promise<void> {
+    this.trackApp({
+      appId: args.appId,
+      threadId: args.threadId,
+    });
+    const cacheKey = appDataCacheKey(args);
+    const generation = this.generation;
+    const previous = this.pendingByCacheKey.get(cacheKey) ?? Promise.resolve();
+    const pending = previous
+      .catch(() => undefined)
+      .then(() =>
+        this.reportObservedChange({
+          change: args,
+          generation,
+        }),
+      )
+      .catch((error) => {
+        this.options.logger.warn(
+          {
+            appId: args.appId,
+            path: args.path,
+            threadId: args.threadId,
+            ...runtimeErrorLogFields(error),
+          },
+          "Failed to report observed app data change",
+        );
+      })
+      .finally(() => {
+        if (this.pendingByCacheKey.get(cacheKey) === pending) {
+          this.pendingByCacheKey.delete(cacheKey);
+        }
+      });
+    this.pendingByCacheKey.set(cacheKey, pending);
+    return pending;
+  }
+
+  private isCurrentGeneration(args: AppDataReporterGenerationArgs): boolean {
+    return args.generation === this.generation;
+  }
+
+  private replaceTrackedThreadIds(threadIds: ReadonlySet<string>): void {
+    for (const threadId of Array.from(this.trackedThreadIds)) {
+      if (threadIds.has(threadId)) {
+        continue;
+      }
+      this.trackedThreadIds.delete(threadId);
+      this.appIdsByThreadId.delete(threadId);
+      for (const cached of this.cachedKeysForThread({ threadId })) {
+        this.cache.delete(cached.cacheKey);
+      }
+    }
+    for (const threadId of threadIds) {
+      this.trackedThreadIds.add(threadId);
+    }
+  }
+
+  private trackApp(args: AppDataResyncPayload): void {
+    this.trackedThreadIds.add(args.threadId);
+    let appIds = this.appIdsByThreadId.get(args.threadId);
+    if (!appIds) {
+      appIds = new Set<AppId>();
+      this.appIdsByThreadId.set(args.threadId, appIds);
+    }
+    appIds.add(args.appId);
+  }
+
+  private cachedKeysForThread(args: {
+    threadId: string;
+  }): CachedAppDataKey[] {
+    const prefix = `${args.threadId}\0`;
+    return Array.from(this.cache.keys())
+      .filter((cacheKey) => cacheKey.startsWith(prefix))
+      .map((cacheKey) => {
+        const [, rawAppId, rawDataPath] = cacheKey.split("\0");
+        return {
+          appId: appIdSchema.parse(rawAppId),
+          path: appDataPathSchema.parse(rawDataPath),
+          cacheKey,
+        };
+      });
+  }
+
+  private async reprimeThread(args: ReprimeThreadArgs): Promise<void> {
+    try {
+      const snapshot = await listThreadAppDataFromRoot({
+        rootPath: args.target.threadStoragePath,
+      });
+      if (!this.isCurrentGeneration({ generation: args.generation })) {
+        return;
+      }
+      const previousAppIds = new Set(
+        this.appIdsByThreadId.get(args.target.threadId) ?? [],
+      );
+      await this.applyThreadSnapshot({
+        ...args,
+        snapshotEntries: snapshot.entries,
+        snapshotAppIds: snapshot.appIds,
+      });
+      const resyncAppIds = new Set<AppId>([
+        ...previousAppIds,
+        ...snapshot.appIds,
+      ]);
+      await Promise.all(
+        Array.from(resyncAppIds)
+          .sort((left, right) => left.localeCompare(right))
+          .map((appId) =>
+            this.postResyncHint({
+              appId,
+              threadId: args.target.threadId,
+            }),
+          ),
+      );
+    } catch (error) {
+      this.options.logger.warn(
+        {
+          threadId: args.target.threadId,
+          threadStoragePath: args.target.threadStoragePath,
+          ...runtimeErrorLogFields(error),
+        },
+        "Failed to reprime app data change cache",
+      );
+    }
+  }
+
+  private async applyThreadSnapshot(
+    args: ApplyThreadSnapshotArgs,
+  ): Promise<void> {
+    const seenCacheKeys = new Set<string>();
+    const appIds = new Set<AppId>(args.snapshotAppIds);
+    for (const snapshotEntry of args.snapshotEntries) {
+      if (!this.isCurrentGeneration({ generation: args.generation })) {
+        return;
+      }
+      appIds.add(snapshotEntry.appId);
+      const cacheKey = appDataCacheKey({
+        appId: snapshotEntry.appId,
+        path: snapshotEntry.entry.path,
+        threadId: args.target.threadId,
+      });
+      seenCacheKeys.add(cacheKey);
+      this.cache.set(cacheKey, { version: snapshotEntry.entry.version });
+    }
+    this.appIdsByThreadId.set(args.target.threadId, appIds);
+    for (const cached of this.cachedKeysForThread({
+      threadId: args.target.threadId,
+    })) {
+      if (!seenCacheKeys.has(cached.cacheKey)) {
+        this.cache.delete(cached.cacheKey);
+      }
+    }
+  }
+
+  private async postResyncHint(args: AppDataResyncPayload): Promise<void> {
+    try {
+      await this.options.postAppDataResync(args);
+    } catch (error) {
+      this.options.logger.warn(
+        {
+          appId: args.appId,
+          threadId: args.threadId,
+          ...runtimeErrorLogFields(error),
+        },
+        "Failed to report app data resync hint",
+      );
+    }
+  }
+
+  private async reportObservedChange(
+    args: ReportObservedChangeArgs,
+  ): Promise<void> {
+    if (!this.isCurrentGeneration({ generation: args.generation })) {
+      return;
+    }
+    const cacheKey = appDataCacheKey(args.change);
+    const previous = this.cache.get(cacheKey);
+
+    try {
+      const entry = await readAppDataFromRoot({
+        appId: args.change.appId,
+        path: args.change.path,
+        rootPath: args.change.threadStoragePath,
+      });
+      if (!this.isCurrentGeneration({ generation: args.generation })) {
+        return;
+      }
+      if (previous?.version === entry.version) {
+        return;
+      }
+      await this.options.postAppDataChange({
+        appId: args.change.appId,
+        threadId: args.change.threadId,
+        path: entry.path,
+        deleted: false,
+        value: entry.value,
+        version: entry.version,
+      });
+      if (!this.isCurrentGeneration({ generation: args.generation })) {
+        return;
+      }
+      this.trackApp({
+        appId: args.change.appId,
+        threadId: args.change.threadId,
+      });
+      this.cache.set(cacheKey, { version: entry.version });
+    } catch (error) {
+      if (error instanceof Error && isMissingAppDataEntryError(error)) {
+        await this.reportObservedDelete({
+          appId: args.change.appId,
+          generation: args.generation,
+          path: args.change.path,
+          threadId: args.change.threadId,
+        });
+        return;
+      }
+      if (error instanceof Error && isNonReportableAppDataReadError(error)) {
+        this.options.logger.warn(
+          {
+            appId: args.change.appId,
+            path: args.change.path,
+            threadId: args.change.threadId,
+            ...runtimeErrorLogFields(error),
+          },
+          "Ignoring unreadable observed app data file",
+        );
+        return;
+      }
+      throw error;
+    }
+  }
+
+  private async reportObservedDelete(
+    args: ReportObservedDeleteArgs,
+  ): Promise<void> {
+    if (!this.isCurrentGeneration({ generation: args.generation })) {
+      return;
+    }
+    await this.options.postAppDataChange({
+      appId: args.appId,
+      threadId: args.threadId,
+      path: args.path,
+      deleted: true,
+      value: null,
+      version: null,
+    });
+    if (!this.isCurrentGeneration({ generation: args.generation })) {
+      return;
+    }
+    this.trackApp({
+      appId: args.appId,
+      threadId: args.threadId,
+    });
+    this.cache.delete(appDataCacheKey(args));
+  }
+}
diff --git a/apps/host-daemon/src/app-data-files.ts b/apps/host-daemon/src/app-data-files.ts
new file mode 100644
index 000000000..39d320046
--- /dev/null
+++ b/apps/host-daemon/src/app-data-files.ts
@@ -0,0 +1,280 @@
+import { createHash } from "node:crypto";
+import type { Stats } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  appDataPathSchema,
+  appIdSchema,
+  jsonValueSchema,
+  type AppDataPath,
+  type AppId,
+  type JsonValue,
+} from "@bb/domain";
+import {
+  CommandDispatchError,
+  ExpectedCommandDispatchError,
+} from "./command-dispatch-support.js";
+import { isFsErrorWithCode } from "./fs-errors.js";
+import { NON_IMAGE_FILE_SIZE_LIMIT_BYTES } from "./command-handlers/file-read.js";
+import { resolveNonSymlinkDirectoryPath } from "./command-handlers/root-path.js";
+
+export interface AppDataEntry {
+  modifiedAtMs: number;
+  path: AppDataPath;
+  sizeBytes: number;
+  value: JsonValue;
+  version: string;
+}
+
+export interface ThreadAppDataEntry {
+  appId: AppId;
+  entry: AppDataEntry;
+}
+
+export interface ThreadAppDataSnapshot {
+  appIds: AppId[];
+  entries: ThreadAppDataEntry[];
+}
+
+interface AppDataTargetArgs {
+  appId: AppId;
+  path: AppDataPath;
+  rootPath: string;
+}
+
+interface ResolveAppDataRootArgs {
+  appId: AppId;
+  rootPath: string;
+}
+
+interface ReadAppDataJsonArgs {
+  bytes: Buffer;
+  path: AppDataPath;
+}
+
+interface ListAppDataFilesArgs {
+  appDataRoot: string;
+  currentDirectory: string;
+}
+
+interface ListThreadAppDataArgs {
+  rootPath: string;
+}
+
+function sha256(bytes: Buffer): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function isPathWithinRoot(candidatePath: string, rootPath: string): boolean {
+  const relativePath = path.relative(rootPath, candidatePath);
+  return (
+    relativePath === "" ||
+    (!relativePath.startsWith("..") && !path.isAbsolute(relativePath))
+  );
+}
+
+function createFileTooLargeError(stat: Stats): CommandDispatchError {
+  return new CommandDispatchError(
+    "file_too_large",
+    `File size ${stat.size} bytes exceeds the ${Math.floor(NON_IMAGE_FILE_SIZE_LIMIT_BYTES / (1024 * 1024))} MB limit`,
+  );
+}
+
+function parseJsonValue(args: ReadAppDataJsonArgs): JsonValue {
+  try {
+    return jsonValueSchema.parse(JSON.parse(args.bytes.toString("utf8")));
+  } catch {
+    throw new CommandDispatchError(
+      "invalid_json",
+      `App data path ${args.path} does not contain valid JSON`,
+    );
+  }
+}
+
+async function resolveAppDataRoot(
+  args: ResolveAppDataRootArgs,
+): Promise<string> {
+  const appId = appIdSchema.parse(args.appId);
+  if (!path.isAbsolute(args.rootPath)) {
+    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
+  }
+  const threadStoragePath = await resolveNonSymlinkDirectoryPath({
+    description: "Thread storage root",
+    path: args.rootPath,
+  });
+  const appDataPath = path.join(threadStoragePath, "apps", appId, "data");
+  const resolvedAppDataPath = await resolveNonSymlinkDirectoryPath({
+    description: "App data directory",
+    path: appDataPath,
+  });
+  if (!isPathWithinRoot(resolvedAppDataPath, threadStoragePath)) {
+    throw new CommandDispatchError(
+      "invalid_path",
+      "App data path escapes thread storage root",
+    );
+  }
+  return resolvedAppDataPath;
+}
+
+export async function readAppDataFromRoot(
+  args: AppDataTargetArgs,
+): Promise<AppDataEntry> {
+  const appDataPath = appDataPathSchema.parse(args.path);
+  let appDataRoot: string;
+  try {
+    appDataRoot = await resolveAppDataRoot({
+      appId: args.appId,
+      rootPath: args.rootPath,
+    });
+  } catch (error) {
+    if (isFsErrorWithCode(error, "ENOENT")) {
+      throw new ExpectedCommandDispatchError(
+        "ENOENT",
+        `Path does not exist: ${appDataPath}`,
+      );
+    }
+    throw error;
+  }
+  const filePath = path.join(appDataRoot, ...appDataPath.split("/"));
+  let stat;
+  try {
+    stat = await fs.lstat(filePath);
+  } catch (error) {
+    if (isFsErrorWithCode(error, "ENOENT")) {
+      throw new ExpectedCommandDispatchError(
+        "ENOENT",
+        `Path does not exist: ${appDataPath}`,
+      );
+    }
+    throw error;
+  }
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    throw new CommandDispatchError(
+      "invalid_path",
+      `App data path ${appDataPath} is not a regular file`,
+    );
+  }
+  if (stat.size > NON_IMAGE_FILE_SIZE_LIMIT_BYTES) {
+    throw createFileTooLargeError(stat);
+  }
+
+  const bytes = await fs.readFile(filePath);
+  return {
+    modifiedAtMs: stat.mtimeMs,
+    path: appDataPath,
+    sizeBytes: stat.size,
+    value: parseJsonValue({ bytes, path: appDataPath }),
+    version: sha256(bytes),
+  };
+}
+
+async function listAppDataFilePaths(
+  args: ListAppDataFilesArgs,
+): Promise<AppDataPath[]> {
+  const entries = await fs.readdir(args.currentDirectory, {
+    withFileTypes: true,
+  });
+  const paths: AppDataPath[] = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const entryPath = path.join(args.currentDirectory, entry.name);
+    if (entry.isDirectory()) {
+      paths.push(
+        ...(await listAppDataFilePaths({
+          appDataRoot: args.appDataRoot,
+          currentDirectory: entryPath,
+        })),
+      );
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const relativePath = path
+      .relative(args.appDataRoot, entryPath)
+      .split(path.sep)
+      .join("/");
+    const parsed = appDataPathSchema.safeParse(relativePath);
+    if (parsed.success) {
+      paths.push(parsed.data);
+    }
+  }
+  return paths.sort((left, right) => left.localeCompare(right));
+}
+
+export async function listThreadAppDataFromRoot(
+  args: ListThreadAppDataArgs,
+): Promise<ThreadAppDataSnapshot> {
+  if (!path.isAbsolute(args.rootPath)) {
+    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
+  }
+  const threadStoragePath = await resolveNonSymlinkDirectoryPath({
+    description: "Thread storage root",
+    path: args.rootPath,
+  });
+  const appsRoot = path.join(threadStoragePath, "apps");
+  let appDirectories;
+  try {
+    appDirectories = await fs.readdir(appsRoot, { withFileTypes: true });
+  } catch (error) {
+    if (isFsErrorWithCode(error, "ENOENT")) {
+      return { appIds: [], entries: [] };
+    }
+    throw error;
+  }
+
+  const appIds: AppId[] = [];
+  const snapshotEntries: ThreadAppDataEntry[] = [];
+  for (const directory of appDirectories) {
+    if (!directory.isDirectory()) {
+      continue;
+    }
+    const parsedAppId = appIdSchema.safeParse(directory.name);
+    if (!parsedAppId.success) {
+      continue;
+    }
+    const appId = parsedAppId.data;
+    appIds.push(appId);
+    const appDataRoot = path.join(appsRoot, appId, "data");
+    let resolvedAppDataRoot;
+    try {
+      resolvedAppDataRoot = await resolveNonSymlinkDirectoryPath({
+        description: "App data directory",
+        path: appDataRoot,
+      });
+    } catch (error) {
+      if (isFsErrorWithCode(error, "ENOENT")) {
+        continue;
+      }
+      throw error;
+    }
+    const dataPaths = await listAppDataFilePaths({
+      appDataRoot: resolvedAppDataRoot,
+      currentDirectory: resolvedAppDataRoot,
+    });
+    for (const dataPath of dataPaths) {
+      snapshotEntries.push({
+        appId,
+        entry: await readAppDataFromRoot({
+          appId,
+          path: dataPath,
+          rootPath: threadStoragePath,
+        }),
+      });
+    }
+  }
+
+  appIds.sort((left, right) => left.localeCompare(right));
+  snapshotEntries.sort((left, right) => {
+    const appOrder = left.appId.localeCompare(right.appId);
+    return appOrder === 0
+      ? left.entry.path.localeCompare(right.entry.path)
+      : appOrder;
+  });
+  return {
+    appIds,
+    entries: snapshotEntries,
+  };
+}
diff --git a/apps/host-daemon/src/app.ts b/apps/host-daemon/src/app.ts
index 677e8fdb8..96d248d82 100644
--- a/apps/host-daemon/src/app.ts
+++ b/apps/host-daemon/src/app.ts
@@ -34,6 +34,7 @@ import {
 } from "./terminals/terminal-manager.js";
 import { createReplayCaptureService } from "@bb/replay-capture/writer";
 import { createServerClient } from "./server-client.js";
+import { AppDataChangeReporter } from "./app-data-change-reporter.js";
 import { StatusDataChangeReporter } from "./status-data-change-reporter.js";
 import {
   ServerConnection,
@@ -377,6 +378,11 @@ export async function createHostDaemonApp(
     postStatusDataChange: (payload) =>
       serverClient.postStatusDataChange(payload),
   });
+  const appDataChangeReporter = new AppDataChangeReporter({
+    logger: options.logger,
+    postAppDataChange: (payload) => serverClient.postAppDataChange(payload),
+    postAppDataResync: (payload) => serverClient.postAppDataResync(payload),
+  });
 
   function buildInteractiveInterruptKey(
     request: PendingInteractiveInterruptRequest,
@@ -549,6 +555,9 @@ export async function createHostDaemonApp(
     onThreadStatusDataChanged: (change) => {
       void statusDataChangeReporter.observe(change);
     },
+    onThreadAppDataChanged: (change) => {
+      void appDataChangeReporter.observe(change);
+    },
     onThreadStorageWatchError: ({ error }) => {
       options.logger.warn(
         {
@@ -754,6 +763,12 @@ export async function createHostDaemonApp(
           threadStoragePath: path.join(threadStorageRootPath, target.threadId),
         })),
       });
+      void appDataChangeReporter.replaceTrackedThreads({
+        targets: session.trackedThreadTargets.map((target) => ({
+          threadId: target.threadId,
+          threadStoragePath: path.join(threadStorageRootPath, target.threadId),
+        })),
+      });
       void eventBuffer.flush().catch((error) => {
         options.logger.warn(
           {
diff --git a/apps/host-daemon/src/command-dispatch.ts b/apps/host-daemon/src/command-dispatch.ts
index 604dcf5c1..fa9c3f2c8 100644
--- a/apps/host-daemon/src/command-dispatch.ts
+++ b/apps/host-daemon/src/command-dispatch.ts
@@ -21,6 +21,7 @@ import {
   listHostFiles,
   listHostPaths,
   deleteHostRelativeFile,
+  deleteHostRelativePath,
   readHostFile,
   readHostFileMetadata,
   readHostRelativeFile,
@@ -341,6 +342,10 @@ const commandHandlers: CommandHandlerMap = {
     command: Extract<HostDaemonCommand, { type: "host.delete_file_relative" }>,
     _options: CommandDispatchOptions,
   ) => deleteHostRelativeFile(command),
+  "host.delete_path_relative": async (
+    command: Extract<HostDaemonCommand, { type: "host.delete_path_relative" }>,
+    _options: CommandDispatchOptions,
+  ) => deleteHostRelativePath(command),
   "provider.list": async (
     _command: Extract<HostDaemonCommand, { type: "provider.list" }>,
     options: CommandDispatchOptions,
diff --git a/apps/host-daemon/src/command-handlers/file-list.test.ts b/apps/host-daemon/src/command-handlers/file-list.test.ts
index 4b6a84592..5ea132ca9 100644
--- a/apps/host-daemon/src/command-handlers/file-list.test.ts
+++ b/apps/host-daemon/src/command-handlers/file-list.test.ts
@@ -236,6 +236,27 @@ describe("listPathsRecursively", () => {
     }
   });
 
+  it("does not return symlinked files as regular path entries", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "bb-file-list-"));
+    try {
+      await fs.writeFile(path.join(root, "state.json"), "{}");
+      await fs.symlink(path.join(root, "state.json"), path.join(root, "logo.svg"));
+
+      const result = await listPathsRecursively({
+        dir: root,
+        root,
+        includeFiles: true,
+        includeDirectories: false,
+      });
+
+      expect(result).toEqual([
+        { kind: "file", path: "state.json", name: "state.json" },
+      ]);
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
   it("normalizes Windows separators before returning paths", () => {
     expect(normalizeListedPath("src\\components\\Button.tsx")).toBe(
       "src/components/Button.tsx",
diff --git a/apps/host-daemon/src/command-handlers/file-list.ts b/apps/host-daemon/src/command-handlers/file-list.ts
index 14d93e0a3..1f1c96bde 100644
--- a/apps/host-daemon/src/command-handlers/file-list.ts
+++ b/apps/host-daemon/src/command-handlers/file-list.ts
@@ -142,6 +142,7 @@ export async function listPathsRecursively(
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
     if (entry.name === "node_modules") continue;
+    if (entry.isSymbolicLink()) continue;
 
     const fullPath = path.join(args.dir, entry.name);
     const relativePath = normalizeListedPath(
diff --git a/apps/host-daemon/src/command-handlers/file-read.ts b/apps/host-daemon/src/command-handlers/file-read.ts
index 93ce37c84..e80e26bde 100644
--- a/apps/host-daemon/src/command-handlers/file-read.ts
+++ b/apps/host-daemon/src/command-handlers/file-read.ts
@@ -20,6 +20,7 @@ export interface ReadFileForTransportResult {
   content: string;
   contentEncoding: FileContentEncoding;
   mimeType?: string;
+  modifiedAtMs?: number;
   path: string;
   sizeBytes: number;
 }
@@ -325,6 +326,7 @@ export async function readFileForTransport(
         : fileContents.toString("base64"),
     contentEncoding,
     ...(mimeType ? { mimeType } : {}),
+    modifiedAtMs: stat.mtimeMs,
     sizeBytes: stat.size,
   };
 }
@@ -370,6 +372,7 @@ export async function readRootRelativeFileForTransport(
         : fileContents.toString("base64"),
     contentEncoding,
     ...(mimeType ? { mimeType } : {}),
+    modifiedAtMs: stat.mtimeMs,
     sizeBytes: stat.size,
   };
 }
diff --git a/apps/host-daemon/src/command-handlers/file-write.ts b/apps/host-daemon/src/command-handlers/file-write.ts
index 539d402fa..d2e37f964 100644
--- a/apps/host-daemon/src/command-handlers/file-write.ts
+++ b/apps/host-daemon/src/command-handlers/file-write.ts
@@ -68,6 +68,11 @@ interface DeleteRootRelativeFileResult {
   previousHash: string | null;
 }
 
+interface DeleteRootRelativePathResult {
+  deleted: boolean;
+  path: string;
+}
+
 function validateRootRelativeWritePath(
   args: ValidateRootRelativeWritePathArgs,
 ): ValidatedRootRelativeWritePath {
@@ -138,6 +143,9 @@ async function ensureWritableRoot(rootPath: string): Promise<string> {
 async function resolveWritableTarget(
   args: ResolveWritableTargetArgs,
 ): Promise<ResolvedWritableTarget> {
+  if (!path.isAbsolute(args.rootPath)) {
+    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
+  }
   const realRootPath = await ensureWritableRoot(args.rootPath);
   const absolutePath = path.join(realRootPath, ...args.relativePath.segments);
   const parentPath = path.dirname(absolutePath);
@@ -260,3 +268,68 @@ export async function deleteRootRelativeFile(
     previousHash: existing.hash,
   };
 }
+
+export async function deleteRootRelativePath(
+  args: DeleteRootRelativeFileArgs,
+): Promise<DeleteRootRelativePathResult> {
+  const relativePath = validateRootRelativeWritePath({
+    relativePath: args.relativePath,
+    dotfiles: args.dotfiles,
+  });
+  if (!path.isAbsolute(args.rootPath)) {
+    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
+  }
+  let realRootPath: string;
+  try {
+    realRootPath = await resolveNonSymlinkDirectoryPath({
+      description: "Root path",
+      path: args.rootPath,
+    });
+  } catch (error) {
+    if (isFsErrorWithCode(error, "ENOENT")) {
+      return {
+        path: relativePath.resultPath,
+        deleted: false,
+      };
+    }
+    throw error;
+  }
+  const targetPath = path.join(realRootPath, ...relativePath.segments);
+  const parentPath = path.dirname(targetPath);
+  const realParentPath = await resolveNonSymlinkDirectoryPath({
+    description: "Parent path",
+    path: parentPath,
+  });
+  if (!isPathWithinRoot(realParentPath, realRootPath)) {
+    throw new CommandDispatchError(
+      "invalid_path",
+      `Path "${relativePath.resultPath}" escapes delete root`,
+    );
+  }
+  const confinedPath = path.join(realParentPath, path.basename(targetPath));
+
+  let stat;
+  try {
+    stat = await fs.lstat(confinedPath);
+  } catch (error) {
+    if (isFsErrorWithCode(error, "ENOENT")) {
+      return {
+        path: relativePath.resultPath,
+        deleted: false,
+      };
+    }
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    throw new CommandDispatchError(
+      "invalid_path",
+      "Path is a symlink, not a directory or file",
+    );
+  }
+
+  await fs.rm(confinedPath, { recursive: stat.isDirectory(), force: true });
+  return {
+    path: relativePath.resultPath,
+    deleted: true,
+  };
+}
diff --git a/apps/host-daemon/src/command-handlers/host-files.test.ts b/apps/host-daemon/src/command-handlers/host-files.test.ts
index 7d3704eed..c19278b5e 100644
--- a/apps/host-daemon/src/command-handlers/host-files.test.ts
+++ b/apps/host-daemon/src/command-handlers/host-files.test.ts
@@ -17,6 +17,7 @@ import {
   readHostStatusVersion,
   writeHostRelativeFile,
   deleteHostRelativeFile,
+  deleteHostRelativePath,
 } from "./host-files.js";
 
 const execFileAsync = promisify(execFile);
@@ -426,6 +427,50 @@ describe("writeHostRelativeFile and deleteHostRelativeFile", () => {
       previousHash: null,
     });
   });
+
+  it("deletes directories recursively beneath the root", async () => {
+    const rootPath = await makeTempDir("bb-host-relative-delete-dir-");
+    await fs.mkdir(path.join(rootPath, "apps", "demo", "assets"), {
+      recursive: true,
+    });
+    await fs.writeFile(
+      path.join(rootPath, "apps", "demo", "manifest.json"),
+      "{}\n",
+      "utf8",
+    );
+    await fs.writeFile(
+      path.join(rootPath, "apps", "demo", "assets", "index.html"),
+      "<h1>Demo</h1>",
+      "utf8",
+    );
+
+    await expect(
+      deleteHostRelativePath({
+        type: "host.delete_path_relative",
+        rootPath: path.join(rootPath, "apps"),
+        path: "demo",
+        dotfiles: "deny",
+      }),
+    ).resolves.toEqual({
+      path: "demo",
+      deleted: true,
+    });
+    await expect(
+      fs.stat(path.join(rootPath, "apps", "demo")),
+    ).rejects.toMatchObject({ code: "ENOENT" });
+
+    await expect(
+      deleteHostRelativePath({
+        type: "host.delete_path_relative",
+        rootPath: path.join(rootPath, "apps"),
+        path: "demo",
+        dotfiles: "deny",
+      }),
+    ).resolves.toEqual({
+      path: "demo",
+      deleted: false,
+    });
+  });
 });
 
 describe("readHostStatusVersion", () => {
diff --git a/apps/host-daemon/src/command-handlers/host-files.ts b/apps/host-daemon/src/command-handlers/host-files.ts
index 82e3492b7..2b766b3ab 100644
--- a/apps/host-daemon/src/command-handlers/host-files.ts
+++ b/apps/host-daemon/src/command-handlers/host-files.ts
@@ -17,6 +17,7 @@ import {
 } from "./file-read.js";
 import {
   deleteRootRelativeFile,
+  deleteRootRelativePath,
   writeRootRelativeFile,
 } from "./file-write.js";
 import { resolveNonSymlinkDirectoryPath } from "./root-path.js";
@@ -189,3 +190,13 @@ export async function deleteHostRelativeFile(
     dotfiles: command.dotfiles,
   });
 }
+
+export async function deleteHostRelativePath(
+  command: CommandOf<"host.delete_path_relative">,
+): Promise<HostDaemonCommandResult<"host.delete_path_relative">> {
+  return deleteRootRelativePath({
+    rootPath: command.rootPath,
+    relativePath: command.path,
+    dotfiles: command.dotfiles,
+  });
+}
diff --git a/apps/host-daemon/src/command-router.ts b/apps/host-daemon/src/command-router.ts
index aa2b1a7bd..c5c7fe678 100644
--- a/apps/host-daemon/src/command-router.ts
+++ b/apps/host-daemon/src/command-router.ts
@@ -39,7 +39,12 @@ interface EnvironmentLaneState {
 
 type FileWriteLaneCommand = Extract<
   HostDaemonCommandEnvelope["command"],
-  { type: "host.write_file_relative" | "host.delete_file_relative" }
+  {
+    type:
+      | "host.write_file_relative"
+      | "host.delete_file_relative"
+      | "host.delete_path_relative";
+  }
 >;
 type StatusDataSetCommand = Extract<
   HostDaemonCommand,
@@ -555,7 +560,8 @@ export class CommandRouter {
   ): command is FileWriteLaneCommand {
     return (
       command.type === "host.write_file_relative" ||
-      command.type === "host.delete_file_relative"
+      command.type === "host.delete_file_relative" ||
+      command.type === "host.delete_path_relative"
     );
   }
 
diff --git a/apps/host-daemon/src/runtime-manager.ts b/apps/host-daemon/src/runtime-manager.ts
index 2e05148a0..5cbf76498 100644
--- a/apps/host-daemon/src/runtime-manager.ts
+++ b/apps/host-daemon/src/runtime-manager.ts
@@ -7,6 +7,8 @@ import {
   type AgentRuntimeProcessExitInfo,
 } from "@bb/agent-runtime";
 import type {
+  AppDataPath,
+  AppId,
   PendingInteractionCreate,
   PendingInteractionResolution,
   StatusDataKey,
@@ -159,6 +161,14 @@ export interface ThreadStatusDataChangedNotification {
   threadStoragePath: string;
 }
 
+export interface ThreadAppDataChangedNotification {
+  appId: AppId;
+  environmentId: string;
+  path: AppDataPath;
+  threadId: string;
+  threadStoragePath: string;
+}
+
 export interface EnsureEnvironmentArgs {
   environmentId: string;
   personalWorkspaceRoot?: string;
@@ -190,6 +200,7 @@ export interface RuntimeManagerOptions {
   onThreadStatusDataChanged?: (
     args: ThreadStatusDataChangedNotification,
   ) => void;
+  onThreadAppDataChanged?: (args: ThreadAppDataChangedNotification) => void;
   onThreadStorageWatchError?: (args: {
     error: ThreadStorageWatchError;
   }) => void;
@@ -926,6 +937,18 @@ export class RuntimeManager {
               ),
             });
           }
+          if (event.kind === "thread-app-data-changed") {
+            this.options.onThreadAppDataChanged?.({
+              appId: event.appId,
+              environmentId: event.environmentId,
+              path: event.path,
+              threadId: event.threadId,
+              threadStoragePath: path.join(
+                threadStorageRootPath,
+                event.threadId,
+              ),
+            });
+          }
         },
         onWatchError: (error) => {
           this.options.onThreadStorageWatchError?.({
diff --git a/apps/host-daemon/src/server-client.ts b/apps/host-daemon/src/server-client.ts
index c574166dc..eefa04231 100644
--- a/apps/host-daemon/src/server-client.ts
+++ b/apps/host-daemon/src/server-client.ts
@@ -6,6 +6,8 @@ import {
   hostDaemonCommandResultResponseSchema,
   hostDaemonCommandResultReportSchema,
   hostDaemonCommandsQuerySchema,
+  hostDaemonAppDataChangeRequestSchema,
+  hostDaemonAppDataResyncRequestSchema,
   hostDaemonEnvironmentChangeRequestSchema,
   hostDaemonEventBatchRequestSchema,
   hostDaemonEventBatchResponseSchema,
@@ -23,6 +25,8 @@ import {
   type HostDaemonInteractiveInterruptResponse,
   type HostDaemonInteractiveRequestResponse,
   type HostDaemonActiveThread,
+  type HostDaemonAppDataChangePayload,
+  type HostDaemonAppDataResyncPayload,
   type HostDaemonCommandEnvelope,
   type HostDaemonCommandResultReportWithoutSession,
   type HostDaemonEventEnvelope,
@@ -229,6 +233,8 @@ export interface ServerClient {
   postStatusDataChange(
     args: HostDaemonStatusDataChangePayload,
   ): Promise<void>;
+  postAppDataChange(args: HostDaemonAppDataChangePayload): Promise<void>;
+  postAppDataResync(args: HostDaemonAppDataResyncPayload): Promise<void>;
   postEvents(events: HostDaemonEventEnvelope[]): Promise<EventPostResult>;
   callTool(request: ToolCallRequest): Promise<HostDaemonToolCallResponse>;
   registerInteractiveRequest(
@@ -675,6 +681,44 @@ export function createServerClient(
       }
     },
 
+    async postAppDataChange(args): Promise<void> {
+      const payload = hostDaemonAppDataChangeRequestSchema.parse({
+        sessionId: requireSessionId(),
+        ...args,
+      });
+      const response = await fetchFn(
+        buildInternalUrl("/session/app-data-change"),
+        {
+          method: "POST",
+          headers: headers(),
+          body: JSON.stringify(payload),
+        },
+      );
+
+      if (!response.ok) {
+        throw await createResponseError("post app data change", response);
+      }
+    },
+
+    async postAppDataResync(args): Promise<void> {
+      const payload = hostDaemonAppDataResyncRequestSchema.parse({
+        sessionId: requireSessionId(),
+        ...args,
+      });
+      const response = await fetchFn(
+        buildInternalUrl("/session/app-data-resync"),
+        {
+          method: "POST",
+          headers: headers(),
+          body: JSON.stringify(payload),
+        },
+      );
+
+      if (!response.ok) {
+        throw await createResponseError("post app data resync", response);
+      }
+    },
+
     async postEvents(
       events: HostDaemonEventEnvelope[],
     ): Promise<EventPostResult> {
diff --git a/apps/server/src/internal/app-data-changes.ts b/apps/server/src/internal/app-data-changes.ts
new file mode 100644
index 000000000..d94e75686
--- /dev/null
+++ b/apps/server/src/internal/app-data-changes.ts
@@ -0,0 +1,110 @@
+import {
+  hostDaemonAppDataChangeRequestSchema,
+  hostDaemonAppDataResyncRequestSchema,
+  typedRoutes,
+  type HostDaemonInternalSchema,
+} from "@bb/host-daemon-contract";
+import type { Hono } from "hono";
+import type { AppDeps } from "../types.js";
+import { ApiError } from "../errors.js";
+import {
+  requireEnvironment,
+  requirePublicThread,
+} from "../services/lib/entity-lookup.js";
+import { runWithDaemonCommandWaitForbidden } from "../services/hosts/command-wait-context.js";
+import {
+  requireAuthenticatedDaemonSession,
+  type RequireAuthenticatedDaemonSessionArgs,
+} from "./session-state.js";
+
+interface RequireSessionOwnedThreadArgs {
+  context: RequireAuthenticatedDaemonSessionArgs["context"];
+  deps: AppDeps;
+  sessionId: string;
+  threadId: string;
+}
+
+function requireSessionOwnedThread(args: RequireSessionOwnedThreadArgs): void {
+  const session = requireAuthenticatedDaemonSession({
+    context: args.context,
+    db: args.deps.db,
+    sessionId: args.sessionId,
+  });
+  const thread = requirePublicThread(args.deps.db, args.threadId);
+  if (!thread.environmentId) {
+    throw new ApiError(
+      403,
+      "invalid_request",
+      "Thread does not belong to an environment",
+    );
+  }
+  const environment = requireEnvironment(args.deps.db, thread.environmentId);
+  if (environment.hostId !== session.hostId) {
+    throw new ApiError(
+      403,
+      "invalid_request",
+      "Thread does not belong to the session host",
+    );
+  }
+}
+
+export function registerInternalAppDataChangeRoutes(
+  app: Hono,
+  deps: AppDeps,
+): void {
+  const { post } = typedRoutes<HostDaemonInternalSchema>(app, {
+    onValidationError: (msg) => new ApiError(400, "invalid_request", msg),
+  });
+
+  post(
+    "/session/app-data-change",
+    hostDaemonAppDataChangeRequestSchema,
+    (context, payload) =>
+      runWithDaemonCommandWaitForbidden({
+        reason: "/session/app-data-change",
+        work: async () => {
+          requireSessionOwnedThread({
+            context,
+            deps,
+            sessionId: payload.sessionId,
+            threadId: payload.threadId,
+          });
+
+          deps.hub.notifyThreadAppData({
+            type: "app-data.changed",
+            threadId: payload.threadId,
+            appId: payload.appId,
+            path: payload.path,
+            value: payload.value,
+            deleted: payload.deleted,
+            version: payload.version,
+          });
+          return context.json({ ok: true });
+        },
+      }),
+  );
+
+  post(
+    "/session/app-data-resync",
+    hostDaemonAppDataResyncRequestSchema,
+    (context, payload) =>
+      runWithDaemonCommandWaitForbidden({
+        reason: "/session/app-data-resync",
+        work: async () => {
+          requireSessionOwnedThread({
+            context,
+            deps,
+            sessionId: payload.sessionId,
+            threadId: payload.threadId,
+          });
+
+          deps.hub.notifyThreadAppData({
+            type: "app-data.resync",
+            threadId: payload.threadId,
+            appId: payload.appId,
+          });
+          return context.json({ ok: true });
+        },
+      }),
+  );
+}
diff --git a/apps/server/src/internal/command-result-owners.ts b/apps/server/src/internal/command-result-owners.ts
index 961370a29..d398f3c44 100644
--- a/apps/server/src/internal/command-result-owners.ts
+++ b/apps/server/src/internal/command-result-owners.ts
@@ -747,6 +747,7 @@ const commandResultOwners: CommandResultOwnerRegistry = {
   "host.read_file_relative": null,
   "host.write_file_relative": null,
   "host.delete_file_relative": null,
+  "host.delete_path_relative": null,
   "host.status_version": null,
   "host.status_data.list": null,
   "host.status_data.get": null,
diff --git a/apps/server/src/routes/relative-route-path.ts b/apps/server/src/routes/relative-route-path.ts
new file mode 100644
index 000000000..e138de188
--- /dev/null
+++ b/apps/server/src/routes/relative-route-path.ts
@@ -0,0 +1,92 @@
+import path from "node:path";
+import { ApiError } from "../errors.js";
+
+export type DotfileSegmentPolicy = "allow" | "not-found";
+
+export interface SafeRelativeRoutePath {
+  relativePath: string;
+}
+
+export interface ParseSafeRelativeRoutePathArgs {
+  dotfileSegmentPolicy: DotfileSegmentPolicy;
+  invalidPathMessage: string;
+  rawPath: string;
+  directoryIndexPath?: string;
+}
+
+export interface DecodeRoutePathArgs {
+  invalidPathMessage: string;
+  rawPath: string;
+}
+
+export interface ExtractRoutePathArgs {
+  requestUrl: string;
+  routeSegment: string;
+}
+
+function createInvalidPathError(message: string): ApiError {
+  return new ApiError(400, "invalid_path", message);
+}
+
+function createNotFoundError(relativePath: string): ApiError {
+  return new ApiError(404, "ENOENT", `Path does not exist: ${relativePath}`);
+}
+
+export function decodeRoutePath(args: DecodeRoutePathArgs): string {
+  try {
+    return decodeURIComponent(args.rawPath);
+  } catch {
+    throw createInvalidPathError(args.invalidPathMessage);
+  }
+}
+
+export function parseSafeRelativeRoutePath(
+  args: ParseSafeRelativeRoutePathArgs,
+): SafeRelativeRoutePath {
+  const decodedPath = decodeRoutePath({
+    rawPath: args.rawPath,
+    invalidPathMessage: args.invalidPathMessage,
+  });
+  const relativePath =
+    args.directoryIndexPath !== undefined && decodedPath.endsWith("/")
+      ? `${decodedPath}${args.directoryIndexPath}`
+      : decodedPath;
+
+  if (
+    relativePath.length === 0 ||
+    relativePath.includes("\0") ||
+    relativePath.includes("\\") ||
+    path.posix.isAbsolute(relativePath)
+  ) {
+    throw createInvalidPathError(args.invalidPathMessage);
+  }
+
+  const segments = relativePath.split("/");
+  if (
+    segments.some(
+      (segment) => segment.length === 0 || segment === "." || segment === "..",
+    )
+  ) {
+    throw createInvalidPathError(args.invalidPathMessage);
+  }
+
+  if (
+    args.dotfileSegmentPolicy === "not-found" &&
+    segments.some((segment) => segment.startsWith("."))
+  ) {
+    throw createNotFoundError(relativePath);
+  }
+
+  return {
+    relativePath: segments.join("/"),
+  };
+}
+
+export function extractRoutePath(args: ExtractRoutePathArgs): string {
+  const requestPath = new URL(args.requestUrl).pathname;
+  const routeSegmentIndex = requestPath.indexOf(args.routeSegment);
+  if (routeSegmentIndex === -1) {
+    return "";
+  }
+  return requestPath.slice(routeSegmentIndex + args.routeSegment.length);
+}
diff --git a/apps/server/src/routes/threads/apps.ts b/apps/server/src/routes/threads/apps.ts
new file mode 100644
index 000000000..5df68e93c
--- /dev/null
+++ b/apps/server/src/routes/threads/apps.ts
@@ -0,0 +1,1205 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import mimeTypes from "mime-types";
+import type { Hono } from "hono";
+import {
+  FILE_LIST_LIMIT_MAX,
+  type HostDaemonCommand,
+  type HostDaemonCommandResult,
+} from "@bb/host-daemon-contract";
+import { appDataPathSchema, appIdSchema, jsonValueSchema } from "@bb/domain";
+import type { AppDataPath, AppId, JsonValue } from "@bb/domain";
+import {
+  appDataListQuerySchema,
+  appDataWriteRequestSchema,
+  appManifestSchema,
+  appMessageRequestSchema,
+  createThreadAppRequestSchema,
+  typedRoutes,
+  type AppCapability,
+  type AppDataEntry,
+  type AppDetail,
+  type AppEntry,
+  type AppIcon,
+  type AppManifest,
+  type AppSummary,
+  type AppTemplate,
+  type CreateThreadAppRequest,
+  type PublicApiSchema,
+} from "@bb/server-contract";
+import type { AppDeps, LoggedWorkSessionDeps } from "../../types.js";
+import { COMMAND_TIMEOUT_MS } from "../../constants.js";
+import { ApiError } from "../../errors.js";
+import { queueCommandAndWait } from "../../services/hosts/command-wait.js";
+import {
+  createDaemonFileContentResponse,
+  decodeDaemonFileContent,
+  type DaemonFileReadResult,
+  remapDaemonFileRouteError,
+} from "../../services/hosts/daemon-file-response.js";
+import { requirePublicThread } from "../../services/lib/entity-lookup.js";
+import { requireThreadCommandEnvironment } from "../../services/threads/thread-command-environment.js";
+import { sendThreadMessage } from "../../services/threads/thread-send.js";
+import { injectAppClientScript } from "../../services/threads/app-client-script.js";
+import {
+  extractRoutePath,
+  parseSafeRelativeRoutePath,
+  type SafeRelativeRoutePath,
+} from "../relative-route-path.js";
+import { requireThreadStorageTarget } from "./data.js";
+
+interface ThreadAppsTarget {
+  hostId: string;
+  storagePath: string;
+}
+
+interface AppManifestReadArgs {
+  appId: AppId;
+  target: ThreadAppsTarget;
+}
+
+interface AppSummaryArgs extends AppManifestReadArgs {
+  manifest: AppManifest;
+  requestThreadId: string;
+}
+
+interface AppDetailArgs extends AppManifestReadArgs {
+  requestThreadId: string;
+}
+
+interface AppRootArgs {
+  appId: AppId;
+  target: ThreadAppsTarget;
+}
+
+interface AppDataRootArgs extends AppRootArgs {}
+
+interface ReadAppRelativeFileArgs {
+  appId: AppId;
+  dotfiles: "allow" | "deny";
+  path: string;
+  rootKind: "app" | "assets" | "data";
+  target: ThreadAppsTarget;
+}
+
+interface ReadAppFileMetadataArgs {
+  appId: AppId;
+  path: string;
+  rootKind: "app" | "assets" | "data";
+  target: ThreadAppsTarget;
+}
+
+interface AppRootForKindArgs {
+  appId: AppId;
+  rootKind: "app" | "assets" | "data";
+  target: ThreadAppsTarget;
+}
+
+interface ReadAppDataEntryArgs {
+  appId: AppId;
+  dataPath: AppDataPath;
+  target: ThreadAppsTarget;
+}
+
+interface ListAppDataEntriesArgs {
+  appId: AppId;
+  dataPath: AppDataPath | "";
+  target: ThreadAppsTarget;
+}
+
+interface WriteAppDataEntryArgs extends ReadAppDataEntryArgs {
+  value: JsonValue;
+}
+
+interface DeleteAppDataEntryArgs extends ReadAppDataEntryArgs {}
+
+interface CreateInjectedAppHtmlResponseArgs {
+  appId: AppId;
+  capabilities: AppCapability[];
+  html: string;
+  requestUrl: string;
+  threadId: string;
+}
+
+type AppAssetPath = SafeRelativeRoutePath;
+
+interface LogoResolution {
+  extension: string;
+}
+
+interface TemplateFile {
+  content: string;
+  path: string;
+}
+
+interface ScaffoldAppArgs {
+  request: CreateThreadAppRequest;
+  target: ThreadAppsTarget;
+  threadId: string;
+}
+
+type HostCommandType =
+  | "host.file_metadata"
+  | "host.list_paths"
+  | "host.read_file_relative"
+  | "host.write_file_relative"
+  | "host.delete_file_relative"
+  | "host.delete_path_relative";
+
+interface QueueHostCommandArgs<TType extends HostCommandType> {
+  command: Extract<HostDaemonCommand, { type: TType }>;
+  hostId: string;
+}
+
+const APPS_DIRECTORY_NAME = "apps";
+const ASSETS_DIRECTORY_NAME = "assets";
+const DATA_DIRECTORY_NAME = "data";
+const MANIFEST_FILE_NAME = "manifest.json";
+const HTML_CONTENT_TYPE = "text/html; charset=utf-8";
+const NO_STORE_CACHE_CONTROL = "no-store";
+const CONTENT_TYPE_OPTIONS = "nosniff";
+const HTML_ENTRY_MAX_BYTES = 5 * 1024 * 1024;
+const LOGO_MAX_BYTES = 1024 * 1024;
+const LOGO_EXTENSIONS = ["svg", "png", "jpg", "jpeg"] as const;
+const APP_ROUTE_DATA_SEGMENT = "/data/";
+const APP_ROUTE_ASSETS_SEGMENT = "/assets/";
+
+function sha256(bytes: Buffer): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function canonicalizeJson(value: JsonValue): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function parseAppId(rawAppId: string): AppId {
+  const parsed = appIdSchema.safeParse(rawAppId);
+  if (!parsed.success) {
+    throw new ApiError(400, "invalid_request", "Invalid app id");
+  }
+  return parsed.data;
+}
+
+function parseAppDataPath(rawPath: string): AppDataPath {
+  const parsed = appDataPathSchema.safeParse(rawPath);
+  if (!parsed.success) {
+    throw new ApiError(400, "invalid_request", "Invalid app data path");
+  }
+  return parsed.data;
+}
+
+function parseAppDataRoutePath(rawPath: string): AppDataPath {
+  return parseAppDataPath(
+    parseSafeRelativeRoutePath({
+      rawPath,
+      dotfileSegmentPolicy: "allow",
+      invalidPathMessage: "Invalid app data path",
+    }).relativePath,
+  );
+}
+
+function parseOptionalAppDataPrefix(rawPrefix: string | undefined): AppDataPath | "" {
+  if (rawPrefix === undefined || rawPrefix === "") {
+    return "";
+  }
+  return parseAppDataPath(rawPrefix);
+}
+
+function appRootPath(args: AppRootArgs): string {
+  return path.join(args.target.storagePath, APPS_DIRECTORY_NAME, args.appId);
+}
+
+function appAssetsRootPath(args: AppRootArgs): string {
+  return path.join(appRootPath(args), ASSETS_DIRECTORY_NAME);
+}
+
+function appDataRootPath(args: AppDataRootArgs): string {
+  return path.join(appRootPath(args), DATA_DIRECTORY_NAME);
+}
+
+function appRootForKind(args: AppRootForKindArgs): string {
+  if (args.rootKind === "app") {
+    return appRootPath(args);
+  }
+  if (args.rootKind === "assets") {
+    return appAssetsRootPath(args);
+  }
+  return appDataRootPath(args);
+}
+
+function parseAppAssetPath(rawPath: string): AppAssetPath {
+  return parseSafeRelativeRoutePath({
+    rawPath,
+    directoryIndexPath: "index.html",
+    dotfileSegmentPolicy: "not-found",
+    invalidPathMessage: "Invalid app asset path",
+  });
+}
+
+function decodeDaemonTextFile(result: DaemonFileReadResult): string {
+  return Buffer.from(decodeDaemonFileContent(result)).toString("utf8");
+}
+
+function remapAppCommandError(error: unknown): never {
+  if (!(error instanceof ApiError)) {
+    throw error;
+  }
+  if (error.body.code === "ENOENT") {
+    throw new ApiError(
+      404,
+      error.body.code,
+      error.body.message,
+      error.body.retryable,
+    );
+  }
+  if (error.body.code === "invalid_path") {
+    throw new ApiError(
+      400,
+      error.body.code,
+      error.body.message,
+      error.body.retryable,
+    );
+  }
+  if (error.body.code === "invalid_json") {
+    throw new ApiError(
+      422,
+      error.body.code,
+      error.body.message,
+      error.body.retryable,
+    );
+  }
+  throw error;
+}
+
+async function queueHostCommand<TType extends HostCommandType>(
+  deps: AppDeps,
+  args: QueueHostCommandArgs<TType>,
+): Promise<HostDaemonCommandResult<TType>> {
+  try {
+    return await queueCommandAndWait(deps, {
+      hostId: args.hostId,
+      timeoutMs: COMMAND_TIMEOUT_MS,
+      command: args.command,
+    });
+  } catch (error) {
+    remapAppCommandError(error);
+  }
+}
+
+async function requireThreadAppsTarget(
+  deps: LoggedWorkSessionDeps,
+  threadId: string,
+): Promise<ThreadAppsTarget> {
+  const target = await requireThreadStorageTarget(deps, { threadId });
+  return {
+    hostId: target.hostId,
+    storagePath: target.storagePath,
+  };
+}
+
+async function readAppRelativeFile(
+  deps: AppDeps,
+  args: ReadAppRelativeFileArgs,
+): Promise<DaemonFileReadResult> {
+  return queueHostCommand(deps, {
+    hostId: args.target.hostId,
+    command: {
+      type: "host.read_file_relative",
+      rootPath: appRootForKind(args),
+      path: args.path,
+      dotfiles: args.dotfiles,
+    },
+  });
+}
+
+async function readAppFileMetadata(
+  deps: AppDeps,
+  args: ReadAppFileMetadataArgs,
+): Promise<HostDaemonCommandResult<"host.file_metadata">> {
+  return queueHostCommand(deps, {
+    hostId: args.target.hostId,
+    command: {
+      type: "host.file_metadata",
+      path: path.join(appRootForKind(args), args.path),
+      rootPath: appRootForKind(args),
+    },
+  });
+}
+
+async function readAppManifest(
+  deps: AppDeps,
+  args: AppManifestReadArgs,
+): Promise<AppManifest> {
+  const result = await readAppRelativeFile(deps, {
+    appId: args.appId,
+    target: args.target,
+    rootKind: "app",
+    path: MANIFEST_FILE_NAME,
+    dotfiles: "deny",
+  });
+  let parsedJson: unknown;
+  try {
+    parsedJson = JSON.parse(decodeDaemonTextFile(result));
+  } catch {
+    throw new ApiError(422, "invalid_json", "App manifest is not valid JSON");
+  }
+  const manifest = appManifestSchema.safeParse(parsedJson);
+  if (!manifest.success) {
+    throw new ApiError(422, "invalid_request", "Invalid app manifest");
+  }
+  if (manifest.data.id !== args.appId) {
+    throw new ApiError(
+      422,
+      "invalid_request",
+      "App manifest id must match its directory name",
+    );
+  }
+  return manifest.data;
+}
+
+function entryKindForPath(entryPath: string): AppEntry["kind"] {
+  const normalized = entryPath.toLowerCase();
+  if (normalized.endsWith(".html")) {
+    return "html";
+  }
+  if (normalized.endsWith(".md")) {
+    return "md";
+  }
+  throw new ApiError(
+    422,
+    "invalid_request",
+    "App entry must end in .html or .md",
+  );
+}
+
+async function resolveAppEntry(
+  deps: AppDeps,
+  args: AppManifestReadArgs & { manifest: AppManifest },
+): Promise<AppEntry> {
+  if (args.manifest.entry !== undefined) {
+    return {
+      path: args.manifest.entry,
+      kind: entryKindForPath(args.manifest.entry),
+    };
+  }
+
+  for (const candidate of ["index.html", "index.md"]) {
+    try {
+      await readAppFileMetadata(deps, {
+        appId: args.appId,
+        target: args.target,
+        path: candidate,
+        rootKind: "assets",
+      });
+      return {
+        path: candidate,
+        kind: entryKindForPath(candidate),
+      };
+    } catch (error) {
+      if (error instanceof ApiError && error.body.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+  }
+
+  throw new ApiError(
+    404,
+    "ENOENT",
+    "App entry not found: index.html or index.md",
+  );
+}
+
+async function tryResolveLogo(
+  deps: AppDeps,
+  args: AppManifestReadArgs,
+): Promise<LogoResolution | null> {
+  let listResult: HostDaemonCommandResult<"host.list_paths">;
+  try {
+    listResult = await queueHostCommand(deps, {
+      hostId: args.target.hostId,
+      command: {
+        type: "host.list_paths",
+        path: appRootPath(args),
+        limit: LOGO_EXTENSIONS.length,
+        includeFiles: true,
+        includeDirectories: false,
+      },
+    });
+  } catch (error) {
+    if (error instanceof ApiError && error.body.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+
+  const topLevelFiles = new Set(
+    listResult.paths
+      .filter((entry) => entry.kind === "file" && !entry.path.includes("/"))
+      .map((entry) => entry.path),
+  );
+  for (const extension of LOGO_EXTENSIONS) {
+    if (topLevelFiles.has(`logo.${extension}`)) {
+      return { extension };
+    }
+  }
+  return null;
+}
+
+async function resolveAppIcon(
+  deps: AppDeps,
+  args: AppSummaryArgs,
+): Promise<AppIcon> {
+  if (args.manifest.icon !== undefined) {
+    return { kind: "builtin", name: args.manifest.icon };
+  }
+  const logo = await tryResolveLogo(deps, args);
+  if (logo) {
+    return {
+      kind: "logo",
+      url: `/api/v1/threads/${encodeURIComponent(
+        args.requestThreadId,
+      )}/apps/${encodeURIComponent(args.appId)}/icon`,
+    };
+  }
+  return { kind: "builtin", name: "GridView" };
+}
+
+async function buildAppSummary(
+  deps: AppDeps,
+  args: AppSummaryArgs,
+): Promise<AppSummary> {
+  const [entry, icon] = await Promise.all([
+    resolveAppEntry(deps, args),
+    resolveAppIcon(deps, args),
+  ]);
+  return {
+    id: args.manifest.id,
+    name: args.manifest.name,
+    entry,
+    capabilities: args.manifest.capabilities,
+    icon,
+  };
+}
+
+async function buildAppDetail(
+  deps: AppDeps,
+  args: AppDetailArgs,
+): Promise<AppDetail> {
+  const manifest = await readAppManifest(deps, args);
+  return buildAppSummary(deps, {
+    ...args,
+    manifest,
+  });
+}
+
+function assertAppCapability(
+  manifest: AppManifest,
+  capability: AppCapability,
+): void {
+  if (!manifest.capabilities.includes(capability)) {
+    throw new ApiError(
+      403,
+      "invalid_request",
+      `App does not have the ${capability} capability`,
+    );
+  }
+}
+
+async function listThreadApps(
+  deps: AppDeps,
+  threadId: string,
+): Promise<AppSummary[]> {
+  const target = await requireThreadAppsTarget(deps, threadId);
+  let listResult: HostDaemonCommandResult<"host.list_paths">;
+  try {
+    listResult = await queueHostCommand(deps, {
+      hostId: target.hostId,
+      command: {
+        type: "host.list_paths",
+        path: path.join(target.storagePath, APPS_DIRECTORY_NAME),
+        limit: FILE_LIST_LIMIT_MAX,
+        includeFiles: false,
+        includeDirectories: true,
+      },
+    });
+  } catch (error) {
+    if (error instanceof ApiError && error.body.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+
+  const appIds = listResult.paths
+    .filter((entry) => entry.kind === "directory" && !entry.path.includes("/"))
+    .map((entry) => appIdSchema.safeParse(entry.path))
+    .filter((entry) => entry.success)
+    .map((entry) => entry.data)
+    .sort((left, right) => left.localeCompare(right));
+
+  return Promise.all(
+    appIds.map(async (appId) => {
+      const manifest = await readAppManifest(deps, { appId, target });
+      return buildAppSummary(deps, {
+        appId,
+        target,
+        manifest,
+        requestThreadId: threadId,
+      });
+    }),
+  );
+}
+
+function createHtmlResponse(html: string): Response {
+  return new Response(html, {
+    status: 200,
+    headers: {
+      "cache-control": NO_STORE_CACHE_CONTROL,
+      "content-type": HTML_CONTENT_TYPE,
+      "x-content-type-options": CONTENT_TYPE_OPTIONS,
+    },
+  });
+}
+
+function buildAppWebSocketUrl(
+  deps: LoggedWorkSessionDeps,
+  requestUrl: string,
+): string {
+  if (deps.config.isDevelopment) {
+    return `ws://localhost:${deps.config.serverPort}/ws`;
+  }
+  const url = new URL(requestUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/ws";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+function createInjectedAppHtmlResponse(
+  deps: LoggedWorkSessionDeps,
+  args: CreateInjectedAppHtmlResponseArgs,
+): Response {
+  // Phase 1 app capabilities are advisory because app HTML is still served from
+  // bb's same origin. We gate the injected bridge and app-owned routes by the
+  // manifest-declared list, but real isolation waits for the third-party
+  // extensions phase: sandboxed/opaque-origin iframes with a postMessage bridge.
+  return createHtmlResponse(
+    injectAppClientScript(args.html, {
+      appId: args.appId,
+      capabilities: args.capabilities,
+      threadId: args.threadId,
+      dataUrl: `/api/v1/threads/${encodeURIComponent(
+        args.threadId,
+      )}/apps/${encodeURIComponent(args.appId)}/data`,
+      messageUrl: `/api/v1/threads/${encodeURIComponent(
+        args.threadId,
+      )}/apps/${encodeURIComponent(args.appId)}/message`,
+      wsUrl: buildAppWebSocketUrl(deps, args.requestUrl),
+    }),
+  );
+}
+
+async function serveAppEntry(
+  deps: AppDeps,
+  threadId: string,
+  rawAppId: string,
+  requestUrl: string,
+): Promise<Response> {
+  const appId = parseAppId(rawAppId);
+  const target = await requireThreadAppsTarget(deps, threadId);
+  const manifest = await readAppManifest(deps, { appId, target });
+  const entry = await resolveAppEntry(deps, { appId, target, manifest });
+  if (entry.kind !== "html") {
+    throw new ApiError(404, "invalid_request", "App entry is not HTML");
+  }
+  const metadata = await readAppFileMetadata(deps, {
+    appId,
+    target,
+    rootKind: "assets",
+    path: entry.path,
+  });
+  if (metadata.sizeBytes > HTML_ENTRY_MAX_BYTES) {
+    throw new ApiError(
+      413,
+      "file_too_large",
+      "App HTML entry exceeds the 5 MB limit",
+      false,
+    );
+  }
+  const result = await readAppRelativeFile(deps, {
+    appId,
+    target,
+    rootKind: "assets",
+    path: entry.path,
+    dotfiles: "deny",
+  });
+  return createInjectedAppHtmlResponse(deps, {
+    appId,
+    requestUrl,
+    threadId,
+    html: decodeDaemonTextFile(result),
+    capabilities: manifest.capabilities,
+  });
+}
+
+async function serveAppAsset(
+  deps: AppDeps,
+  threadId: string,
+  rawAppId: string,
+  rawPath: string,
+): Promise<Response> {
+  const appId = parseAppId(rawAppId);
+  const assetPath = parseAppAssetPath(rawPath);
+  const target = await requireThreadAppsTarget(deps, threadId);
+  try {
+    const result = await readAppRelativeFile(deps, {
+      appId,
+      target,
+      rootKind: "assets",
+      path: assetPath.relativePath,
+      dotfiles: "deny",
+    });
+    return createDaemonFileContentResponse(result, {
+      headers: {
+        "cache-control": NO_STORE_CACHE_CONTROL,
+        "x-content-type-options": CONTENT_TYPE_OPTIONS,
+      },
+    });
+  } catch (error) {
+    return remapDaemonFileRouteError(error);
+  }
+}
+
+async function serveAppIcon(
+  deps: AppDeps,
+  threadId: string,
+  rawAppId: string,
+): Promise<Response> {
+  const appId = parseAppId(rawAppId);
+  const target = await requireThreadAppsTarget(deps, threadId);
+  const manifest = await readAppManifest(deps, { appId, target });
+  if (manifest.icon !== undefined) {
+    throw new ApiError(404, "ENOENT", "App uses a built-in icon");
+  }
+  const logo = await tryResolveLogo(deps, { appId, target });
+  if (!logo) {
+    throw new ApiError(404, "ENOENT", "App logo not found");
+  }
+  const logoPath = `logo.${logo.extension}`;
+  const metadata = await readAppFileMetadata(deps, {
+    appId,
+    target,
+    rootKind: "app",
+    path: logoPath,
+  });
+  if (metadata.sizeBytes > LOGO_MAX_BYTES) {
+    throw new ApiError(
+      413,
+      "file_too_large",
+      "App logo exceeds the 1 MB limit",
+      false,
+    );
+  }
+  const result = await readAppRelativeFile(deps, {
+    appId,
+    target,
+    rootKind: "app",
+    path: logoPath,
+    dotfiles: "deny",
+  });
+  const contentType =
+    mimeTypes.lookup(logoPath) || "application/octet-stream";
+  return new Response(decodeDaemonFileContent(result), {
+    status: 200,
+    headers: {
+      "cache-control": NO_STORE_CACHE_CONTROL,
+      "content-type": contentType,
+      "x-content-type-options": CONTENT_TYPE_OPTIONS,
+    },
+  });
+}
+
+async function readAppDataEntry(
+  deps: AppDeps,
+  args: ReadAppDataEntryArgs,
+): Promise<AppDataEntry> {
+  const file = await readAppRelativeFile(deps, {
+    appId: args.appId,
+    target: args.target,
+    rootKind: "data",
+    path: args.dataPath,
+    dotfiles: "deny",
+  });
+  let value: JsonValue;
+  const bytes = Buffer.from(decodeDaemonFileContent(file));
+  try {
+    value = jsonValueSchema.parse(JSON.parse(bytes.toString("utf8")));
+  } catch {
+    throw new ApiError(
+      422,
+      "invalid_json",
+      `App data path ${args.dataPath} does not contain valid JSON`,
+    );
+  }
+  const modifiedAtMs =
+    file.modifiedAtMs ??
+    (
+      await readAppFileMetadata(deps, {
+        appId: args.appId,
+        target: args.target,
+        rootKind: "data",
+        path: args.dataPath,
+      })
+    ).modifiedAtMs;
+  return {
+    path: args.dataPath,
+    value,
+    version: sha256(bytes),
+    sizeBytes: file.sizeBytes,
+    modifiedAtMs,
+  };
+}
+
+function shouldListAppDataPrefixAfterReadError(error: Error): boolean {
+  return (
+    error instanceof ApiError &&
+    (error.body.code === "ENOENT" ||
+      (error.body.code === "invalid_path" &&
+        error.body.message.includes("Path is a directory")))
+  );
+}
+
+async function listAppDataEntries(
+  deps: AppDeps,
+  args: ListAppDataEntriesArgs,
+): Promise<AppDataEntry[]> {
+  if (args.dataPath !== "") {
+    try {
+      return [
+        await readAppDataEntry(deps, {
+          appId: args.appId,
+          dataPath: args.dataPath,
+          target: args.target,
+        }),
+      ];
+    } catch (error) {
+      if (
+        !(error instanceof Error) ||
+        !shouldListAppDataPrefixAfterReadError(error)
+      ) {
+        throw error;
+      }
+    }
+  }
+
+  const listRoot = args.dataPath
+    ? path.join(appDataRootPath(args), args.dataPath)
+    : appDataRootPath(args);
+  let listResult: HostDaemonCommandResult<"host.list_paths">;
+  try {
+    listResult = await queueHostCommand(deps, {
+      hostId: args.target.hostId,
+      command: {
+        type: "host.list_paths",
+        path: listRoot,
+        limit: FILE_LIST_LIMIT_MAX,
+        includeFiles: true,
+        includeDirectories: false,
+      },
+    });
+  } catch (error) {
+    if (error instanceof ApiError && error.body.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+
+  const dataPaths = listResult.paths
+    .filter((entry) => entry.kind === "file")
+    .map((entry) =>
+      args.dataPath ? `${args.dataPath}/${entry.path}` : entry.path,
+    )
+    .map((entryPath) => appDataPathSchema.safeParse(entryPath))
+    .filter((entryPath) => entryPath.success)
+    .map((entryPath) => entryPath.data)
+    .sort((left, right) => left.localeCompare(right));
+
+  return Promise.all(
+    dataPaths.map((dataPath) =>
+      readAppDataEntry(deps, {
+        appId: args.appId,
+        dataPath,
+        target: args.target,
+      }),
+    ),
+  );
+}
+
+async function writeAppDataEntry(
+  deps: AppDeps,
+  args: WriteAppDataEntryArgs,
+): Promise<AppDataEntry> {
+  const content = canonicalizeJson(args.value);
+  const result = await queueHostCommand(deps, {
+    hostId: args.target.hostId,
+    command: {
+      type: "host.write_file_relative",
+      rootPath: appDataRootPath(args),
+      path: args.dataPath,
+      dotfiles: "deny",
+      content,
+      contentEncoding: "utf8",
+    },
+  });
+  return {
+    path: args.dataPath,
+    value: args.value,
+    version: result.hash,
+    sizeBytes: result.sizeBytes,
+    modifiedAtMs: result.modifiedAtMs,
+  };
+}
+
+async function deleteAppDataEntry(
+  deps: AppDeps,
+  args: DeleteAppDataEntryArgs,
+): Promise<void> {
+  await queueHostCommand(deps, {
+    hostId: args.target.hostId,
+    command: {
+      type: "host.delete_file_relative",
+      rootPath: appDataRootPath(args),
+      path: args.dataPath,
+      dotfiles: "deny",
+    },
+  });
+}
+
+function createTemplateManifest(
+  request: CreateThreadAppRequest,
+  template: AppTemplate,
+): AppManifest {
+  const manifest: AppManifest = {
+    manifestVersion: 1,
+    id: request.id,
+    name: request.name,
+    entry: "index.html",
+    contributions: ["thread.app"],
+    capabilities: ["data", "message"],
+  };
+  if (template === "status") {
+    manifest.icon = "ListTodo";
+  }
+  return manifest;
+}
+
+function blankIndexHtml(name: string): string {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${name}</title>
+  </head>
+  <body>
+    <main id="app"></main>
+    <script>
+      document.getElementById("app").textContent = window.bb ? window.bb.appId : ${JSON.stringify(name)};
+    </script>
+  </body>
+</html>
+`;
+}
+
+async function templateFilesForRequest(
+  request: CreateThreadAppRequest,
+): Promise<TemplateFile[]> {
+  const manifest = createTemplateManifest(request, request.template);
+  if (request.template === "blank") {
+    return [
+      {
+        path: MANIFEST_FILE_NAME,
+        content: canonicalizeJson(manifest),
+      },
+      {
+        path: "assets/index.html",
+        content: blankIndexHtml(request.name),
+      },
+      {
+        path: "data/state.json",
+        content: canonicalizeJson({}),
+      },
+    ];
+  }
+
+  const templateDir = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "../../services/threads/default-template/apps/status",
+  );
+  const [indexHtml, stateJson] = await Promise.all([
+    readFile(path.join(templateDir, "assets/index.html"), "utf8"),
+    readFile(path.join(templateDir, "data/state.json"), "utf8"),
+  ]);
+  return [
+    {
+      path: MANIFEST_FILE_NAME,
+      content: canonicalizeJson(manifest),
+    },
+    {
+      path: "assets/index.html",
+      content: indexHtml,
+    },
+    {
+      path: "data/state.json",
+      content: stateJson,
+    },
+  ];
+}
+
+async function scaffoldApp(
+  deps: AppDeps,
+  args: ScaffoldAppArgs,
+): Promise<AppDetail> {
+  try {
+    await readAppManifest(deps, {
+      appId: args.request.id,
+      target: args.target,
+    });
+    throw new ApiError(409, "invalid_request", "App already exists");
+  } catch (error) {
+    if (!(error instanceof ApiError) || error.status !== 404) {
+      throw error;
+    }
+  }
+
+  const files = await templateFilesForRequest(args.request);
+  for (const file of files) {
+    await queueHostCommand(deps, {
+      hostId: args.target.hostId,
+      command: {
+        type: "host.write_file_relative",
+        rootPath: appRootPath({
+          appId: args.request.id,
+          target: args.target,
+        }),
+        path: file.path,
+        dotfiles: "deny",
+        content: file.content,
+        contentEncoding: "utf8",
+      },
+    });
+  }
+  return buildAppDetail(deps, {
+    appId: args.request.id,
+    target: args.target,
+    requestThreadId: args.threadId,
+  });
+}
+
+export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
+  const { get, post, put, del } = typedRoutes<PublicApiSchema>(app, {
+    onValidationError: (msg) => new ApiError(400, "invalid_request", msg),
+  });
+
+  get("/threads/:id/apps", async (context) =>
+    context.json(await listThreadApps(deps, context.req.param("id"))),
+  );
+
+  post(
+    "/threads/:id/apps",
+    createThreadAppRequestSchema,
+    async (context, payload) => {
+      const threadId = context.req.param("id");
+      const target = await requireThreadAppsTarget(deps, threadId);
+      const detail = await scaffoldApp(deps, {
+        target,
+        request: payload,
+        threadId,
+      });
+      return context.json(detail, 201);
+    },
+  );
+
+  get("/threads/:id/apps/:appId", async (context) => {
+    const threadId = context.req.param("id");
+    const appId = parseAppId(context.req.param("appId"));
+    const target = await requireThreadAppsTarget(deps, threadId);
+    return context.json(
+      await buildAppDetail(deps, {
+        appId,
+        target,
+        requestThreadId: threadId,
+      }),
+    );
+  });
+
+  del("/threads/:id/apps/:appId", async (context) => {
+    const threadId = context.req.param("id");
+    const appId = parseAppId(context.req.param("appId"));
+    const target = await requireThreadAppsTarget(deps, threadId);
+    const result = await queueHostCommand(deps, {
+      hostId: target.hostId,
+      command: {
+        type: "host.delete_path_relative",
+        rootPath: path.join(target.storagePath, APPS_DIRECTORY_NAME),
+        path: appId,
+        dotfiles: "deny",
+      },
+    });
+    if (!result.deleted) {
+      throw new ApiError(404, "ENOENT", `App not found: ${appId}`);
+    }
+    return context.json({ ok: true });
+  });
+
+  get(
+    "/threads/:id/apps/:appId/data",
+    appDataListQuerySchema,
+    async (context, query) => {
+      const target = await requireThreadAppsTarget(
+        deps,
+        context.req.param("id"),
+      );
+      const appId = parseAppId(context.req.param("appId"));
+      assertAppCapability(
+        await readAppManifest(deps, { appId, target }),
+        "data",
+      );
+      const dataPath = parseOptionalAppDataPrefix(query.prefix);
+      return context.json({
+        entries: await listAppDataEntries(deps, {
+          appId,
+          target,
+          dataPath,
+        }),
+      });
+    },
+  );
+
+  post(
+    "/threads/:id/apps/:appId/message",
+    appMessageRequestSchema,
+    async (context, payload) => {
+      const thread = requirePublicThread(deps.db, context.req.param("id"));
+      const manifest = await readAppManifest(deps, {
+        appId: parseAppId(context.req.param("appId")),
+        target: await requireThreadAppsTarget(deps, thread.id),
+      });
+      assertAppCapability(manifest, "message");
+      const environment = await requireThreadCommandEnvironment(deps, {
+        thread,
+      });
+      await sendThreadMessage(deps, {
+        environment,
+        thread,
+        trigger: "user",
+        payload: {
+          input: [{ type: "text", text: payload.text }],
+          mode: "auto",
+        },
+      });
+      return context.json({ ok: true });
+    },
+  );
+
+  app.get("/threads/:id/apps/:appId/", async (context) =>
+    serveAppEntry(
+      deps,
+      context.req.param("id"),
+      context.req.param("appId"),
+      context.req.url,
+    ),
+  );
+
+  app.get("/threads/:id/apps/:appId/assets/*", async (context) =>
+    serveAppAsset(
+      deps,
+      context.req.param("id"),
+      context.req.param("appId"),
+      extractRoutePath({
+        requestUrl: context.req.url,
+        routeSegment: APP_ROUTE_ASSETS_SEGMENT,
+      }),
+    ),
+  );
+
+  app.get("/threads/:id/apps/:appId/icon", async (context) =>
+    serveAppIcon(deps, context.req.param("id"), context.req.param("appId")),
+  );
+
+  get("/threads/:id/apps/:appId/data/*", async (context) => {
+    const target = await requireThreadAppsTarget(deps, context.req.param("id"));
+    const appId = parseAppId(context.req.param("appId"));
+    assertAppCapability(await readAppManifest(deps, { appId, target }), "data");
+    const dataPath = parseAppDataRoutePath(
+      extractRoutePath({
+        requestUrl: context.req.url,
+        routeSegment: APP_ROUTE_DATA_SEGMENT,
+      }),
+    );
+    const entry = await readAppDataEntry(deps, {
+      appId,
+      target,
+      dataPath,
+    });
+    const response = context.json(entry);
+    response.headers.set("cache-control", NO_STORE_CACHE_CONTROL);
+    response.headers.set("etag", `"${entry.version}"`);
+    return response;
+  });
+
+  put(
+    "/threads/:id/apps/:appId/data/*",
+    appDataWriteRequestSchema,
+    async (context, payload) => {
+      const target = await requireThreadAppsTarget(
+        deps,
+        context.req.param("id"),
+      );
+      const appId = parseAppId(context.req.param("appId"));
+      const manifest = await readAppManifest(deps, { appId, target });
+      assertAppCapability(manifest, "data");
+      const dataPath = parseAppDataRoutePath(
+        extractRoutePath({
+          requestUrl: context.req.url,
+          routeSegment: APP_ROUTE_DATA_SEGMENT,
+        }),
+      );
+      const entry = await writeAppDataEntry(deps, {
+        appId,
+        target,
+        dataPath,
+        value: payload.value,
+      });
+      const response = context.json(entry);
+      response.headers.set("cache-control", NO_STORE_CACHE_CONTROL);
+      response.headers.set("etag", `"${entry.version}"`);
+      return response;
+    },
+  );
+
+  del("/threads/:id/apps/:appId/data/*", async (context) => {
+    const target = await requireThreadAppsTarget(deps, context.req.param("id"));
+    const appId = parseAppId(context.req.param("appId"));
+    const manifest = await readAppManifest(deps, { appId, target });
+    assertAppCapability(manifest, "data");
+    const dataPath = parseAppDataRoutePath(
+      extractRoutePath({
+        requestUrl: context.req.url,
+        routeSegment: APP_ROUTE_DATA_SEGMENT,
+      }),
+    );
+    await deleteAppDataEntry(deps, {
+      appId,
+      target,
+      dataPath,
+    });
+    const response = context.json({ ok: true });
+    response.headers.set("cache-control", NO_STORE_CACHE_CONTROL);
+    return response;
+  });
+}
diff --git a/apps/server/src/routes/threads/data.ts b/apps/server/src/routes/threads/data.ts
index 1a987203b..508769e74 100644
--- a/apps/server/src/routes/threads/data.ts
+++ b/apps/server/src/routes/threads/data.ts
@@ -75,6 +75,11 @@ import {
   parseOptionalInteger,
 } from "../../services/lib/validation.js";
 import { parsePathKindInclusion } from "../path-list-inclusion.js";
+import {
+  extractRoutePath,
+  parseSafeRelativeRoutePath,
+  type SafeRelativeRoutePath,
+} from "../relative-route-path.js";
 
 interface ThreadComposerExecutionOptionsSource {
   archivedAt: number | null;
@@ -159,13 +164,8 @@ type HostStatusVersionCommand = Extract<
   { type: "host.status_version" }
 >;
 
-interface StatusAssetPath {
-  relativePath: string;
-}
-
-interface RawFileRoutePath {
-  relativePath: string;
-}
+type StatusAssetPath = SafeRelativeRoutePath;
+type RawFileRoutePath = SafeRelativeRoutePath;
 
 const STATUS_DIRECTORY_NAME = "STATUS";
 const STATUS_INDEX_FILE_PATH = "index.html";
@@ -283,112 +283,38 @@ export async function requireThreadStorageTarget(
   };
 }
 
-function createStatusNotFoundError(relativePath: string): ApiError {
-  return new ApiError(404, "ENOENT", `Path does not exist: ${relativePath}`);
-}
-
-function createStatusInvalidPathError(): ApiError {
-  return new ApiError(400, "invalid_path", "Invalid status asset path");
-}
-
-function decodeStatusRoutePath(rawPath: string): string {
-  try {
-    return decodeURIComponent(rawPath);
-  } catch {
-    throw createStatusInvalidPathError();
-  }
-}
-
 function parseStatusAssetPath(rawPath: string): StatusAssetPath {
-  const decodedPath = decodeStatusRoutePath(rawPath);
-  const requestedDirectoryIndex = decodedPath.endsWith("/");
-  const relativePath = requestedDirectoryIndex
-    ? `${decodedPath}${STATUS_INDEX_FILE_PATH}`
-    : decodedPath;
-
-  if (
-    relativePath.length === 0 ||
-    relativePath.includes("\0") ||
-    relativePath.includes("\\") ||
-    path.posix.isAbsolute(relativePath)
-  ) {
-    throw createStatusInvalidPathError();
-  }
-
-  const segments = relativePath.split("/");
-  if (
-    segments.some(
-      (segment) => segment.length === 0 || segment === "." || segment === "..",
-    )
-  ) {
-    throw createStatusInvalidPathError();
-  }
-
-  if (segments.some((segment) => segment.startsWith("."))) {
-    throw createStatusNotFoundError(relativePath);
-  }
-
-  return {
-    relativePath: segments.join("/"),
-  };
-}
-
-function createRawFileInvalidPathError(): ApiError {
-  return new ApiError(400, "invalid_path", "Invalid file path");
-}
-
-function decodeRawFileRoutePath(rawPath: string): string {
-  try {
-    return decodeURIComponent(rawPath);
-  } catch {
-    throw createRawFileInvalidPathError();
-  }
+  return parseSafeRelativeRoutePath({
+    rawPath,
+    directoryIndexPath: STATUS_INDEX_FILE_PATH,
+    dotfileSegmentPolicy: "not-found",
+    invalidPathMessage: "Invalid status asset path",
+  });
 }
 
 function parseRawFileRoutePath(rawPath: string): RawFileRoutePath {
-  const relativePath = decodeRawFileRoutePath(rawPath);
-  if (
-    relativePath.length === 0 ||
-    relativePath.includes("\0") ||
-    relativePath.includes("\\") ||
-    path.posix.isAbsolute(relativePath)
-  ) {
-    throw createRawFileInvalidPathError();
-  }
-
-  const segments = relativePath.split("/");
-  if (
-    segments.some(
-      (segment) => segment.length === 0 || segment === "." || segment === "..",
-    )
-  ) {
-    throw createRawFileInvalidPathError();
-  }
-
-  return {
-    relativePath: segments.join("/"),
-  };
+  return parseSafeRelativeRoutePath({
+    rawPath,
+    dotfileSegmentPolicy: "allow",
+    invalidPathMessage: "Invalid file path",
+  });
 }
 
 function extractThreadStatusPath(requestUrl: string): string {
-  const requestPath = new URL(requestUrl).pathname;
-  const statusSegmentIndex = requestPath.indexOf(STATUS_ROUTE_SEGMENT);
-  if (statusSegmentIndex === -1) {
-    return "";
-  }
-  return requestPath.slice(statusSegmentIndex + STATUS_ROUTE_SEGMENT.length);
+  return extractRoutePath({
+    requestUrl,
+    routeSegment: STATUS_ROUTE_SEGMENT,
+  });
 }
 
 function extractRawFileRoutePath(
   requestUrl: string,
   routeSegment: string,
 ): string {
-  const requestPath = new URL(requestUrl).pathname;
-  const routeSegmentIndex = requestPath.indexOf(routeSegment);
-  if (routeSegmentIndex === -1) {
-    return "";
-  }
-  return requestPath.slice(routeSegmentIndex + routeSegment.length);
+  return extractRoutePath({
+    requestUrl,
+    routeSegment,
+  });
 }
 
 function shouldFallbackStatusRead(error: unknown): boolean {
diff --git a/apps/server/src/routes/threads/index.ts b/apps/server/src/routes/threads/index.ts
index 386ffe276..854b6fd3f 100644
--- a/apps/server/src/routes/threads/index.ts
+++ b/apps/server/src/routes/threads/index.ts
@@ -1,6 +1,7 @@
 import type { Hono } from "hono";
 import type { AppDeps } from "../../types.js";
 import { registerThreadActionRoutes } from "./actions.js";
+import { registerThreadAppRoutes } from "./apps.js";
 import { registerThreadBaseRoutes } from "./base.js";
 import { registerThreadDataRoutes } from "./data.js";
 import { registerThreadInteractionRoutes } from "./interactions.js";
@@ -14,6 +15,7 @@ export function registerThreadRoutes(app: Hono, deps: AppDeps): void {
     registerThreadTerminalRoutes(app, deps);
   }
   registerThreadStatusDataRoutes(app, deps);
+  registerThreadAppRoutes(app, deps);
   registerThreadDataRoutes(app, deps);
   registerThreadInteractionRoutes(app, deps);
 }
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 7acd18286..077e969b3 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -21,6 +21,7 @@ import { registerDevelopmentOnlyReplayRoutes } from "./routes/internal-replay.js
 import { registerThreadRoutes } from "./routes/threads/index.js";
 import { registerInternalCommandRoutes } from "./internal/commands.js";
 import { registerInternalCommandResultRoutes } from "./internal/command-result-route.js";
+import { registerInternalAppDataChangeRoutes } from "./internal/app-data-changes.js";
 import { registerInternalEnvironmentChangeRoutes } from "./internal/environment-changes.js";
 import { registerInternalEventRoutes } from "./internal/events.js";
 import { registerInternalHostRoutes } from "./internal/hosts.js";
@@ -265,6 +266,7 @@ export function createApp(
   registerInternalCommandResultRoutes(internalApi, deps);
   registerInternalEnvironmentChangeRoutes(internalApi, deps);
   registerInternalStatusDataChangeRoutes(internalApi, deps);
+  registerInternalAppDataChangeRoutes(internalApi, deps);
   registerInternalEventRoutes(internalApi, deps);
   registerInternalToolCallRoutes(internalApi, deps);
   registerInternalInteractiveRequestRoutes(internalApi, deps);
diff --git a/apps/server/src/services/threads/app-client-script.ts b/apps/server/src/services/threads/app-client-script.ts
new file mode 100644
index 000000000..5bcf56cc7
--- /dev/null
+++ b/apps/server/src/services/threads/app-client-script.ts
@@ -0,0 +1,445 @@
+import type { AppId } from "@bb/domain";
+import type { AppCapability } from "@bb/server-contract";
+
+export interface AppClientBootstrap {
+  appId: AppId;
+  capabilities: AppCapability[];
+  dataUrl: string;
+  messageUrl: string;
+  threadId: string;
+  wsUrl: string;
+}
+
+interface CreateAppClientScriptArgs {
+  bootstrap: AppClientBootstrap;
+}
+
+const APP_CLIENT_SCRIPT_MARKER = "data-bb-app-client";
+
+function escapedJsonForInlineScript(value: AppClientBootstrap): string {
+  return JSON.stringify(value).replace(/</gu, "\\u003c");
+}
+
+export function createAppClientScript(args: CreateAppClientScriptArgs): string {
+  const bootstrapJson = escapedJsonForInlineScript(args.bootstrap);
+  return `<script ${APP_CLIENT_SCRIPT_MARKER}>${buildAppClientJavascript(
+    bootstrapJson,
+  )}</script>`;
+}
+
+export function injectAppClientScript(
+  html: string,
+  bootstrap: AppClientBootstrap,
+): string {
+  if (html.includes(APP_CLIENT_SCRIPT_MARKER)) {
+    return html;
+  }
+
+  const script = createAppClientScript({ bootstrap });
+  const firstScriptIndex = html.search(/<script\b/iu);
+  const headCloseIndex = html.search(/<\/head>/iu);
+  if (firstScriptIndex !== -1) {
+    return `${html.slice(0, firstScriptIndex)}${script}${html.slice(
+      firstScriptIndex,
+    )}`;
+  }
+  if (headCloseIndex !== -1) {
+    return `${html.slice(0, headCloseIndex)}${script}${html.slice(
+      headCloseIndex,
+    )}`;
+  }
+
+  const htmlOpenMatch = /<html\b[^>]*>/iu.exec(html);
+  if (htmlOpenMatch?.index !== undefined) {
+    const insertIndex = htmlOpenMatch.index + htmlOpenMatch[0].length;
+    return `${html.slice(0, insertIndex)}${script}${html.slice(insertIndex)}`;
+  }
+
+  return `${script}${html}`;
+}
+
+function buildAppClientJavascript(bootstrapJson: string): string {
+  return `
+(function () {
+  var bootstrap = ${bootstrapJson};
+  var capabilities = Object.create(null);
+  bootstrap.capabilities.forEach(function (capability) {
+    capabilities[capability] = true;
+  });
+
+  function hasCapability(name) {
+    return capabilities[name] === true;
+  }
+
+  function cloneValue(value) {
+    if (value === undefined) return undefined;
+    return JSON.parse(JSON.stringify(value));
+  }
+
+  function isJsonValue(value) {
+    if (value === null) return true;
+    var type = typeof value;
+    if (type === "string" || type === "boolean") return true;
+    if (type === "number") return Number.isFinite(value);
+    if (Array.isArray(value)) return value.every(isJsonValue);
+    if (type !== "object") return false;
+    var proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) return false;
+    return Object.keys(value).every(function (key) {
+      return isJsonValue(value[key]);
+    });
+  }
+
+  function validatePath(path, allowEmpty) {
+    // Keep these app-data path limits in sync with packages/domain/src/apps.ts.
+    if (allowEmpty && path === "") return;
+    if (typeof path !== "string") {
+      throw new Error("App data path must be a string");
+    }
+    if (
+      path.length === 0 ||
+      path.length > 512 ||
+      path.indexOf("\\\\") !== -1 ||
+      path.indexOf(String.fromCharCode(0)) !== -1 ||
+      path.charAt(0) === "/" ||
+      path.charAt(path.length - 1) === "/"
+    ) {
+      throw new Error("Invalid app data path: " + String(path));
+    }
+    var segments = path.split("/");
+    if (segments.length > 8) {
+      throw new Error("App data path is too deep: " + path);
+    }
+    for (var index = 0; index < segments.length; index += 1) {
+      var segment = segments[index];
+      if (
+        segment === "." ||
+        segment === ".." ||
+        segment.charAt(0) === "." ||
+        !/^[A-Za-z0-9._-]{1,80}$/.test(segment)
+      ) {
+        throw new Error("Invalid app data path segment: " + String(segment));
+      }
+    }
+  }
+
+  function dataPathUrl(path) {
+    validatePath(path, false);
+    return bootstrap.dataUrl + "/" + path.split("/").map(encodeURIComponent).join("/");
+  }
+
+  function buildError(response, text) {
+    var message = response.statusText || ("HTTP " + response.status);
+    var code = null;
+    if (text) {
+      try {
+        var body = JSON.parse(text);
+        if (body && typeof body === "object" && typeof body.message === "string") {
+          message = body.message;
+          if (typeof body.code === "string") code = body.code;
+        } else {
+          message = text;
+        }
+      } catch (error) {
+        message = text;
+      }
+    }
+    var appError = new Error(message);
+    appError.status = response.status;
+    if (code) appError.code = code;
+    return appError;
+  }
+
+  function rejectResponse(response) {
+    return response.text().then(function (text) {
+      throw buildError(response, text);
+    });
+  }
+
+  function read(path) {
+    return fetch(dataPathUrl(path), {
+      method: "GET",
+      credentials: "same-origin",
+      headers: { "Accept": "application/json" }
+    }).then(function (response) {
+      if (response.status === 404) return undefined;
+      if (!response.ok) return rejectResponse(response);
+      return response.json().then(function (entry) {
+        return cloneValue(entry.value);
+      });
+    });
+  }
+
+  function write(path, value) {
+    validatePath(path, false);
+    if (value === undefined || !isJsonValue(value)) {
+      return Promise.reject(new Error("bb.data.write requires a JSON value"));
+    }
+    return fetch(dataPathUrl(path), {
+      method: "PUT",
+      credentials: "same-origin",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ value: value })
+    }).then(function (response) {
+      if (response.ok) return undefined;
+      return rejectResponse(response);
+    });
+  }
+
+  function deletePath(path) {
+    return fetch(dataPathUrl(path), {
+      method: "DELETE",
+      credentials: "same-origin",
+      headers: { "Accept": "application/json" }
+    }).then(function (response) {
+      if (response.ok) return undefined;
+      return rejectResponse(response);
+    });
+  }
+
+  function listEntries(prefix) {
+    var effectivePrefix = prefix === undefined ? "" : prefix;
+    validatePath(effectivePrefix, true);
+    var url = bootstrap.dataUrl;
+    if (effectivePrefix !== "") {
+      url += "?prefix=" + encodeURIComponent(effectivePrefix);
+    }
+    return fetch(url, {
+      method: "GET",
+      credentials: "same-origin",
+      headers: { "Accept": "application/json" }
+    }).then(function (response) {
+      if (!response.ok) return rejectResponse(response);
+      return response.json().then(function (body) {
+        return body.entries.map(function (entry) {
+          return {
+            path: entry.path,
+            value: cloneValue(entry.value),
+            version: entry.version
+          };
+        });
+      });
+    });
+  }
+
+  function list(prefix) {
+    return listEntries(prefix).then(function (entries) {
+      return entries.map(function (entry) {
+        return { path: entry.path, value: cloneValue(entry.value) };
+      });
+    });
+  }
+
+  var socket = null;
+  var reconnectTimer = null;
+  var reconnectDelay = 1000;
+  var listeners = [];
+  var socketHasOpened = false;
+  var subscriptionReady = null;
+  var resolveSubscriptionReady = null;
+
+  function pathMatchesPrefix(path, prefix) {
+    return prefix === "" || path === prefix || path.indexOf(prefix + "/") === 0;
+  }
+
+  function callListener(listener, event) {
+    if (!pathMatchesPrefix(event.path, listener.prefix)) return;
+    try {
+      listener.callback({
+        path: event.path,
+        value: event.deleted ? undefined : cloneValue(event.value),
+        deleted: event.deleted
+      });
+    } catch (error) {
+      console.error("window.bb.data.onChange callback failed", error);
+    }
+  }
+
+  function deliverOrBufferListener(listener, event) {
+    if (!pathMatchesPrefix(event.path, listener.prefix)) return;
+    if (listener.replaying) {
+      listener.bufferedEvents.push(event);
+      return;
+    }
+    callListener(listener, event);
+  }
+
+  function handleBroadcast(message) {
+    if (
+      !message ||
+      message.threadId !== bootstrap.threadId ||
+      message.appId !== bootstrap.appId
+    ) {
+      return;
+    }
+    if (message.type === "app-data.resync") {
+      listeners.slice().forEach(function (listener) {
+        replayExisting(listener);
+      });
+      return;
+    }
+    if (message.type !== "app-data.changed") {
+      return;
+    }
+    var event = {
+      path: message.path,
+      value: message.deleted ? undefined : cloneValue(message.value),
+      deleted: message.deleted,
+      version: message.version
+    };
+    listeners.slice().forEach(function (listener) {
+      deliverOrBufferListener(listener, event);
+    });
+  }
+
+  function resetSubscriptionReady() {
+    subscriptionReady = new Promise(function (resolve) {
+      resolveSubscriptionReady = resolve;
+    });
+  }
+
+  function connectSocket() {
+    if (!subscriptionReady) resetSubscriptionReady();
+    if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return subscriptionReady;
+    socket = new WebSocket(bootstrap.wsUrl);
+    socket.onopen = function () {
+      var reconnected = socketHasOpened;
+      socketHasOpened = true;
+      reconnectDelay = 1000;
+      socket.send(JSON.stringify({
+        type: "subscribe",
+        entity: "thread",
+        id: bootstrap.threadId + ":app:" + bootstrap.appId + ":data"
+      }));
+      if (resolveSubscriptionReady) {
+        resolveSubscriptionReady();
+        resolveSubscriptionReady = null;
+      }
+      if (reconnected) {
+        listeners.slice().forEach(function (listener) {
+          replayExisting(listener);
+        });
+      }
+    };
+    socket.onmessage = function (event) {
+      if (typeof event.data !== "string") return;
+      try {
+        handleBroadcast(JSON.parse(event.data));
+      } catch (error) {
+        console.error("window.bb ignored invalid realtime message", error);
+      }
+    };
+    socket.onclose = function () {
+      resetSubscriptionReady();
+      if (reconnectTimer) return;
+      reconnectTimer = setTimeout(function () {
+        reconnectTimer = null;
+        reconnectDelay = Math.min(reconnectDelay * 1.5, 30000);
+        connectSocket();
+      }, reconnectDelay);
+    };
+    socket.onerror = function () {
+      if (socket) socket.close();
+    };
+    return subscriptionReady;
+  }
+
+  function replayExisting(listener) {
+    listener.replayPromise = (listener.replayPromise || Promise.resolve()).then(function () {
+      listener.replaying = true;
+      listener.bufferedEvents = [];
+      return connectSocket().then(function () {
+        return listEntries(listener.prefix);
+      }).then(function (entries) {
+        var replayedVersions = Object.create(null);
+        entries.forEach(function (entry) {
+          replayedVersions[entry.path] = entry.version;
+          callListener(listener, {
+            path: entry.path,
+            value: entry.value,
+            deleted: false
+          });
+        });
+        listener.bufferedEvents.forEach(function (event) {
+          if (!event.deleted && replayedVersions[event.path] === event.version) return;
+          callListener(listener, event);
+        });
+      }).finally(function () {
+        listener.replaying = false;
+        listener.bufferedEvents = [];
+      });
+    }).catch(function (error) {
+      console.error("window.bb.data.onChange replay failed", error);
+    });
+    return listener.replayPromise;
+  }
+
+  function onChange(prefix, callback) {
+    var effectivePrefix = prefix === undefined ? "" : prefix;
+    validatePath(effectivePrefix, true);
+    if (typeof callback !== "function") {
+      throw new Error("bb.data.onChange requires a callback");
+    }
+    var listener = {
+      prefix: effectivePrefix,
+      callback: callback,
+      replaying: false,
+      bufferedEvents: [],
+      replayPromise: null
+    };
+    listeners.push(listener);
+    replayExisting(listener);
+    return function () {
+      listeners = listeners.filter(function (candidate) {
+        return candidate !== listener;
+      });
+    };
+  }
+
+  function message(text) {
+    if (typeof text !== "string") {
+      throw new TypeError("window.bb.message(text) requires a string");
+    }
+    return fetch(bootstrap.messageUrl, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text: text })
+    }).then(function (response) {
+      if (response.ok) return undefined;
+      return rejectResponse(response);
+    });
+  }
+
+  var bb = { appId: bootstrap.appId };
+  if (hasCapability("data")) {
+    bb.data = {
+      read: read,
+      write: write,
+      delete: deletePath,
+      list: list,
+      onChange: onChange
+    };
+  }
+  if (hasCapability("message")) {
+    bb.message = message;
+  }
+
+  try {
+    Object.defineProperty(window, "bb", {
+      value: bb,
+      configurable: true,
+      writable: false
+    });
+  } catch (error) {
+    window.bb = bb;
+  }
+})();
+`;
+}
diff --git a/apps/server/src/services/threads/default-template/apps/status/assets/index.html b/apps/server/src/services/threads/default-template/apps/status/assets/index.html
new file mode 100644
index 000000000..2df721196
--- /dev/null
+++ b/apps/server/src/services/threads/default-template/apps/status/assets/index.html
@@ -0,0 +1,273 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Status</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        --bg: #f8fafc;
+        --panel: #ffffff;
+        --text: #111827;
+        --muted: #6b7280;
+        --border: #d1d5db;
+        --accent: #2563eb;
+        --soft: #eff6ff;
+        --ok: #047857;
+        --warn: #b45309;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --bg: #0f172a;
+          --panel: #111827;
+          --text: #f8fafc;
+          --muted: #9ca3af;
+          --border: #374151;
+          --accent: #60a5fa;
+          --soft: #172554;
+          --ok: #34d399;
+          --warn: #fbbf24;
+        }
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        background: var(--bg);
+        color: var(--text);
+        font: 13px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      main {
+        display: grid;
+        gap: 16px;
+        padding: 16px;
+      }
+
+      header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+      }
+
+      h1,
+      h2,
+      p {
+        margin: 0;
+      }
+
+      h1 {
+        font-size: 17px;
+        font-weight: 650;
+      }
+
+      h2 {
+        font-size: 12px;
+        font-weight: 650;
+        letter-spacing: 0;
+        text-transform: uppercase;
+        color: var(--muted);
+      }
+
+      .pill {
+        display: inline-flex;
+        align-items: center;
+        min-height: 24px;
+        border: 1px solid var(--border);
+        border-radius: 999px;
+        padding: 2px 9px;
+        background: var(--panel);
+        color: var(--muted);
+        white-space: nowrap;
+      }
+
+      section {
+        display: grid;
+        gap: 8px;
+      }
+
+      .rows {
+        display: grid;
+        gap: 8px;
+      }
+
+      .row {
+        display: grid;
+        gap: 4px;
+        border: 1px solid var(--border);
+        border-radius: 8px;
+        background: var(--panel);
+        padding: 10px;
+      }
+
+      .row-title {
+        font-weight: 600;
+      }
+
+      .row-meta {
+        color: var(--muted);
+        overflow-wrap: anywhere;
+      }
+
+      .empty {
+        border: 1px dashed var(--border);
+        border-radius: 8px;
+        padding: 14px;
+        color: var(--muted);
+      }
+
+      form {
+        display: grid;
+        grid-template-columns: 1fr auto;
+        gap: 8px;
+      }
+
+      textarea {
+        min-height: 38px;
+        max-height: 160px;
+        resize: vertical;
+        border: 1px solid var(--border);
+        border-radius: 8px;
+        padding: 8px 10px;
+        background: var(--panel);
+        color: var(--text);
+        font: inherit;
+      }
+
+      button {
+        border: 1px solid var(--accent);
+        border-radius: 8px;
+        padding: 0 12px;
+        background: var(--accent);
+        color: white;
+        font: inherit;
+        font-weight: 600;
+        cursor: pointer;
+      }
+
+      button:disabled {
+        cursor: default;
+        opacity: 0.55;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>Status</h1>
+        <span class="pill" id="landing-mode">pr</span>
+      </header>
+
+      <section>
+        <h2>Pull Requests</h2>
+        <div class="rows" id="prs"></div>
+      </section>
+
+      <section>
+        <h2>Workers</h2>
+        <div class="rows" id="workers"></div>
+      </section>
+
+      <form id="message-form">
+        <textarea id="message-text" placeholder="Message the manager"></textarea>
+        <button type="submit">Send</button>
+      </form>
+    </main>
+
+    <script>
+      var state = { prefs: { landingMode: "pr" }, prs: [], workers: [] };
+
+      function text(value) {
+        return value === null || value === undefined ? "" : String(value);
+      }
+
+      function renderRows(element, rows, emptyText, title) {
+        element.textContent = "";
+        if (!Array.isArray(rows) || rows.length === 0) {
+          var empty = document.createElement("div");
+          empty.className = "empty";
+          empty.textContent = emptyText;
+          element.appendChild(empty);
+          return;
+        }
+        rows.forEach(function (row) {
+          var item = document.createElement("article");
+          item.className = "row";
+          var itemTitle = document.createElement("div");
+          itemTitle.className = "row-title";
+          itemTitle.textContent = title(row);
+          var meta = document.createElement("div");
+          meta.className = "row-meta";
+          meta.textContent = [row.state, row.updatedAt, row.threadId, row.url]
+            .map(text)
+            .filter(Boolean)
+            .join(" - ");
+          item.appendChild(itemTitle);
+          if (meta.textContent) item.appendChild(meta);
+          element.appendChild(item);
+        });
+      }
+
+      function render() {
+        document.getElementById("landing-mode").textContent =
+          text(state.prefs && state.prefs.landingMode) || "pr";
+        renderRows(
+          document.getElementById("prs"),
+          state.prs,
+          "No pull requests tracked",
+          function (row) {
+            return row.number ? "#" + row.number + " " + text(row.title) : text(row.title || row.url);
+          }
+        );
+        renderRows(
+          document.getElementById("workers"),
+          state.workers,
+          "No workers tracked",
+          function (row) {
+            return text(row.description || row.threadId);
+          }
+        );
+      }
+
+      function install() {
+        if (!window.bb || !window.bb.data) {
+          render();
+          return;
+        }
+        window.bb.data.onChange("state.json", function (event) {
+          if (!event.deleted && event.value && typeof event.value === "object") {
+            state = event.value;
+          }
+          render();
+        });
+        var form = document.getElementById("message-form");
+        var input = document.getElementById("message-text");
+        form.addEventListener("submit", function (event) {
+          event.preventDefault();
+          var message = input.value.trim();
+          if (!message || !window.bb.message) return;
+          form.querySelector("button").disabled = true;
+          window.bb.message(message).then(
+            function () {
+              input.value = "";
+              form.querySelector("button").disabled = false;
+            },
+            function () {
+              form.querySelector("button").disabled = false;
+            }
+          );
+        });
+      }
+
+      render();
+      install();
+    </script>
+  </body>
+</html>
diff --git a/apps/server/src/services/threads/default-template/apps/status/data/state.json b/apps/server/src/services/threads/default-template/apps/status/data/state.json
new file mode 100644
index 000000000..d339df6c7
--- /dev/null
+++ b/apps/server/src/services/threads/default-template/apps/status/data/state.json
@@ -0,0 +1,7 @@
+{
+  "prefs": {
+    "landingMode": "pr"
+  },
+  "prs": [],
+  "workers": []
+}
diff --git a/apps/server/src/services/threads/default-template/apps/status/manifest.json b/apps/server/src/services/threads/default-template/apps/status/manifest.json
new file mode 100644
index 000000000..8f83d9dc3
--- /dev/null
+++ b/apps/server/src/services/threads/default-template/apps/status/manifest.json
@@ -0,0 +1,9 @@
+{
+  "manifestVersion": 1,
+  "id": "status",
+  "name": "Status",
+  "icon": "ListTodo",
+  "entry": "index.html",
+  "contributions": ["thread.app"],
+  "capabilities": ["data", "message"]
+}
diff --git a/apps/server/src/services/threads/manager-storage-templates.ts b/apps/server/src/services/threads/manager-storage-templates.ts
index 26074eb76..6041ebb0e 100644
--- a/apps/server/src/services/threads/manager-storage-templates.ts
+++ b/apps/server/src/services/threads/manager-storage-templates.ts
@@ -34,6 +34,11 @@ interface BuiltInManagerTemplateFile {
   fileName: string;
 }
 
+interface TemplateFileToCopy {
+  relativePath: string;
+  sourcePath: string;
+}
+
 interface BuiltInManagerTemplateSet {
   files: readonly BuiltInManagerTemplateFile[];
   name: ManagerTemplateName;
@@ -92,6 +97,18 @@ const BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET: BuiltInManagerTemplateSet = {
       fileName: "STATUS.html",
       content: loadDefaultTemplateAsset("STATUS.html"),
     },
+    {
+      fileName: "apps/status/manifest.json",
+      content: loadDefaultTemplateAsset("apps/status/manifest.json"),
+    },
+    {
+      fileName: "apps/status/assets/index.html",
+      content: loadDefaultTemplateAsset("apps/status/assets/index.html"),
+    },
+    {
+      fileName: "apps/status/data/state.json",
+      content: loadDefaultTemplateAsset("apps/status/data/state.json"),
+    },
   ],
 };
 
@@ -167,9 +184,9 @@ async function readActiveManagerTemplateName(
 async function copyTemplateFiles(
   args: CopyTemplateFilesArgs,
 ): Promise<CopyTemplateFilesResult> {
-  let entries: Dirent[];
+  let files: TemplateFileToCopy[];
   try {
-    entries = await readdir(args.templateDirPath, { withFileTypes: true });
+    files = await collectTemplateFiles(args.templateDirPath);
   } catch (error) {
     if (isFsErrorWithCode({ error, code: "ENOENT" })) {
       return "missing";
@@ -179,14 +196,15 @@ async function copyTemplateFiles(
 
   await mkdir(args.threadStoragePath, { recursive: true });
 
-  for (const entry of entries) {
-    if (!entry.isFile()) {
-      continue;
-    }
-    const sourcePath = path.join(args.templateDirPath, entry.name);
-    const destinationPath = path.join(args.threadStoragePath, entry.name);
+  for (const file of files) {
+    const destinationPath = path.join(args.threadStoragePath, file.relativePath);
     try {
-      await copyFile(sourcePath, destinationPath, fsConstants.COPYFILE_EXCL);
+      await mkdir(path.dirname(destinationPath), { recursive: true });
+      await copyFile(
+        file.sourcePath,
+        destinationPath,
+        fsConstants.COPYFILE_EXCL,
+      );
     } catch (error) {
       if (isFsErrorWithCode({ error, code: "EEXIST" })) {
         continue;
@@ -194,7 +212,7 @@ async function copyTemplateFiles(
       if (isFsErrorWithCode({ error, code: "ENOENT" })) {
         args.logger.warn(
           {
-            sourcePath,
+            sourcePath: file.sourcePath,
             templateName: args.templateName,
             threadId: args.threadId,
           },
@@ -209,6 +227,42 @@ async function copyTemplateFiles(
   return "copied";
 }
 
+async function collectTemplateFiles(
+  rootPath: string,
+): Promise<TemplateFileToCopy[]> {
+  const pendingDirs = [rootPath];
+  const files: TemplateFileToCopy[] = [];
+
+  while (pendingDirs.length > 0) {
+    const currentDir = pendingDirs.shift();
+    if (!currentDir) {
+      continue;
+    }
+    const entries: Dirent[] = await readdir(currentDir, {
+      withFileTypes: true,
+    });
+    for (const entry of entries) {
+      const sourcePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        pendingDirs.push(sourcePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      files.push({
+        sourcePath,
+        relativePath: path
+          .relative(rootPath, sourcePath)
+          .split(path.sep)
+          .join("/"),
+      });
+    }
+  }
+
+  return files;
+}
+
 async function copyBuiltInTemplateFiles(
   args: CopyBuiltInTemplateFilesArgs,
 ): Promise<void> {
@@ -217,6 +271,7 @@ async function copyBuiltInTemplateFiles(
   for (const file of args.files) {
     const destinationPath = path.join(args.threadStoragePath, file.fileName);
     try {
+      await mkdir(path.dirname(destinationPath), { recursive: true });
       await writeFile(destinationPath, file.content, {
         encoding: "utf8",
         flag: "wx",
diff --git a/apps/server/src/ws/hub.ts b/apps/server/src/ws/hub.ts
index d638c896d..3a66442e6 100644
--- a/apps/server/src/ws/hub.ts
+++ b/apps/server/src/ws/hub.ts
@@ -13,8 +13,10 @@ import type {
   HostDaemonSessionCloseReason,
 } from "@bb/host-daemon-contract";
 import {
+  appDataBroadcastMessageSchema,
   statusStateBroadcastMessageSchema,
   terminalServerMessageSchema,
+  type AppDataBroadcastMessage,
   type StatusStateBroadcastMessage,
   type TerminalServerMessage,
 } from "@bb/server-contract";
@@ -415,6 +417,13 @@ export class NotificationHub implements DbNotifier {
     );
   }
 
+  notifyThreadAppData(message: AppDataBroadcastMessage): void {
+    this.notifyClientsByKey(
+      subKey("thread", `${message.threadId}:app:${message.appId}:data`),
+      JSON.stringify(appDataBroadcastMessageSchema.parse(message)),
+    );
+  }
+
   notifyProject(projectId: string, changes: ProjectChangeKind[]): void {
     this.notifyClients({
       type: "changed",
diff --git a/apps/server/test/app/hub.test.ts b/apps/server/test/app/hub.test.ts
index c58bc6d56..3554b158c 100644
--- a/apps/server/test/app/hub.test.ts
+++ b/apps/server/test/app/hub.test.ts
@@ -87,6 +87,52 @@ describe("NotificationHub", () => {
     expect(socket.messages).toHaveLength(0);
   });
 
+  it("subscribes clients and delivers app data broadcasts", () => {
+    const hub = new NotificationHub();
+    const socket = createMockSocket();
+
+    hub.subscribe(socket, "thread", "thread-1:app:status:data");
+    hub.notifyThreadAppData({
+      type: "app-data.changed",
+      threadId: "thread-1",
+      appId: "status",
+      path: "state.json",
+      value: { workers: [] },
+      deleted: false,
+      version: "version-1",
+    });
+
+    expect(socket.messages).toHaveLength(1);
+    expect(JSON.parse(socket.messages[0])).toEqual({
+      type: "app-data.changed",
+      threadId: "thread-1",
+      appId: "status",
+      path: "state.json",
+      value: { workers: [] },
+      deleted: false,
+      version: "version-1",
+    });
+  });
+
+  it("delivers app data resync broadcasts", () => {
+    const hub = new NotificationHub();
+    const socket = createMockSocket();
+
+    hub.subscribe(socket, "thread", "thread-1:app:status:data");
+    hub.notifyThreadAppData({
+      type: "app-data.resync",
+      threadId: "thread-1",
+      appId: "status",
+    });
+
+    expect(socket.messages).toHaveLength(1);
+    expect(JSON.parse(socket.messages[0])).toEqual({
+      type: "app-data.resync",
+      threadId: "thread-1",
+      appId: "status",
+    });
+  });
+
   it("cleans up subscriptions on client disconnect", () => {
     const hub = new NotificationHub();
     const socket = createMockSocket();
diff --git a/apps/server/test/internal/internal-app-data-change.test.ts b/apps/server/test/internal/internal-app-data-change.test.ts
new file mode 100644
index 000000000..4163e90cc
--- /dev/null
+++ b/apps/server/test/internal/internal-app-data-change.test.ts
@@ -0,0 +1,173 @@
+import { describe, expect, it, vi } from "vitest";
+import { internalAuthHeaders } from "../helpers/commands.js";
+import { readJson } from "../helpers/json.js";
+import {
+  seedEnvironment,
+  seedHostSession,
+  seedProjectWithSource,
+  seedThread,
+} from "../helpers/seed.js";
+import { createTestAppHarness } from "../helpers/test-app.js";
+
+describe("internal app-data change route", () => {
+  it("broadcasts daemon-reported app data changes for session-owned threads", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const { host, session } = seedHostSession(harness.deps, {
+        id: "host-app-data-change",
+      });
+      const { project } = seedProjectWithSource(harness.deps, {
+        hostId: host.id,
+      });
+      const environment = seedEnvironment(harness.deps, {
+        hostId: host.id,
+        projectId: project.id,
+        path: "/tmp/app-data-change",
+        status: "ready",
+      });
+      const thread = seedThread(harness.deps, {
+        projectId: project.id,
+        environmentId: environment.id,
+        type: "manager",
+      });
+      const notifyThreadAppDataSpy = vi.spyOn(
+        harness.hub,
+        "notifyThreadAppData",
+      );
+
+      const response = await harness.app.request(
+        "/internal/session/app-data-change",
+        {
+          method: "POST",
+          headers: internalAuthHeaders(harness),
+          body: JSON.stringify({
+            sessionId: session.id,
+            threadId: thread.id,
+            appId: "status",
+            path: "state.json",
+            value: { workers: [] },
+            deleted: false,
+            version: "version-next",
+          }),
+        },
+      );
+
+      expect(response.status).toBe(200);
+      expect(notifyThreadAppDataSpy).toHaveBeenCalledWith({
+        type: "app-data.changed",
+        threadId: thread.id,
+        appId: "status",
+        path: "state.json",
+        value: { workers: [] },
+        deleted: false,
+        version: "version-next",
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("rejects daemon-reported app data changes for threads owned by another host", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const hostA = seedHostSession(harness.deps, {
+        id: "host-app-data-change-a",
+      });
+      const hostB = seedHostSession(harness.deps, {
+        id: "host-app-data-change-b",
+      });
+      const { project } = seedProjectWithSource(harness.deps, {
+        hostId: hostB.host.id,
+      });
+      const environment = seedEnvironment(harness.deps, {
+        hostId: hostB.host.id,
+        projectId: project.id,
+        path: "/tmp/app-data-change-other",
+        status: "ready",
+      });
+      const thread = seedThread(harness.deps, {
+        projectId: project.id,
+        environmentId: environment.id,
+        type: "manager",
+      });
+      const notifyThreadAppDataSpy = vi.spyOn(
+        harness.hub,
+        "notifyThreadAppData",
+      );
+
+      const response = await harness.app.request(
+        "/internal/session/app-data-change",
+        {
+          method: "POST",
+          headers: internalAuthHeaders(harness),
+          body: JSON.stringify({
+            sessionId: hostA.session.id,
+            threadId: thread.id,
+            appId: "status",
+            path: "state.json",
+            value: null,
+            deleted: true,
+            version: null,
+          }),
+        },
+      );
+
+      expect(response.status).toBe(403);
+      await expect(readJson(response)).resolves.toMatchObject({
+        code: "invalid_request",
+      });
+      expect(notifyThreadAppDataSpy).not.toHaveBeenCalled();
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("broadcasts daemon-requested app data resync hints", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const { host, session } = seedHostSession(harness.deps, {
+        id: "host-app-data-resync",
+      });
+      const { project } = seedProjectWithSource(harness.deps, {
+        hostId: host.id,
+      });
+      const environment = seedEnvironment(harness.deps, {
+        hostId: host.id,
+        projectId: project.id,
+        path: "/tmp/app-data-resync",
+        status: "ready",
+      });
+      const thread = seedThread(harness.deps, {
+        projectId: project.id,
+        environmentId: environment.id,
+        type: "manager",
+      });
+      const notifyThreadAppDataSpy = vi.spyOn(
+        harness.hub,
+        "notifyThreadAppData",
+      );
+
+      const response = await harness.app.request(
+        "/internal/session/app-data-resync",
+        {
+          method: "POST",
+          headers: internalAuthHeaders(harness),
+          body: JSON.stringify({
+            sessionId: session.id,
+            threadId: thread.id,
+            appId: "status",
+          }),
+        },
+      );
+
+      expect(response.status).toBe(200);
+      expect(notifyThreadAppDataSpy).toHaveBeenCalledWith({
+        type: "app-data.resync",
+        threadId: thread.id,
+        appId: "status",
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+});
diff --git a/apps/server/test/public/public-thread-apps.test.ts b/apps/server/test/public/public-thread-apps.test.ts
new file mode 100644
index 000000000..67cf3e726
--- /dev/null
+++ b/apps/server/test/public/public-thread-apps.test.ts
@@ -0,0 +1,851 @@
+import { createHash } from "node:crypto";
+import type { HostDaemonCommand } from "@bb/host-daemon-contract";
+import {
+  appDataListResponseSchema,
+  appDataReadResponseSchema,
+  appDetailSchema,
+  appSummarySchema,
+  type AppManifest,
+} from "@bb/server-contract";
+import { describe, expect, it } from "vitest";
+import {
+  reportQueuedCommandError,
+  reportQueuedCommandSuccess,
+  waitForQueuedCommand,
+  waitForQueuedCommandAfter,
+  type QueuedCommand,
+} from "../helpers/commands.js";
+import { readJson } from "../helpers/json.js";
+import type { TestAppHarness } from "../helpers/test-app.js";
+import {
+  seedEnvironment,
+  seedHostSession,
+  seedProjectWithSource,
+  seedThread,
+} from "../helpers/seed.js";
+import { createTestAppHarness } from "../helpers/test-app.js";
+
+interface ManagerThreadStorageFixture {
+  hostId: string;
+  threadId: string;
+  storageRootPath: string;
+}
+
+interface ReadFileResultArgs {
+  content: string;
+  mimeType?: string;
+  path: string;
+}
+
+interface PathEntryArgs {
+  kind: "directory" | "file";
+  path: string;
+}
+
+interface ManifestReadArgs {
+  appId: string;
+  afterCursor?: number;
+  fixture: ManagerThreadStorageFixture;
+  harness: TestAppHarness;
+  manifest: AppManifest;
+}
+
+type WriteFileRelativeQueuedCommand = QueuedCommand<
+  Extract<HostDaemonCommand, { type: "host.write_file_relative" }>
+>;
+
+const STATUS_MANIFEST: AppManifest = {
+  manifestVersion: 1,
+  id: "status",
+  name: "Status",
+  icon: "ListTodo",
+  entry: "index.html",
+  contributions: ["thread.app"],
+  capabilities: ["data", "message"],
+};
+
+function seedManagerThreadStorage(
+  harness: TestAppHarness,
+): ManagerThreadStorageFixture {
+  const { host } = seedHostSession(harness.deps, {
+    id: "host-thread-apps",
+  });
+  const { project } = seedProjectWithSource(harness.deps, {
+    hostId: host.id,
+    path: "/tmp/project-source",
+  });
+  const environment = seedEnvironment(harness.deps, {
+    hostId: host.id,
+    projectId: project.id,
+    path: "/tmp/project-source",
+  });
+  const thread = seedThread(harness.deps, {
+    projectId: project.id,
+    environmentId: environment.id,
+    type: "manager",
+  });
+  return {
+    hostId: host.id,
+    threadId: thread.id,
+    storageRootPath: `/tmp/bb-host-data/${host.id}/thread-storage/${thread.id}`,
+  };
+}
+
+function appRoot(fixture: ManagerThreadStorageFixture, appId: string): string {
+  return `${fixture.storageRootPath}/apps/${appId}`;
+}
+
+function appAssetsRoot(
+  fixture: ManagerThreadStorageFixture,
+  appId: string,
+): string {
+  return `${appRoot(fixture, appId)}/assets`;
+}
+
+function appDataRoot(
+  fixture: ManagerThreadStorageFixture,
+  appId: string,
+): string {
+  return `${appRoot(fixture, appId)}/data`;
+}
+
+function sha256Text(content: string): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+function readFileResult(args: ReadFileResultArgs) {
+  return {
+    path: args.path,
+    content: args.content,
+    contentEncoding: "utf8" as const,
+    ...(args.mimeType ? { mimeType: args.mimeType } : {}),
+    sizeBytes: Buffer.byteLength(args.content),
+  };
+}
+
+function pathEntry(args: PathEntryArgs) {
+  return {
+    kind: args.kind,
+    path: args.path,
+    name: args.path.split("/").at(-1) ?? args.path,
+    score: 1,
+    positions: [],
+  };
+}
+
+function requireWriteFileRelativeCommand(
+  queued: QueuedCommand,
+): WriteFileRelativeQueuedCommand {
+  if (queued.command.type === "host.write_file_relative") {
+    return {
+      command: queued.command,
+      row: queued.row,
+    };
+  }
+  throw new Error("Expected host.write_file_relative command");
+}
+
+async function reportManifestRead(args: ManifestReadArgs): Promise<QueuedCommand> {
+  const queued = args.afterCursor
+    ? await waitForQueuedCommandAfter(
+        args.harness,
+        args.afterCursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(args.fixture, args.appId) &&
+          command.path === "manifest.json",
+      )
+    : await waitForQueuedCommand(
+        args.harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(args.fixture, args.appId) &&
+          command.path === "manifest.json",
+      );
+  const content = `${JSON.stringify(args.manifest, null, 2)}\n`;
+  await reportQueuedCommandSuccess(
+    args.harness,
+    queued,
+    readFileResult({
+      path: "manifest.json",
+      content,
+      mimeType: "application/json",
+    }),
+  );
+  return queued;
+}
+
+describe("public thread app routes", () => {
+  it("lists app summaries from daemon-owned manifests", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps`,
+      );
+      const listCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === `${fixture.storageRootPath}/apps`,
+      );
+      await reportQueuedCommandSuccess(harness, listCommand, {
+        paths: [
+          pathEntry({ kind: "directory", path: "demo" }),
+          pathEntry({ kind: "directory", path: "status" }),
+        ],
+        truncated: false,
+      });
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "demo",
+        afterCursor: listCommand.row.cursor,
+        manifest: {
+          ...STATUS_MANIFEST,
+          id: "demo",
+          name: "Demo",
+          icon: "GridView",
+        },
+      });
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: listCommand.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      const apps = appSummarySchema.array().parse(await readJson(response));
+      expect(apps.map((app) => app.id)).toEqual(["demo", "status"]);
+      expect(apps[0]?.icon).toEqual({ kind: "builtin", name: "GridView" });
+      expect(apps[1]?.icon).toEqual({ kind: "builtin", name: "ListTodo" });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("serves HTML app entries with capability-scoped window.bb injection", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const html = "<!doctype html><html><head></head><body>Status</body></html>";
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/`,
+      );
+      const manifestCommand = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const metadataCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path === `${appAssetsRoot(fixture, "status")}/index.html`,
+      );
+      await reportQueuedCommandSuccess(harness, metadataCommand, {
+        path: `${appAssetsRoot(fixture, "status")}/index.html`,
+        modifiedAtMs: 1234,
+        sizeBytes: Buffer.byteLength(html),
+      });
+      const entryCommand = await waitForQueuedCommandAfter(
+        harness,
+        metadataCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appAssetsRoot(fixture, "status") &&
+          command.path === "index.html",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        entryCommand,
+        readFileResult({
+          path: "index.html",
+          content: html,
+          mimeType: "text/html",
+        }),
+      );
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe(
+        "text/html; charset=utf-8",
+      );
+      const body = await response.text();
+      expect(body).toContain("data-bb-app-client");
+      expect(body).toContain("window.bb");
+      expect(body).toContain('"capabilities":["data","message"]');
+      expect(body).toContain("<body>Status</body>");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("proxies app data list, read, write, and delete through generic daemon file commands", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const stateJson = `${JSON.stringify({ workers: [] }, null, 2)}\n`;
+
+      const listRequest = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/data`,
+      );
+      const listManifest = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const listCommand = await waitForQueuedCommandAfter(
+        harness,
+        listManifest.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === appDataRoot(fixture, "status"),
+      );
+      await reportQueuedCommandSuccess(harness, listCommand, {
+        paths: [pathEntry({ kind: "file", path: "state.json" })],
+        truncated: false,
+      });
+      const listRead = await waitForQueuedCommandAfter(
+        harness,
+        listCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "state.json",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        listRead,
+        readFileResult({
+          path: "state.json",
+          content: stateJson,
+          mimeType: "application/json",
+        }),
+      );
+      const listMetadata = await waitForQueuedCommandAfter(
+        harness,
+        listCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path === `${appDataRoot(fixture, "status")}/state.json`,
+      );
+      await reportQueuedCommandSuccess(harness, listMetadata, {
+        path: `${appDataRoot(fixture, "status")}/state.json`,
+        modifiedAtMs: 1234,
+        sizeBytes: Buffer.byteLength(stateJson),
+      });
+      const listResponse = await listRequest;
+      expect(listResponse.status).toBe(200);
+      expect(appDataListResponseSchema.parse(await readJson(listResponse))).toEqual({
+        entries: [
+          {
+            path: "state.json",
+            value: { workers: [] },
+            version: sha256Text(stateJson),
+            sizeBytes: Buffer.byteLength(stateJson),
+            modifiedAtMs: 1234,
+          },
+        ],
+      });
+
+      const readRequest = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/data/state.json`,
+      );
+      const readManifest = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: listMetadata.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+      const readCommand = await waitForQueuedCommandAfter(
+        harness,
+        readManifest.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "state.json",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        readCommand,
+        readFileResult({
+          path: "state.json",
+          content: stateJson,
+          mimeType: "application/json",
+        }),
+      );
+      const readMetadata = await waitForQueuedCommandAfter(
+        harness,
+        readManifest.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path === `${appDataRoot(fixture, "status")}/state.json`,
+      );
+      await reportQueuedCommandSuccess(harness, readMetadata, {
+        path: `${appDataRoot(fixture, "status")}/state.json`,
+        modifiedAtMs: 2345,
+        sizeBytes: Buffer.byteLength(stateJson),
+      });
+      const readResponse = await readRequest;
+      expect(readResponse.status).toBe(200);
+      expect(appDataReadResponseSchema.parse(await readJson(readResponse))).toEqual(
+        {
+          path: "state.json",
+          value: { workers: [] },
+          version: sha256Text(stateJson),
+          sizeBytes: Buffer.byteLength(stateJson),
+          modifiedAtMs: 2345,
+        },
+      );
+
+      const nextValue = { workers: [{ id: "worker-1" }] };
+      const nextJson = `${JSON.stringify(nextValue, null, 2)}\n`;
+      const writeRequest = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/data/state.json`,
+        {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ value: nextValue }),
+        },
+      );
+      const writeManifest = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: readMetadata.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+      const writeCommand = await waitForQueuedCommandAfter(
+        harness,
+        writeManifest.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "state.json",
+      );
+      expect(writeCommand.command).toMatchObject({
+        dotfiles: "deny",
+        content: nextJson,
+        contentEncoding: "utf8",
+      });
+      await reportQueuedCommandSuccess(harness, writeCommand, {
+        path: "state.json",
+        hash: sha256Text(nextJson),
+        modifiedAtMs: 3456,
+        sizeBytes: Buffer.byteLength(nextJson),
+      });
+      const writeResponse = await writeRequest;
+      expect(writeResponse.status).toBe(200);
+      expect(appDataReadResponseSchema.parse(await readJson(writeResponse))).toEqual(
+        {
+          path: "state.json",
+          value: nextValue,
+          version: sha256Text(nextJson),
+          sizeBytes: Buffer.byteLength(nextJson),
+          modifiedAtMs: 3456,
+        },
+      );
+
+      const deleteRequest = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/data/state.json`,
+        { method: "DELETE" },
+      );
+      const deleteManifest = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: writeCommand.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+      const deleteCommand = await waitForQueuedCommandAfter(
+        harness,
+        deleteManifest.row.cursor,
+        ({ command }) =>
+          command.type === "host.delete_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "state.json",
+      );
+      await reportQueuedCommandSuccess(harness, deleteCommand, {
+        path: "state.json",
+        deleted: true,
+        previousHash: sha256Text(nextJson),
+      });
+      const deleteResponse = await deleteRequest;
+      expect(deleteResponse.status).toBe(200);
+      await expect(readJson(deleteResponse)).resolves.toEqual({ ok: true });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("lists app data subtree prefixes when the prefix is a directory", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const oneJson = `${JSON.stringify({ title: "One" }, null, 2)}\n`;
+      const twoJson = `${JSON.stringify({ title: "Two" }, null, 2)}\n`;
+
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/data?prefix=tasks`,
+      );
+      const manifestCommand = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const prefixRead = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "tasks",
+      );
+      await reportQueuedCommandError(harness, prefixRead, {
+        errorCode: "invalid_path",
+        errorMessage: "Path is a directory, not a file",
+      });
+      const listCommand = await waitForQueuedCommandAfter(
+        harness,
+        prefixRead.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === `${appDataRoot(fixture, "status")}/tasks`,
+      );
+      await reportQueuedCommandSuccess(harness, listCommand, {
+        paths: [
+          pathEntry({ kind: "file", path: "one.json" }),
+          pathEntry({ kind: "file", path: "nested/two.json" }),
+        ],
+        truncated: false,
+      });
+
+      const oneRead = await waitForQueuedCommandAfter(
+        harness,
+        listCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "tasks/one.json",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        oneRead,
+        readFileResult({
+          path: "tasks/one.json",
+          content: oneJson,
+          mimeType: "application/json",
+        }),
+      );
+      const twoRead = await waitForQueuedCommandAfter(
+        harness,
+        listCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appDataRoot(fixture, "status") &&
+          command.path === "tasks/nested/two.json",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        twoRead,
+        readFileResult({
+          path: "tasks/nested/two.json",
+          content: twoJson,
+          mimeType: "application/json",
+        }),
+      );
+      const oneMetadata = await waitForQueuedCommandAfter(
+        harness,
+        oneRead.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path === `${appDataRoot(fixture, "status")}/tasks/one.json`,
+      );
+      await reportQueuedCommandSuccess(harness, oneMetadata, {
+        path: `${appDataRoot(fixture, "status")}/tasks/one.json`,
+        modifiedAtMs: 1111,
+        sizeBytes: Buffer.byteLength(oneJson),
+      });
+      const twoMetadata = await waitForQueuedCommandAfter(
+        harness,
+        twoRead.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path ===
+            `${appDataRoot(fixture, "status")}/tasks/nested/two.json`,
+      );
+      await reportQueuedCommandSuccess(harness, twoMetadata, {
+        path: `${appDataRoot(fixture, "status")}/tasks/nested/two.json`,
+        modifiedAtMs: 2222,
+        sizeBytes: Buffer.byteLength(twoJson),
+      });
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      expect(appDataListResponseSchema.parse(await readJson(response))).toEqual({
+        entries: [
+          {
+            path: "tasks/nested/two.json",
+            value: { title: "Two" },
+            version: sha256Text(twoJson),
+            sizeBytes: Buffer.byteLength(twoJson),
+            modifiedAtMs: 2222,
+          },
+          {
+            path: "tasks/one.json",
+            value: { title: "One" },
+            version: sha256Text(oneJson),
+            sizeBytes: Buffer.byteLength(oneJson),
+            modifiedAtMs: 1111,
+          },
+        ],
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("serves top-level logo icons and 404s built-in icons", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const logoManifest: AppManifest = {
+        manifestVersion: 1,
+        id: "demo",
+        name: "Demo",
+        entry: "index.html",
+        contributions: ["thread.app"],
+        capabilities: ["data", "message"],
+      };
+      const logoSvg = '<svg xmlns="http://www.w3.org/2000/svg"></svg>';
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/demo/icon`,
+      );
+      const manifestCommand = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "demo",
+        manifest: logoManifest,
+      });
+      const logoListCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === appRoot(fixture, "demo"),
+      );
+      await reportQueuedCommandSuccess(harness, logoListCommand, {
+        paths: [pathEntry({ kind: "file", path: "logo.svg" })],
+        truncated: false,
+      });
+      const metadataCommand = await waitForQueuedCommandAfter(
+        harness,
+        logoListCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.file_metadata" &&
+          command.path === `${appRoot(fixture, "demo")}/logo.svg`,
+      );
+      await reportQueuedCommandSuccess(harness, metadataCommand, {
+        path: `${appRoot(fixture, "demo")}/logo.svg`,
+        modifiedAtMs: 4567,
+        sizeBytes: Buffer.byteLength(logoSvg),
+      });
+      const readCommand = await waitForQueuedCommandAfter(
+        harness,
+        metadataCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(fixture, "demo") &&
+          command.path === "logo.svg",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        readCommand,
+        readFileResult({
+          path: "logo.svg",
+          content: logoSvg,
+          mimeType: "image/svg+xml",
+        }),
+      );
+      const response = await request;
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("image/svg+xml");
+      await expect(response.text()).resolves.toBe(logoSvg);
+
+      const builtInRequest = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/icon`,
+      );
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: readCommand.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+      const builtInResponse = await builtInRequest;
+      expect(builtInResponse.status).toBe(404);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("does not serve logo symlinks omitted by the daemon path listing", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const logoManifest: AppManifest = {
+        manifestVersion: 1,
+        id: "demo",
+        name: "Demo",
+        entry: "index.html",
+        contributions: ["thread.app"],
+        capabilities: ["data", "message"],
+      };
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/demo/icon`,
+      );
+      const manifestCommand = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "demo",
+        manifest: logoManifest,
+      });
+      const logoListCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === appRoot(fixture, "demo"),
+      );
+      await reportQueuedCommandSuccess(harness, logoListCommand, {
+        paths: [pathEntry({ kind: "file", path: "manifest.json" })],
+        truncated: false,
+      });
+
+      const response = await request;
+      expect(response.status).toBe(404);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("scaffolds status-template apps through the server lifecycle route", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            id: "demo",
+            name: "Demo",
+            template: "status",
+          }),
+        },
+      );
+      const existingCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(fixture, "demo") &&
+          command.path === "manifest.json",
+      );
+      await reportQueuedCommandError(harness, existingCommand, {
+        errorCode: "ENOENT",
+        errorMessage: "Path does not exist: manifest.json",
+      });
+
+      const manifestWrite = await waitForQueuedCommandAfter(
+        harness,
+        existingCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "demo") &&
+          command.path === "manifest.json",
+      );
+      expect(manifestWrite.command).toMatchObject({
+        dotfiles: "deny",
+        contentEncoding: "utf8",
+      });
+      const manifestWriteCommand =
+        requireWriteFileRelativeCommand(manifestWrite);
+      await reportQueuedCommandSuccess(harness, manifestWrite, {
+        path: "manifest.json",
+        hash: sha256Text(manifestWriteCommand.command.content),
+        modifiedAtMs: 1000,
+        sizeBytes: Buffer.byteLength(manifestWriteCommand.command.content),
+      });
+
+      const htmlWrite = await waitForQueuedCommandAfter(
+        harness,
+        manifestWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "demo") &&
+          command.path === "assets/index.html",
+      );
+      const htmlWriteCommand = requireWriteFileRelativeCommand(htmlWrite);
+      await reportQueuedCommandSuccess(harness, htmlWrite, {
+        path: "assets/index.html",
+        hash: sha256Text(htmlWriteCommand.command.content),
+        modifiedAtMs: 1001,
+        sizeBytes: Buffer.byteLength(htmlWriteCommand.command.content),
+      });
+
+      const stateWrite = await waitForQueuedCommandAfter(
+        harness,
+        htmlWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "demo") &&
+          command.path === "data/state.json",
+      );
+      const stateWriteCommand = requireWriteFileRelativeCommand(stateWrite);
+      await reportQueuedCommandSuccess(harness, stateWrite, {
+        path: "data/state.json",
+        hash: sha256Text(stateWriteCommand.command.content),
+        modifiedAtMs: 1002,
+        sizeBytes: Buffer.byteLength(stateWriteCommand.command.content),
+      });
+
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "demo",
+        afterCursor: stateWrite.row.cursor,
+        manifest: {
+          manifestVersion: 1,
+          id: "demo",
+          name: "Demo",
+          icon: "ListTodo",
+          entry: "index.html",
+          contributions: ["thread.app"],
+          capabilities: ["data", "message"],
+        },
+      });
+
+      const response = await request;
+      expect(response.status).toBe(201);
+      expect(appDetailSchema.parse(await readJson(response))).toMatchObject({
+        id: "demo",
+        name: "Demo",
+        entry: { kind: "html", path: "index.html" },
+        icon: { kind: "builtin", name: "ListTodo" },
+        capabilities: ["data", "message"],
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+});
diff --git a/apps/server/test/services/threads/app-client-script.test.ts b/apps/server/test/services/threads/app-client-script.test.ts
new file mode 100644
index 000000000..e1e0f9af7
--- /dev/null
+++ b/apps/server/test/services/threads/app-client-script.test.ts
@@ -0,0 +1,204 @@
+import { describe, expect, it, vi } from "vitest";
+import type {
+  AppDataBroadcastMessage,
+  AppDataListResponse,
+  Bb,
+} from "@bb/server-contract";
+import {
+  injectAppClientScript,
+  type AppClientBootstrap,
+} from "../../../src/services/threads/app-client-script.js";
+
+type OpenHandler = () => void;
+type CloseHandler = () => void;
+type ErrorHandler = () => void;
+type MessageHandler = (event: SocketMessageEvent) => void;
+type FetchMock = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+interface SocketMessageEvent {
+  data: string;
+}
+
+interface ScriptWindow {
+  bb?: Bb;
+}
+
+interface ExecuteScriptArgs {
+  fetchMock: FetchMock;
+  windowObject: ScriptWindow;
+}
+
+const bootstrap: AppClientBootstrap = {
+  appId: "status",
+  capabilities: ["data", "message"],
+  threadId: "thr_123",
+  dataUrl: "/api/v1/threads/thr_123/apps/status/data",
+  messageUrl: "/api/v1/threads/thr_123/apps/status/message",
+  wsUrl: "ws://server/ws",
+};
+
+class FakeWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSED = 3;
+  static instances: FakeWebSocket[] = [];
+
+  messages: string[] = [];
+  onclose: CloseHandler | null = null;
+  onerror: ErrorHandler | null = null;
+  onmessage: MessageHandler | null = null;
+  onopen: OpenHandler | null = null;
+  readyState = FakeWebSocket.CONNECTING;
+
+  constructor(readonly url: string) {
+    FakeWebSocket.instances.push(this);
+  }
+
+  close(): void {
+    this.readyState = FakeWebSocket.CLOSED;
+    this.onclose?.();
+  }
+
+  emit(payload: AppDataBroadcastMessage): void {
+    this.onmessage?.({ data: JSON.stringify(payload) });
+  }
+
+  open(): void {
+    this.readyState = FakeWebSocket.OPEN;
+    this.onopen?.();
+  }
+
+  send(message: string): void {
+    this.messages.push(message);
+  }
+}
+
+function extractScript(html: string): string {
+  const match = /<script[^>]*>([\s\S]*)<\/script>/u.exec(html);
+  const script = match?.[1];
+  if (!script) {
+    throw new Error("Injected app client script not found");
+  }
+  return script;
+}
+
+function executeScript(args: ExecuteScriptArgs): void {
+  FakeWebSocket.instances = [];
+  const html = injectAppClientScript("<html><head></head></html>", bootstrap);
+  const script = extractScript(html);
+  const runScript = new Function("window", "fetch", "WebSocket", script);
+  runScript(args.windowObject, args.fetchMock, FakeWebSocket);
+}
+
+function listResponse(body: AppDataListResponse): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function requireBb(windowObject: ScriptWindow): Bb {
+  if (!windowObject.bb?.data) {
+    throw new Error("window.bb.data was not installed");
+  }
+  return windowObject.bb;
+}
+
+async function flushPromises(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe("app client script", () => {
+  it("subscribes before replaying existing data for onChange", async () => {
+    const fetchMock = vi.fn(async () => listResponse({ entries: [] }));
+    const windowObject: ScriptWindow = {};
+    executeScript({ fetchMock, windowObject });
+
+    const bb = requireBb(windowObject);
+    bb.data?.onChange("", vi.fn());
+    await Promise.resolve();
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    const socket = FakeWebSocket.instances[0];
+    if (!socket) {
+      throw new Error("Expected websocket");
+    }
+    socket.open();
+    await flushPromises();
+
+    expect(JSON.parse(socket.messages[0] ?? "")).toEqual({
+      type: "subscribe",
+      entity: "thread",
+      id: "thr_123:app:status:data",
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v1/threads/thr_123/apps/status/data",
+      expect.objectContaining({ method: "GET" }),
+    );
+  });
+
+  it("replays existing data when a resync hint arrives", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        listResponse({
+          entries: [
+            {
+              path: "state.json",
+              value: { count: 1 },
+              version: "v1",
+              sizeBytes: 1,
+              modifiedAtMs: 1,
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(
+        listResponse({
+          entries: [
+            {
+              path: "state.json",
+              value: { count: 2 },
+              version: "v2",
+              sizeBytes: 1,
+              modifiedAtMs: 2,
+            },
+          ],
+        }),
+      );
+    const windowObject: ScriptWindow = {};
+    executeScript({ fetchMock, windowObject });
+
+    const bb = requireBb(windowObject);
+    const callback = vi.fn();
+    bb.data?.onChange("", callback);
+    await Promise.resolve();
+    const socket = FakeWebSocket.instances[0];
+    if (!socket) {
+      throw new Error("Expected websocket");
+    }
+    socket.open();
+    await flushPromises();
+    socket.emit({
+      type: "app-data.resync",
+      threadId: "thr_123",
+      appId: "status",
+    });
+    await vi.waitFor(() => {
+      expect(callback).toHaveBeenCalledTimes(2);
+    });
+
+    expect(callback).toHaveBeenCalledWith({
+      path: "state.json",
+      value: { count: 1 },
+      deleted: false,
+    });
+    expect(callback).toHaveBeenCalledWith({
+      path: "state.json",
+      value: { count: 2 },
+      deleted: false,
+    });
+  });
+});
diff --git a/apps/server/test/threads/manager-storage-templates.test.ts b/apps/server/test/threads/manager-storage-templates.test.ts
index fb657a6f5..c17f9c80e 100644
--- a/apps/server/test/threads/manager-storage-templates.test.ts
+++ b/apps/server/test/threads/manager-storage-templates.test.ts
@@ -86,6 +86,16 @@ async function readBundledStatusTemplate(): Promise<string> {
   );
 }
 
+async function readBundledStatusAppFile(relativePath: string): Promise<string> {
+  return readFile(
+    new URL(
+      `../../src/services/threads/default-template/apps/status/${relativePath}`,
+      import.meta.url,
+    ),
+    "utf8",
+  );
+}
+
 async function writeManagerTemplateSet(
   args: WriteManagerTemplateSetArgs,
 ): Promise<void> {
@@ -95,7 +105,9 @@ async function writeManagerTemplateSet(
   );
   await mkdir(templateDir, { recursive: true });
   for (const [fileName, content] of Object.entries(args.files)) {
-    await writeFile(path.join(templateDir, fileName), content, "utf8");
+    const filePath = path.join(templateDir, fileName);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
   }
 }
 
@@ -158,6 +170,24 @@ describe("manager storage templates", () => {
       await expect(
         readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
       ).resolves.toBe(await readBundledStatusTemplate());
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/status/manifest.json"),
+          "utf8",
+        ),
+      ).resolves.toBe(await readBundledStatusAppFile("manifest.json"));
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/status/assets/index.html"),
+          "utf8",
+        ),
+      ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/status/data/state.json"),
+          "utf8",
+        ),
+      ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
       await expect(
         stat(managerTemplateRootPath({ dataDir })),
       ).rejects.toThrow();
@@ -175,6 +205,8 @@ describe("manager storage templates", () => {
         name: DEFAULT_MANAGER_TEMPLATE_NAME,
         files: {
           "STATUS.html": "user status\n",
+          "apps/custom/manifest.json": "{}\n",
+          "apps/custom/assets/index.html": "<h1>Custom</h1>\n",
         },
       });
 
@@ -189,6 +221,12 @@ describe("manager storage templates", () => {
       await expect(
         readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
       ).resolves.toBe("user status\n");
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/custom/assets/index.html"),
+          "utf8",
+        ),
+      ).resolves.toBe("<h1>Custom</h1>\n");
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
@@ -298,6 +336,7 @@ describe("manager storage templates", () => {
         name: MINE_MANAGER_TEMPLATE_NAME,
         files: {
           "STATUS.html": "mine status\n",
+          "apps/mine/data/state.json": "{}\n",
         },
       });
 
@@ -312,6 +351,12 @@ describe("manager storage templates", () => {
       await expect(
         readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
       ).resolves.toBe("mine status\n");
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/mine/data/state.json"),
+          "utf8",
+        ),
+      ).resolves.toBe("{}\n");
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
diff --git a/packages/domain/src/apps.ts b/packages/domain/src/apps.ts
new file mode 100644
index 000000000..5f72ec99a
--- /dev/null
+++ b/packages/domain/src/apps.ts
@@ -0,0 +1,52 @@
+import { z } from "zod";
+
+const APP_DATA_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]{1,80}$/u;
+const APP_DATA_PATH_MAX_DEPTH = 8;
+// Keep these app-data path limits in sync with the injected app client
+// validator in apps/server/src/services/threads/app-client-script.ts.
+const APP_DATA_PATH_MAX_LENGTH = 512;
+
+export const appIdSchema = z.string().regex(/^[A-Za-z0-9_-]+$/u);
+export type AppId = z.infer<typeof appIdSchema>;
+
+export const appDataPathSchema = z.string().superRefine((value, context) => {
+  if (
+    value.length === 0 ||
+    value.length > APP_DATA_PATH_MAX_LENGTH ||
+    value.includes("\0") ||
+    value.includes("\\") ||
+    value.startsWith("/") ||
+    value.endsWith("/")
+  ) {
+    context.addIssue({
+      code: "custom",
+      message: "Invalid app data path",
+    });
+    return;
+  }
+
+  const segments = value.split("/");
+  if (segments.length > APP_DATA_PATH_MAX_DEPTH) {
+    context.addIssue({
+      code: "custom",
+      message: "App data path is too deep",
+    });
+    return;
+  }
+
+  for (const segment of segments) {
+    if (
+      segment === "." ||
+      segment === ".." ||
+      segment.startsWith(".") ||
+      !APP_DATA_PATH_SEGMENT_PATTERN.test(segment)
+    ) {
+      context.addIssue({
+        code: "custom",
+        message: "Invalid app data path segment",
+      });
+      return;
+    }
+  }
+});
+export type AppDataPath = z.infer<typeof appDataPathSchema>;
diff --git a/packages/domain/src/index.ts b/packages/domain/src/index.ts
index 1aeefcd9b..e6cec2f80 100644
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -55,6 +55,9 @@ export type {
 export { managerTemplateNameSchema } from "./manager-templates.js";
 export type { ManagerTemplateName } from "./manager-templates.js";
 
+export { appDataPathSchema, appIdSchema } from "./apps.js";
+export type { AppDataPath, AppId } from "./apps.js";
+
 export { threadDynamicContextFileStatusValues } from "./manager-dynamic-context.js";
 export type { ThreadDynamicContextFileStatus } from "./manager-dynamic-context.js";
 
diff --git a/packages/host-daemon-contract/src/commands.ts b/packages/host-daemon-contract/src/commands.ts
index 3fe99b881..596125b2e 100644
--- a/packages/host-daemon-contract/src/commands.ts
+++ b/packages/host-daemon-contract/src/commands.ts
@@ -27,7 +27,7 @@ import {
 } from "@bb/replay-capture/schema";
 import { z } from "zod";
 
-export const HOST_DAEMON_PROTOCOL_VERSION = 24 as const;
+export const HOST_DAEMON_PROTOCOL_VERSION = 25 as const;
 
 export const FILE_LIST_QUERY_MAX_LENGTH = 256;
 export const FILE_LIST_LIMIT_MAX = 10_000;
@@ -59,6 +59,7 @@ export const HOST_DAEMON_COMMAND_TYPES = [
   "host.read_file_relative",
   "host.write_file_relative",
   "host.delete_file_relative",
+  "host.delete_path_relative",
   "provider.list",
   "provider.list_models",
   "environment.provision",
@@ -333,6 +334,15 @@ export const hostDeleteFileRelativeCommandSchema = z
   })
   .strict();
 
+export const hostDeletePathRelativeCommandSchema = z
+  .object({
+    type: z.literal("host.delete_path_relative"),
+    rootPath: z.string().min(1),
+    path: z.string().min(1),
+    dotfiles: hostReadFileRelativeDotfilePolicySchema,
+  })
+  .strict();
+
 export const hostFileMetadataCommandSchema = z
   .object({
     type: z.literal("host.file_metadata"),
@@ -676,6 +686,7 @@ const hostDaemonNonProvisionCommandSchema = z.discriminatedUnion("type", [
   hostReadFileRelativeCommandSchema,
   hostWriteFileRelativeCommandSchema,
   hostDeleteFileRelativeCommandSchema,
+  hostDeletePathRelativeCommandSchema,
   providerListCommandSchema,
   providerListModelsCommandSchema,
   environmentDestroyCommandSchema,
@@ -716,6 +727,7 @@ export function shouldFlushEventsBeforeReportingCommandResult(
     case "host.read_file_relative":
     case "host.write_file_relative":
     case "host.delete_file_relative":
+    case "host.delete_path_relative":
     case "codex.inference.complete":
     case "provider.list":
     case "provider.list_models":
@@ -742,6 +754,7 @@ const fileReadResultSchema = z.object({
   contentEncoding: z.enum(["base64", "utf8"]),
   mimeType: z.string().optional(),
   sizeBytes: z.number().int().nonnegative(),
+  modifiedAtMs: z.number().nonnegative().optional(),
 });
 
 const fileMetadataResultSchema = z.object({
@@ -763,6 +776,11 @@ const fileDeleteResultSchema = z.object({
   previousHash: z.string().nullable(),
 });
 
+const pathDeleteResultSchema = z.object({
+  path: z.string(),
+  deleted: z.boolean(),
+});
+
 const statusVersionResultSchema = z.object({
   source: hostStatusVersionSourceSchema,
   hash: z.string().min(1),
@@ -911,6 +929,7 @@ export const hostDaemonCommandResultSchemaByType = {
   "host.read_file_relative": fileReadResultSchema,
   "host.write_file_relative": fileWriteResultSchema,
   "host.delete_file_relative": fileDeleteResultSchema,
+  "host.delete_path_relative": pathDeleteResultSchema,
   "provider.list": z.object({
     providers: z.array(providerInfoSchema),
   }),
diff --git a/packages/host-daemon-contract/src/index.ts b/packages/host-daemon-contract/src/index.ts
index e7db35f96..fe677608b 100644
--- a/packages/host-daemon-contract/src/index.ts
+++ b/packages/host-daemon-contract/src/index.ts
@@ -126,6 +126,7 @@ export {
   hostReadFileRelativeDotfilePolicySchema,
   hostWriteFileRelativeCommandSchema,
   hostDeleteFileRelativeCommandSchema,
+  hostDeletePathRelativeCommandSchema,
   providerListCommandSchema,
   providerListModelsCommandSchema,
   replayCaptureGetCommandSchema,
@@ -177,6 +178,10 @@ export {
   hostDaemonCommandBatchSchema,
   hostDaemonCommandsQuerySchema,
   hostDaemonCommandResultResponseSchema,
+  hostDaemonAppDataChangePayloadSchema,
+  hostDaemonAppDataChangeRequestSchema,
+  hostDaemonAppDataResyncPayloadSchema,
+  hostDaemonAppDataResyncRequestSchema,
   hostDaemonDaemonWsMessageSchema,
   hostDaemonEnvironmentChangePayloadSchema,
   hostDaemonEnvironmentChangeRequestSchema,
@@ -210,6 +215,10 @@ export type {
   HostDaemonEnrollResponse,
   HostDaemonCommandsQuery,
   HostDaemonCommandResultResponse,
+  HostDaemonAppDataChangePayload,
+  HostDaemonAppDataChangeRequest,
+  HostDaemonAppDataResyncPayload,
+  HostDaemonAppDataResyncRequest,
   HostDaemonDaemonWsMessage,
   HostDaemonEnvironmentChange,
   HostDaemonEnvironmentChangePayload,
diff --git a/packages/host-daemon-contract/src/session.ts b/packages/host-daemon-contract/src/session.ts
index c276d7be3..e13ce5db8 100644
--- a/packages/host-daemon-contract/src/session.ts
+++ b/packages/host-daemon-contract/src/session.ts
@@ -8,6 +8,8 @@ import {
   pendingInteractionCreateSchema,
   pendingInteractionStatusSchema,
   statusDataKeySchema,
+  appDataPathSchema,
+  appIdSchema,
   terminalColsSchema,
   terminalDataBase64Schema,
   terminalRowsSchema,
@@ -274,6 +276,79 @@ export type HostDaemonStatusDataChangeRequest = z.infer<
   typeof hostDaemonStatusDataChangeRequestSchema
 >;
 
+const hostDaemonAppDataChangePayloadBaseSchema = z
+  .object({
+    threadId: z.string().min(1),
+    appId: appIdSchema,
+    path: appDataPathSchema,
+    value: jsonValueSchema.nullable(),
+    deleted: z.boolean(),
+    version: z.string().min(1).nullable(),
+  })
+  .strict();
+type HostDaemonAppDataChangePayloadBase = z.infer<
+  typeof hostDaemonAppDataChangePayloadBaseSchema
+>;
+
+function validateHostDaemonAppDataChangePayload(
+  payload: HostDaemonAppDataChangePayloadBase,
+  context: z.RefinementCtx,
+): void {
+  if (payload.deleted && payload.version !== null) {
+    context.addIssue({
+      code: "custom",
+      path: ["version"],
+      message: "version must be null for deleted app data changes",
+    });
+  }
+  if (!payload.deleted && payload.version === null) {
+    context.addIssue({
+      code: "custom",
+      path: ["version"],
+      message: "version is required for non-deleted app data changes",
+    });
+  }
+}
+
+export const hostDaemonAppDataChangePayloadSchema =
+  hostDaemonAppDataChangePayloadBaseSchema.superRefine(
+    validateHostDaemonAppDataChangePayload,
+  );
+export type HostDaemonAppDataChangePayload = z.infer<
+  typeof hostDaemonAppDataChangePayloadSchema
+>;
+
+export const hostDaemonAppDataChangeRequestSchema = z
+  .object({
+    sessionId: z.string().min(1),
+    ...hostDaemonAppDataChangePayloadBaseSchema.shape,
+  })
+  .strict()
+  .superRefine(validateHostDaemonAppDataChangePayload);
+export type HostDaemonAppDataChangeRequest = z.infer<
+  typeof hostDaemonAppDataChangeRequestSchema
+>;
+
+export const hostDaemonAppDataResyncPayloadSchema = z
+  .object({
+    threadId: z.string().min(1),
+    appId: appIdSchema,
+  })
+  .strict();
+export type HostDaemonAppDataResyncPayload = z.infer<
+  typeof hostDaemonAppDataResyncPayloadSchema
+>;
+
+export const hostDaemonAppDataResyncRequestSchema =
+  hostDaemonAppDataResyncPayloadSchema
+    .extend({
+      sessionId: z.string().min(1),
+    })
+    .strict();
+export type HostDaemonAppDataResyncRequest = z.infer<
+  typeof hostDaemonAppDataResyncRequestSchema
+>;
+
 export const hostDaemonHeartbeatPayloadSchema = z.object({
   bufferDepth: z.number().int().nonnegative(),
   lastCommandCursor: z.number().int().nonnegative().nullable(),
@@ -579,6 +654,14 @@ export type HostDaemonInternalSchema = {
     /** Used by the daemon to report host-local STATUS-data file changes for server websocket fan-out. */
     $post: Endpoint<{ json: HostDaemonStatusDataChangeRequest }, { ok: true }>;
   };
+  "/session/app-data-change": {
+    /** Used by the daemon to report host-local app data file changes for server websocket fan-out. */
+    $post: Endpoint<{ json: HostDaemonAppDataChangeRequest }, { ok: true }>;
+  };
+  "/session/app-data-resync": {
+    /** Used by the daemon to request client-side app data resync after reconnect reconciliation. */
+    $post: Endpoint<{ json: HostDaemonAppDataResyncRequest }, { ok: true }>;
+  };
   "/session/tool-call": {
     /** Used by the daemon to execute server-side tool calls on behalf of a provider (e.g. message_user). */
     $post: Endpoint<
diff --git a/packages/host-daemon-contract/test/contract.test.ts b/packages/host-daemon-contract/test/contract.test.ts
index e4c0529ce..a09aa3cfe 100644
--- a/packages/host-daemon-contract/test/contract.test.ts
+++ b/packages/host-daemon-contract/test/contract.test.ts
@@ -553,6 +553,18 @@ describe("host-daemon command schemas", () => {
       path: "tasks.json",
     });
 
+    expect(
+      hostDaemonCommandSchema.parse({
+        type: "host.delete_path_relative",
+        rootPath: "/tmp/bb-data/thread-storage/thread-123/apps",
+        path: "demo",
+        dotfiles: "deny",
+      }),
+    ).toMatchObject({
+      type: "host.delete_path_relative",
+      path: "demo",
+    });
+
     expect(
       hostDaemonCommandSchema.parse({
         type: "host.list_files",
@@ -1371,6 +1383,16 @@ describe("host-daemon command schemas", () => {
       sizeBytes: 26_214_401,
     });
 
+    expect(
+      hostDaemonCommandResultSchemaByType["host.delete_path_relative"].parse({
+        path: "demo",
+        deleted: true,
+      }),
+    ).toEqual({
+      path: "demo",
+      deleted: true,
+    });
+
     expect(
       hostDaemonCommandResultSchemaByType["host.status_version"].parse({
         source: "folder",
@@ -1857,6 +1879,65 @@ describe("host-daemon session schemas", () => {
       }),
     ).toThrow();
 
+    expect(
+      contract.hostDaemonAppDataChangeRequestSchema.parse({
+        sessionId: "session_123",
+        threadId: "thr_123",
+        appId: "status",
+        path: "state.json",
+        value: { workers: [] },
+        deleted: false,
+        version: "next-hash",
+      }),
+    ).toEqual({
+      sessionId: "session_123",
+      threadId: "thr_123",
+      appId: "status",
+      path: "state.json",
+      value: { workers: [] },
+      deleted: false,
+      version: "next-hash",
+    });
+
+    expect(
+      contract.hostDaemonAppDataChangeRequestSchema.parse({
+        sessionId: "session_123",
+        threadId: "thr_123",
+        appId: "status",
+        path: "state.json",
+        value: null,
+        deleted: true,
+        version: null,
+      }),
+    ).toMatchObject({
+      deleted: true,
+      version: null,
+    });
+
+    expect(() =>
+      contract.hostDaemonAppDataChangeRequestSchema.parse({
+        sessionId: "session_123",
+        threadId: "thr_123",
+        appId: "status",
+        path: "state.json",
+        value: { workers: [] },
+        deleted: false,
+        version: null,
+      }),
+    ).toThrow();
+
+    expect(
+      contract.hostDaemonAppDataResyncRequestSchema.parse({
+        sessionId: "session_123",
+        threadId: "thr_123",
+        appId: "status",
+      }),
+    ).toEqual({
+      sessionId: "session_123",
+      threadId: "thr_123",
+      appId: "status",
+    });
+
     expect(
       hostDaemonInteractiveRequestSchema.parse({
         sessionId: "session_123",
@@ -2092,5 +2173,11 @@ describe("host-daemon session schemas", () => {
     expect(client.session["status-data-change"].$url().pathname).toBe(
       "/internal/session/status-data-change",
     );
+    expect(client.session["app-data-change"].$url().pathname).toBe(
+      "/internal/session/app-data-change",
+    );
+    expect(client.session["app-data-resync"].$url().pathname).toBe(
+      "/internal/session/app-data-resync",
+    );
   });
 });
diff --git a/packages/host-watcher/src/host-watcher-types.ts b/packages/host-watcher/src/host-watcher-types.ts
index 628af6e01..7a86273ee 100644
--- a/packages/host-watcher/src/host-watcher-types.ts
+++ b/packages/host-watcher/src/host-watcher-types.ts
@@ -1,5 +1,5 @@
 import type { HostType } from "@bb/domain";
-import type { StatusDataKey } from "@bb/domain";
+import type { AppDataPath, AppId, StatusDataKey } from "@bb/domain";
 import type { WorkspaceStatusWatchChangeKind } from "./watch-status-types.js";
 
 export type HostObservedChange =
@@ -19,6 +19,13 @@ export type HostObservedChange =
       environmentId: string;
       key: StatusDataKey;
       threadId: string;
+    }
+  | {
+      kind: "thread-app-data-changed";
+      appId: AppId;
+      environmentId: string;
+      path: AppDataPath;
+      threadId: string;
     };
 
 export type WorkspaceObservedChange = Extract<
@@ -28,7 +35,12 @@ export type WorkspaceObservedChange = Extract<
 
 export type ThreadStorageObservedChange = Extract<
   HostObservedChange,
-  { kind: "thread-storage-changed" | "thread-status-data-changed" }
+  {
+    kind:
+      | "thread-storage-changed"
+      | "thread-status-data-changed"
+      | "thread-app-data-changed";
+  }
 >;
 
 export interface WorkspaceWatchError {
diff --git a/packages/host-watcher/src/parcel-host-watcher.ts b/packages/host-watcher/src/parcel-host-watcher.ts
index 6c4fea07c..323e66a93 100644
--- a/packages/host-watcher/src/parcel-host-watcher.ts
+++ b/packages/host-watcher/src/parcel-host-watcher.ts
@@ -1,5 +1,11 @@
 import path from "node:path";
-import type { StatusDataKey } from "@bb/domain";
+import {
+  appDataPathSchema,
+  appIdSchema,
+  type AppDataPath,
+  type AppId,
+  type StatusDataKey,
+} from "@bb/domain";
 import {
   parseStatusDataFileName,
   STATUS_DATA_DIRECTORY_NAME,
@@ -29,6 +35,12 @@ interface ThreadStatusDataPath {
   threadId: string;
 }
 
+interface ThreadAppDataPath {
+  appId: AppId;
+  path: AppDataPath;
+  threadId: string;
+}
+
 interface CollectThreadStorageObservedChangesArgs {
   changedPaths: string[];
   threadStorageRootPath: string;
@@ -64,6 +76,10 @@ function isStatusDataSubtreePath(path: ThreadStoragePath): boolean {
   return path.parts[1] === STATUS_DATA_DIRECTORY_NAME;
 }
 
+function isAppDataSubtreePath(path: ThreadStoragePath): boolean {
+  return path.parts[1] === "apps" && path.parts[3] === "data";
+}
+
 function toThreadStatusDataPath(
   path: ThreadStoragePath,
 ): ThreadStatusDataPath | null {
@@ -80,11 +96,31 @@ function toThreadStatusDataPath(
   };
 }
 
+function toThreadAppDataPath(path: ThreadStoragePath): ThreadAppDataPath | null {
+  if (!isAppDataSubtreePath(path) || path.parts.length < 5) {
+    return null;
+  }
+  const appId = appIdSchema.safeParse(path.parts[2]);
+  if (!appId.success) {
+    return null;
+  }
+  const dataPath = appDataPathSchema.safeParse(path.parts.slice(4).join("/"));
+  if (!dataPath.success) {
+    return null;
+  }
+  return {
+    appId: appId.data,
+    threadId: path.threadId,
+    path: dataPath.data,
+  };
+}
+
 export function collectThreadStorageObservedChanges(
   args: CollectThreadStorageObservedChangesArgs,
 ): ThreadStorageObservedChange[] {
   const storageChanges = new Map<string, ThreadStorageWatchTarget>();
   const statusDataChanges = new Map<string, ThreadStorageObservedChange>();
+  const appDataChanges = new Map<string, ThreadStorageObservedChange>();
   for (const changedPath of args.changedPaths) {
     const storagePath = toThreadStoragePath({
       changedPath,
@@ -112,6 +148,22 @@ export function collectThreadStorageObservedChanges(
       }
       continue;
     }
+    if (isAppDataSubtreePath(storagePath)) {
+      const appDataPath = toThreadAppDataPath(storagePath);
+      if (appDataPath) {
+        appDataChanges.set(
+          `${target.environmentId}:${target.threadId}:${appDataPath.appId}:${appDataPath.path}`,
+          {
+            kind: "thread-app-data-changed",
+            appId: appDataPath.appId,
+            environmentId: target.environmentId,
+            path: appDataPath.path,
+            threadId: target.threadId,
+          },
+        );
+      }
+      continue;
+    }
     storageChanges.set(`${target.environmentId}:${target.threadId}`, target);
   }
 
@@ -124,6 +176,7 @@ export function collectThreadStorageObservedChanges(
     });
   }
   observedChanges.push(...statusDataChanges.values());
+  observedChanges.push(...appDataChanges.values());
   return observedChanges;
 }
 
diff --git a/packages/host-watcher/test/thread-storage-watch.test.ts b/packages/host-watcher/test/thread-storage-watch.test.ts
index 402998e35..a98e909b3 100644
--- a/packages/host-watcher/test/thread-storage-watch.test.ts
+++ b/packages/host-watcher/test/thread-storage-watch.test.ts
@@ -94,4 +94,48 @@ describe("thread storage watcher classification", () => {
 
     expect(changes).toEqual([]);
   });
+
+  it("emits targeted app data changes without broad storage changes", () => {
+    const rootPath = path.join("/tmp", "thread-storage");
+    const changes = collectThreadStorageObservedChanges({
+      threadStorageRootPath: rootPath,
+      changedPaths: [
+        path.join(rootPath, "thr_one", "apps", "status", "data", "state.json"),
+        path.join(rootPath, "thr_one", "apps", "status", "data", "state.json"),
+        path.join(rootPath, "thr_one", "apps", "kanban", "data", "cards", "1"),
+        path.join(rootPath, "thr_one", "apps", "bad.app", "data", "state.json"),
+        path.join(rootPath, "thr_one", "apps", "status", "data", ".state.tmp"),
+        path.join(rootPath, "thr_one", "apps", "status", "assets", "index.html"),
+        path.join(rootPath, "thr_unknown", "apps", "status", "data", "state.json"),
+      ],
+      resolveThreadTarget: createResolver({
+        thr_one: {
+          environmentId: "env_one",
+          threadId: "thr_one",
+        },
+      }),
+    });
+
+    expect(changes).toEqual([
+      {
+        kind: "thread-storage-changed",
+        environmentId: "env_one",
+        threadId: "thr_one",
+      },
+      {
+        kind: "thread-app-data-changed",
+        appId: "status",
+        environmentId: "env_one",
+        path: "state.json",
+        threadId: "thr_one",
+      },
+      {
+        kind: "thread-app-data-changed",
+        appId: "kanban",
+        environmentId: "env_one",
+        path: "cards/1",
+        threadId: "thr_one",
+      },
+    ]);
+  });
 });
diff --git a/packages/server-contract/src/api-types.ts b/packages/server-contract/src/api-types.ts
index 797805c1c..9c4703669 100644
--- a/packages/server-contract/src/api-types.ts
+++ b/packages/server-contract/src/api-types.ts
@@ -35,8 +35,16 @@ import {
   managerTemplateNameSchema,
   jsonValueSchema,
   statusDataKeySchema,
+  appDataPathSchema,
+  appIdSchema,
+} from "@bb/domain";
+import type {
+  AppDataPath,
+  AppId,
+  GitBranchName,
+  JsonValue,
+  StatusDataKey,
 } from "@bb/domain";
-import type { GitBranchName, JsonValue, StatusDataKey } from "@bb/domain";
 import { apiErrorSchema } from "./errors.js";
 import { timelineRowSchema } from "./thread-timeline.js";
 
@@ -1147,6 +1155,295 @@ export type StatusStateBroadcastMessage = z.infer<
   typeof statusStateBroadcastMessageSchema
 >;
 
+// Keep app path limits in sync with packages/domain/src/apps.ts and the
+// injected app client validator in app-client-script.ts.
+const appEntryPathSegmentPattern = /^[A-Za-z0-9._-]{1,120}$/u;
+
+function isValidAppEntryPath(value: string): boolean {
+  if (
+    value.length === 0 ||
+    value.length > 512 ||
+    value.includes("\0") ||
+    value.includes("\\") ||
+    value.startsWith("/") ||
+    value.endsWith("/")
+  ) {
+    return false;
+  }
+
+  const segments = value.split("/");
+  return segments.every(
+    (segment) =>
+      segment !== "." &&
+      segment !== ".." &&
+      !segment.startsWith(".") &&
+      appEntryPathSegmentPattern.test(segment),
+  );
+}
+
+export const appIconNameValues = [
+  "AlertCircle",
+  "AlertTriangle",
+  "AlignLeft",
+  "Archive",
+  "ArchiveRestore",
+  "ArrowDown",
+  "ArrowRight",
+  "ArrowUp",
+  "AudioLines",
+  "Check",
+  "ChevronDown",
+  "ChevronLeft",
+  "ChevronRight",
+  "ChevronUp",
+  "ChevronsDown",
+  "ChevronsUp",
+  "Circle",
+  "CircleCheck",
+  "CircleDashed",
+  "CircleX",
+  "Columns2",
+  "Container",
+  "Copy",
+  "CornerDownLeft",
+  "CornerDownRight",
+  "Edit",
+  "ExternalLink",
+  "FileDiff",
+  "File",
+  "FileQuestion",
+  "FileX2",
+  "Folder",
+  "FolderOpen",
+  "FolderMinus",
+  "FolderPlus",
+  "GitBranch",
+  "GitMerge",
+  "GridView",
+  "Info",
+  "Laptop",
+  "ListTodo",
+  "Maximize2",
+  "MessageSquarePlus",
+  "MessageSquare",
+  "Mic",
+  "Minimize2",
+  "MoreHorizontal",
+  "PanelBottom",
+  "PanelLeft",
+  "PanelRight",
+  "Paperclip",
+  "Plus",
+  "RotateCcw",
+  "Rows2",
+  "Search",
+  "Settings",
+  "Spinner",
+  "Square",
+  "Terminal",
+  "Trash2",
+  "UserRound",
+  "UserRoundPlus",
+  "X",
+  "Zap",
+] as const;
+export const appIconNameSchema = z.enum(appIconNameValues);
+export type AppIconName = z.infer<typeof appIconNameSchema>;
+
+export const appEntryKindSchema = z.enum(["html", "md"]);
+export type AppEntryKind = z.infer<typeof appEntryKindSchema>;
+
+export const appEntryPathSchema = z
+  .string()
+  .refine(isValidAppEntryPath, "Invalid app entry path");
+export type AppEntryPath = z.infer<typeof appEntryPathSchema>;
+
+export const appEntrySchema = z
+  .object({
+    path: appEntryPathSchema,
+    kind: appEntryKindSchema,
+  })
+  .strict();
+export type AppEntry = z.infer<typeof appEntrySchema>;
+
+export const appCapabilitySchema = z.enum(["data", "message"]);
+export type AppCapability = z.infer<typeof appCapabilitySchema>;
+
+export const appContributionSchema = z.enum(["thread.app"]);
+export type AppContribution = z.infer<typeof appContributionSchema>;
+
+export const appManifestSchema = z
+  .object({
+    manifestVersion: z.literal(1),
+    id: appIdSchema,
+    name: z.string().min(1).max(80),
+    icon: appIconNameSchema.optional(),
+    entry: appEntryPathSchema.optional(),
+    contributions: z.array(appContributionSchema).min(1),
+    capabilities: z.array(appCapabilitySchema),
+  })
+  .strict()
+  .superRefine((manifest, context) => {
+    if (
+      manifest.contributions.length !== 1 ||
+      manifest.contributions[0] !== "thread.app"
+    ) {
+      context.addIssue({
+        code: "custom",
+        path: ["contributions"],
+        message: 'Only ["thread.app"] is supported',
+      });
+    }
+  });
+export type AppManifest = z.infer<typeof appManifestSchema>;
+
+export const appIconSchema = z.discriminatedUnion("kind", [
+  z
+    .object({
+      kind: z.literal("builtin"),
+      name: appIconNameSchema,
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("logo"),
+      url: z.string().min(1),
+    })
+    .strict(),
+]);
+export type AppIcon = z.infer<typeof appIconSchema>;
+
+export const appSummarySchema = z
+  .object({
+    id: appIdSchema,
+    name: z.string().min(1).max(80),
+    entry: appEntrySchema,
+    capabilities: z.array(appCapabilitySchema),
+    icon: appIconSchema,
+  })
+  .strict();
+export type AppSummary = z.infer<typeof appSummarySchema>;
+
+export const appDetailSchema = appSummarySchema;
+export type AppDetail = z.infer<typeof appDetailSchema>;
+
+export const appTemplateSchema = z.enum(["blank", "status"]);
+export type AppTemplate = z.infer<typeof appTemplateSchema>;
+
+export const createThreadAppRequestSchema = z
+  .object({
+    id: appIdSchema,
+    name: z.string().min(1).max(80),
+    template: appTemplateSchema,
+  })
+  .strict();
+export type CreateThreadAppRequest = z.infer<
+  typeof createThreadAppRequestSchema
+>;
+
+export const appDataEntrySchema = z
+  .object({
+    path: appDataPathSchema,
+    value: jsonValueSchema,
+    version: z.string().min(1),
+    sizeBytes: z.number().int().nonnegative(),
+    modifiedAtMs: z.number().nonnegative(),
+  })
+  .strict();
+export type AppDataEntry = z.infer<typeof appDataEntrySchema>;
+
+export const appDataReadResponseSchema = appDataEntrySchema;
+export type AppDataReadResponse = z.infer<typeof appDataReadResponseSchema>;
+
+export const appDataListQuerySchema = z
+  .object({
+    prefix: appDataPathSchema.or(z.literal("")),
+  })
+  .partial();
+export type AppDataListQuery = z.infer<typeof appDataListQuerySchema>;
+
+export const appDataListResponseSchema = z
+  .object({
+    entries: z.array(appDataEntrySchema),
+  })
+  .strict();
+export type AppDataListResponse = z.infer<typeof appDataListResponseSchema>;
+
+export const appDataWriteRequestSchema = z
+  .object({
+    value: jsonValueSchema,
+  })
+  .strict();
+export type AppDataWriteRequest = z.infer<typeof appDataWriteRequestSchema>;
+
+export const appMessageRequestSchema = z
+  .object({
+    text: z.string().min(1),
+  })
+  .strict();
+export type AppMessageRequest = z.infer<typeof appMessageRequestSchema>;
+
+export const appDataChangedBroadcastMessageSchema = z
+  .object({
+    type: z.literal("app-data.changed"),
+    threadId: z.string().min(1),
+    appId: appIdSchema,
+    path: appDataPathSchema,
+    value: jsonValueSchema.nullable(),
+    deleted: z.boolean(),
+    version: z.string().min(1).nullable(),
+  })
+  .strict();
+export type AppDataChangedBroadcastMessage = z.infer<
+  typeof appDataChangedBroadcastMessageSchema
+>;
+
+export const appDataResyncBroadcastMessageSchema = z
+  .object({
+    type: z.literal("app-data.resync"),
+    threadId: z.string().min(1),
+    appId: appIdSchema,
+  })
+  .strict();
+export type AppDataResyncBroadcastMessage = z.infer<
+  typeof appDataResyncBroadcastMessageSchema
+>;
+
+export const appDataBroadcastMessageSchema = z.discriminatedUnion("type", [
+  appDataChangedBroadcastMessageSchema,
+  appDataResyncBroadcastMessageSchema,
+]);
+export type AppDataBroadcastMessage = z.infer<
+  typeof appDataBroadcastMessageSchema
+>;
+
+export interface BbDataEntry {
+  path: AppDataPath;
+  value: JsonValue;
+}
+
+export interface BbDataChangeEvent {
+  path: AppDataPath;
+  value: JsonValue | undefined;
+  deleted: boolean;
+}
+
+export type BbDataChangeCallback = (event: BbDataChangeEvent) => void;
+
+export interface BbData {
+  read(path: AppDataPath): Promise<JsonValue | undefined>;
+  write(path: AppDataPath, value: JsonValue): Promise<void>;
+  delete(path: AppDataPath): Promise<void>;
+  list(prefix?: AppDataPath | ""): Promise<BbDataEntry[]>;
+  onChange(prefix: AppDataPath | "", callback: BbDataChangeCallback): () => void;
+}
+
+export interface Bb {
+  appId: AppId;
+  data?: BbData;
+  message?(text: string): Promise<void>;
+}
+
 export const systemExecutionOptionsQuerySchema = z
   .object({
     providerId: z.string().min(1),
diff --git a/packages/server-contract/src/index.ts b/packages/server-contract/src/index.ts
index d2420b76e..5be4235e1 100644
--- a/packages/server-contract/src/index.ts
+++ b/packages/server-contract/src/index.ts
@@ -194,6 +194,28 @@ export {
   statusStateChangeEventSchema,
   statusStateChangeEventSourceSchema,
   statusStateChangeOperationSchema,
+  appCapabilitySchema,
+  appContributionSchema,
+  appDataBroadcastMessageSchema,
+  appDataChangedBroadcastMessageSchema,
+  appDataEntrySchema,
+  appDataListQuerySchema,
+  appDataListResponseSchema,
+  appDataReadResponseSchema,
+  appDataResyncBroadcastMessageSchema,
+  appDataWriteRequestSchema,
+  appDetailSchema,
+  appEntryKindSchema,
+  appEntryPathSchema,
+  appEntrySchema,
+  appIconNameSchema,
+  appIconNameValues,
+  appIconSchema,
+  appManifestSchema,
+  appMessageRequestSchema,
+  appSummarySchema,
+  appTemplateSchema,
+  createThreadAppRequestSchema,
   threadStatusDataGetResponseSchema,
   threadStatusDataListResponseSchema,
   threadStatusDataValueRecordSchema,
@@ -352,6 +374,32 @@ export type {
   ThreadStoragePathsQuery,
   ThreadStatusVersionResponse,
   ThreadStatusVersionSource,
+  AppCapability,
+  AppContribution,
+  AppDataBroadcastMessage,
+  AppDataChangedBroadcastMessage,
+  AppDataEntry,
+  AppDataListQuery,
+  AppDataListResponse,
+  AppDataReadResponse,
+  AppDataResyncBroadcastMessage,
+  AppDataWriteRequest,
+  AppDetail,
+  AppEntry,
+  AppEntryKind,
+  AppEntryPath,
+  AppIcon,
+  AppIconName,
+  AppManifest,
+  AppMessageRequest,
+  AppSummary,
+  AppTemplate,
+  Bb,
+  BbData,
+  BbDataChangeCallback,
+  BbDataChangeEvent,
+  BbDataEntry,
+  CreateThreadAppRequest,
   BbStatusState,
   BbThreadTell,
   StatusStateBroadcastMessage,
diff --git a/packages/server-contract/src/public-api.ts b/packages/server-contract/src/public-api.ts
index 54c0cb5aa..dcd4637cd 100644
--- a/packages/server-contract/src/public-api.ts
+++ b/packages/server-contract/src/public-api.ts
@@ -22,10 +22,18 @@ import type {
 } from "./common.js";
 import type {
   Automation,
+  AppDataListQuery,
+  AppDataListResponse,
+  AppDataReadResponse,
+  AppDataWriteRequest,
+  AppDetail,
+  AppMessageRequest,
+  AppSummary,
   CreateAutomationRequest,
   CreateHostJoinRequest,
   CreateHostJoinResponse,
   CreateQueuedMessageRequest,
+  CreateThreadAppRequest,
   CreateManagerThreadRequest,
   CreateProjectRequest,
   CreateProjectSourceRequest,
@@ -120,6 +128,7 @@ import type { ApiError } from "./errors.js";
 type PathProjectSourceId = { param: { id: string; sourceId: string } };
 type PathProjectManagerThreadId = { param: { id: string; threadId: string } };
 type PathThreadStatusDataKey = { param: { id: string; key: string } };
+type PathThreadApp = { param: { id: string; appId: string } };
 
 export type PublicApiSchema = {
   // ─── Development Only ────────────────────────────────────────────────
@@ -581,6 +590,38 @@ export type PublicApiSchema = {
     /** Read one persistent reactive JSON state value for a STATUS dashboard. */
     $get: Endpoint<PathThreadStatusDataKey, ThreadStatusDataGetResponse>;
   };
+  "/threads/:id/apps": {
+    /** List thread apps by reading validated manifests from thread storage. */
+    $get: Endpoint<PathId, AppSummary[]>;
+    /** Scaffold a new thread app under apps/<appId>/ using a server-owned template. */
+    $post: Endpoint<PathId & { json: CreateThreadAppRequest }, AppDetail, 201>;
+  };
+  "/threads/:id/apps/:appId": {
+    /** Resolve one thread app manifest, entry, and icon. */
+    $get: Endpoint<PathThreadApp, AppDetail>;
+    /** Remove one thread app directory from thread storage. */
+    $delete: Endpoint<PathThreadApp, { ok: true }>;
+  };
+  "/threads/:id/apps/:appId/data": {
+    /** List JSON value files at or below an app data prefix. */
+    $get: Endpoint<PathThreadApp & { query?: AppDataListQuery }, AppDataListResponse>;
+  };
+  "/threads/:id/apps/:appId/data/*": {
+    /**
+     * Read, write, or delete one app data JSON file. The wildcard suffix is
+     * validated by the route because hono-typed-routes only types named params.
+     */
+    $get: Endpoint<PathThreadApp, AppDataReadResponse>;
+    $put: Endpoint<
+      PathThreadApp & { json: AppDataWriteRequest },
+      AppDataReadResponse
+    >;
+    $delete: Endpoint<PathThreadApp, { ok: true }>;
+  };
+  "/threads/:id/apps/:appId/message": {
+    /** Send a message from an app iframe to its owning thread. */
+    $post: Endpoint<PathThreadApp & { json: AppMessageRequest }, { ok: true }>;
+  };
   "/threads/:id/thread-storage/files": {
     /**
      * List files in the durable thread storage for a thread environment.
diff --git a/packages/server-contract/test/contract.test.ts b/packages/server-contract/test/contract.test.ts
index 99de38f61..693995d61 100644
--- a/packages/server-contract/test/contract.test.ts
+++ b/packages/server-contract/test/contract.test.ts
@@ -43,6 +43,12 @@ const INTENTIONAL_OPTIONAL_SERVER_FIELDS: Record<string, string> = {
     "Base error details are omitted unless a route has structured detail payloads.",
   "apiErrorSchema.retryable":
     "Error payloads may omit retryability when the server has no retry guidance.",
+  "appDataListQuerySchema.prefix":
+    "App data listing may omit prefix to list every value file under the app data root.",
+  "appManifestSchema.entry":
+    "App manifests may omit entry so the server can resolve index.html then index.md at the boundary.",
+  "appManifestSchema.icon":
+    "App manifests may omit icon so the server can resolve a logo file or the GridView fallback.",
   "createAutomationRequestSchema.action.threadRequest.environment.workspace.branch":
     "Unmanaged workspaces may omit branch when the daemon should not check out before starting the thread.",
   "createAutomationRequestSchema.action.threadRequest.environment.hostId":
@@ -581,6 +587,73 @@ describe("server-contract canonical schemas", () => {
     });
   });
 
+  it("validates app manifests, icon names, entries, and data broadcasts", () => {
+    const manifest = {
+      manifestVersion: 1,
+      id: "status",
+      name: "Status",
+      icon: "ListTodo",
+      entry: "index.html",
+      contributions: ["thread.app"],
+      capabilities: ["data", "message"],
+    };
+
+    expect(contract.appManifestSchema.parse(manifest)).toEqual(manifest);
+    expect(
+      contract.appManifestSchema.safeParse({
+        ...manifest,
+        icon: "MissingIcon",
+      }).success,
+    ).toBe(false);
+    expect(
+      contract.appManifestSchema.safeParse({
+        ...manifest,
+        entry: "../index.html",
+      }).success,
+    ).toBe(false);
+    expect(
+      contract.appManifestSchema.safeParse({
+        ...manifest,
+        contributions: ["thread.app", "sidebar"],
+      }).success,
+    ).toBe(false);
+
+    const message = {
+      type: "app-data.changed",
+      threadId: "thr_123",
+      appId: "status",
+      path: "state.json",
+      value: { workers: [] },
+      deleted: false,
+      version: "next-hash",
+    };
+    expect(contract.appDataBroadcastMessageSchema.parse(message)).toEqual(
+      message,
+    );
+    expect(
+      contract.appDataBroadcastMessageSchema.parse({
+        ...message,
+        value: null,
+        deleted: true,
+        version: null,
+      }),
+    ).toMatchObject({
+      deleted: true,
+      version: null,
+    });
+    expect(
+      contract.appDataBroadcastMessageSchema.parse({
+        type: "app-data.resync",
+        threadId: "thr_123",
+        appId: "status",
+      }),
+    ).toEqual({
+      type: "app-data.resync",
+      threadId: "thr_123",
+      appId: "status",
+    });
+  });
+
   it("parses request contracts", () => {
     expect(
       createAutomationRequestSchema.parse({
@@ -1285,6 +1358,8 @@ describe("server-contract clients", () => {
   it("keeps contract optional fields on an explicit allowlist", () => {
     const optionalFieldPaths = collectOptionalFieldPaths({
       apiErrorSchema: contract.apiErrorSchema,
+      appDataListQuerySchema: contract.appDataListQuerySchema,
+      appManifestSchema: contract.appManifestSchema,
       commitActionResponseSchema: contract.commitActionResponseSchema,
       createQueuedMessageRequestSchema:
         contract.createQueuedMessageRequestSchema,

From 24a6e2c9ae5908002110ddc912043df3f3962d55 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 17:14:00 -0700
Subject: [PATCH 02/13] apps system phase 2: secondary-panel launcher + unified
 app/file search + app tabs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Frontend for the Apps system (additive; STATUS UI left intact for Phase 3):
- App tab kind + pinned `status` app tab in the secondary panel
- "+" launcher listing the thread's apps with resolved icons
- Unified app + file search (Apps + Files sections)
- App tab content branches on entry kind: HTML → iframe + injected window.bb,
  Markdown → static react-markdown
- Live data updates via window.bb.data.onChange (with replay/unsubscribe
  lifecycle guard), shared markdown asset URL transform, centralized STATUS_APP_ID

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../components/secondary-panel/AppIcon.tsx    |  28 +++
 .../secondary-panel/AppTabContent.test.tsx    |  79 ++++++++
 .../secondary-panel/AppTabContent.tsx         | 151 ++++++++++++++
 .../secondary-panel/NewTabFileSearch.tsx      | 140 +++++++++----
 .../secondary-panel/NewTabPage.test.tsx       |  47 ++++-
 .../components/secondary-panel/NewTabPage.tsx |   7 +-
 .../secondary-panel/ThreadSecondaryPanel.tsx  |   2 +
 .../ThreadSecondaryPanelNewTab.stories.tsx    |  35 +++-
 .../ThreadStorageFilePreview.tsx              |  28 +--
 .../useThreadFileTabs.test.tsx                |  84 ++++++++
 .../secondary-panel/useThreadFileTabs.ts      | 185 +++++++++++++++++-
 apps/app/src/components/ui/tab-pill.tsx       |   8 +
 apps/app/src/hooks/queries/query-keys.ts      |  38 ++++
 apps/app/src/hooks/queries/thread-queries.ts  |  58 ++++++
 .../hooks/useFileSearchSuggestions.test.tsx   |  79 +++++++-
 .../app/src/hooks/useFileSearchSuggestions.ts | 109 ++++++++++-
 apps/app/src/lib/api.ts                       |  44 +++++
 apps/app/src/lib/file-content-urls.ts         |  29 +++
 .../src/lib/fixed-panel-tabs-state.test.ts    |  24 +++
 apps/app/src/lib/fixed-panel-tabs-state.ts    |  32 +++
 apps/app/src/lib/markdown-url-transform.ts    |  27 +++
 .../views/thread-detail/ThreadDetailView.tsx  |  43 +++-
 .../threadSecondaryPanelSelection.ts          |   1 +
 .../src/services/threads/app-client-script.ts |  59 +++++-
 .../threads/app-client-script.test.ts         |  65 ++++++
 25 files changed, 1302 insertions(+), 100 deletions(-)
 create mode 100644 apps/app/src/components/secondary-panel/AppIcon.tsx
 create mode 100644 apps/app/src/components/secondary-panel/AppTabContent.test.tsx
 create mode 100644 apps/app/src/components/secondary-panel/AppTabContent.tsx
 create mode 100644 apps/app/src/lib/markdown-url-transform.ts

diff --git a/apps/app/src/components/secondary-panel/AppIcon.tsx b/apps/app/src/components/secondary-panel/AppIcon.tsx
new file mode 100644
index 000000000..ec7ea22d6
--- /dev/null
+++ b/apps/app/src/components/secondary-panel/AppIcon.tsx
@@ -0,0 +1,28 @@
+import type { AppIcon as ThreadAppIcon } from "@bb/server-contract";
+import { Icon } from "@/components/ui/icon.js";
+import { cn } from "@/lib/utils";
+
+export interface ResolvedAppIconProps {
+  icon: ThreadAppIcon;
+  className?: string;
+}
+
+export function ResolvedAppIcon({ icon, className }: ResolvedAppIconProps) {
+  if (icon.kind === "logo") {
+    return (
+      <img
+        src={icon.url}
+        alt=""
+        className={cn("size-4 shrink-0 rounded-sm object-contain", className)}
+      />
+    );
+  }
+
+  return (
+    <Icon
+      name={icon.name}
+      className={cn("size-4 shrink-0 text-muted-foreground", className)}
+      aria-hidden
+    />
+  );
+}
diff --git a/apps/app/src/components/secondary-panel/AppTabContent.test.tsx b/apps/app/src/components/secondary-panel/AppTabContent.test.tsx
new file mode 100644
index 000000000..048c558e3
--- /dev/null
+++ b/apps/app/src/components/secondary-panel/AppTabContent.test.tsx
@@ -0,0 +1,79 @@
+// @vitest-environment jsdom
+
+import { cleanup, render, screen } from "@testing-library/react";
+import type { AppDetail } from "@bb/server-contract";
+import * as api from "@/lib/api";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createQueryClientTestHarness } from "@/test/queryClientTestHarness";
+import { AppTabContent } from "./AppTabContent";
+
+vi.mock("@/lib/api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@/lib/api")>();
+
+  return {
+    ...actual,
+    getThreadApp: vi.fn(),
+    getThreadAppMarkdownPreview: vi.fn(),
+  };
+});
+
+const HTML_APP: AppDetail = {
+  id: "status",
+  name: "Status",
+  entry: { path: "index.html", kind: "html" },
+  capabilities: ["data", "message"],
+  icon: { kind: "builtin", name: "ListTodo" },
+};
+
+const MARKDOWN_APP: AppDetail = {
+  id: "readme",
+  name: "Readme",
+  entry: { path: "docs/index.md", kind: "md" },
+  capabilities: [],
+  icon: { kind: "builtin", name: "GridView" },
+};
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("AppTabContent", () => {
+  it("renders HTML apps in the injected app iframe route", async () => {
+    vi.mocked(api.getThreadApp).mockResolvedValue(HTML_APP);
+    const { wrapper } = createQueryClientTestHarness();
+
+    render(<AppTabContent threadId="thr_1" appId="status" />, { wrapper });
+
+    const frame = await screen.findByTitle("Status");
+    expect(frame.getAttribute("src")).toBe(
+      "/api/v1/threads/thr_1/apps/status/",
+    );
+    expect(frame.getAttribute("sandbox")).toBeNull();
+    expect(api.getThreadAppMarkdownPreview).not.toHaveBeenCalled();
+  });
+
+  it("renders markdown apps through the static markdown preview path", async () => {
+    vi.mocked(api.getThreadApp).mockResolvedValue(MARKDOWN_APP);
+    vi.mocked(api.getThreadAppMarkdownPreview).mockResolvedValue({
+      kind: "text",
+      path: "docs/index.md",
+      name: "index.md",
+      url: "/api/v1/threads/thr_1/apps/readme/assets/docs/index.md",
+      mimeType: "text/markdown",
+      content: "# App Notes\n\nStatic content.",
+    });
+    const { wrapper } = createQueryClientTestHarness();
+
+    render(<AppTabContent threadId="thr_1" appId="readme" />, { wrapper });
+
+    expect(await screen.findByText("App Notes")).toBeTruthy();
+    expect(screen.getByText("Static content.")).toBeTruthy();
+    expect(api.getThreadAppMarkdownPreview).toHaveBeenCalledWith(
+      "thr_1",
+      "readme",
+      "docs/index.md",
+      expect.any(AbortSignal),
+    );
+  });
+});
diff --git a/apps/app/src/components/secondary-panel/AppTabContent.tsx b/apps/app/src/components/secondary-panel/AppTabContent.tsx
new file mode 100644
index 000000000..7cda4ccdb
--- /dev/null
+++ b/apps/app/src/components/secondary-panel/AppTabContent.tsx
@@ -0,0 +1,151 @@
+import { useMemo } from "react";
+import {
+  useThreadApp,
+  useThreadAppMarkdownPreview,
+} from "@/hooks/queries/thread-queries";
+import {
+  buildThreadAppAssetBaseUrl,
+  buildThreadAppEntryUrl,
+} from "@/lib/file-content-urls";
+import { createAssetMarkdownUrlTransform } from "@/lib/markdown-url-transform";
+import { FilePreview as FilePreviewSurface } from "./FilePreview";
+
+const APP_HEADER_MODE = "none";
+
+export interface AppTabContentProps {
+  appId: string;
+  threadId: string;
+}
+
+export function AppTabContent({ appId, threadId }: AppTabContentProps) {
+  const appDetail = useThreadApp(threadId, appId);
+  const markdownEntryPath =
+    appDetail.data?.entry.kind === "md" ? appDetail.data.entry.path : null;
+  const markdownPreview = useThreadAppMarkdownPreview(
+    threadId,
+    appId,
+    markdownEntryPath,
+    {
+      enabled: markdownEntryPath !== null,
+    },
+  );
+  const markdownAssetBaseUrl = useMemo(() => {
+    if (markdownEntryPath === null) {
+      return null;
+    }
+    return buildThreadAppAssetBaseUrl(threadId, appId, markdownEntryPath);
+  }, [appId, markdownEntryPath, threadId]);
+  const markdownUrlTransform = useMemo(() => {
+    if (markdownAssetBaseUrl === null) {
+      return undefined;
+    }
+    return createAssetMarkdownUrlTransform(markdownAssetBaseUrl);
+  }, [markdownAssetBaseUrl]);
+
+  if (appDetail.isError) {
+    return (
+      <FilePreviewSurface
+        path={appId}
+        headerMode={APP_HEADER_MODE}
+        state={{
+          kind: "error",
+          message:
+            appDetail.error instanceof Error
+              ? appDetail.error.message
+              : "Failed to load app.",
+        }}
+      />
+    );
+  }
+
+  if (!appDetail.data) {
+    return (
+      <FilePreviewSurface
+        path={appId}
+        headerMode={APP_HEADER_MODE}
+        state={{ kind: "loading" }}
+      />
+    );
+  }
+
+  if (appDetail.data.entry.kind === "html") {
+    return (
+      <FilePreviewSurface
+        path={appDetail.data.name}
+        headerMode={APP_HEADER_MODE}
+        state={{
+          kind: "iframe",
+          sandbox: null,
+          title: appDetail.data.name,
+          url: buildThreadAppEntryUrl(threadId, appId),
+        }}
+      />
+    );
+  }
+
+  if (markdownPreview.isError) {
+    return (
+      <FilePreviewSurface
+        path={appDetail.data.name}
+        headerMode={APP_HEADER_MODE}
+        state={{
+          kind: "error",
+          message:
+            markdownPreview.error instanceof Error
+              ? markdownPreview.error.message
+              : "Failed to load app entry.",
+        }}
+      />
+    );
+  }
+
+  if (!markdownPreview.data) {
+    return (
+      <FilePreviewSurface
+        path={appDetail.data.name}
+        headerMode={APP_HEADER_MODE}
+        state={{ kind: "loading" }}
+      />
+    );
+  }
+
+  if (markdownPreview.data.kind !== "text") {
+    return (
+      <FilePreviewSurface
+        path={appDetail.data.name}
+        headerMode={APP_HEADER_MODE}
+        state={{
+          kind: "error",
+          message: `Preview not available for ${markdownPreview.data.mimeType}.`,
+        }}
+      />
+    );
+  }
+
+  if (markdownPreview.data.content.length === 0) {
+    return (
+      <FilePreviewSurface
+        path={appDetail.data.name}
+        headerMode={APP_HEADER_MODE}
+        state={{ kind: "empty" }}
+      />
+    );
+  }
+
+  return (
+    <FilePreviewSurface
+      path={appDetail.data.name}
+      headerMode={APP_HEADER_MODE}
+      state={{
+        kind: "ready",
+        lineNumber: null,
+        showMarkdownModeToggle: false,
+        markdownUrlTransform,
+        file: {
+          name: markdownPreview.data.name ?? appDetail.data.entry.path,
+          contents: markdownPreview.data.content,
+        },
+      }}
+    />
+  );
+}
diff --git a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
index a19e618a7..999da636e 100644
--- a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
@@ -10,6 +10,7 @@ import type { ThreadType } from "@bb/domain";
 import { Icon } from "@/components/ui/icon.js";
 import { Input } from "@/components/ui/input.js";
 import { TruncateStart } from "@/components/ui/truncate-start.js";
+import { ResolvedAppIcon } from "./AppIcon";
 import {
   useFileSearchSuggestions,
   type FileSearchSuggestion,
@@ -47,7 +48,7 @@ interface FileSearchSectionItem {
 }
 
 interface FileSearchSection {
-  source: FileSearchSource;
+  kind: FileSearchSectionKind;
   label: string;
   items: FileSearchSectionItem[];
 }
@@ -61,6 +62,7 @@ type SearchInputKeyDownHandler = (
   event: KeyboardEvent<HTMLInputElement>,
 ) => void;
 type FileSearchSource = FileSearchSuggestion["source"];
+type FileSearchSectionKind = "apps" | "files";
 
 interface GetAvailableFileSearchSourcesArgs {
   projectId: string | undefined;
@@ -74,12 +76,18 @@ interface GroupFileSearchSectionsArgs {
 }
 
 const FILE_SEARCH_LIMIT = 20;
-const FILE_SEARCH_SECTION_ORDER: readonly FileSearchSource[] = [
-  "workspace",
-  "thread-storage",
+const FILE_SEARCH_SECTION_ORDER: readonly FileSearchSectionKind[] = [
+  "apps",
+  "files",
 ];
 
 const FILE_SEARCH_SECTION_LABELS = {
+  apps: "Apps",
+  files: "Files",
+} satisfies Record<FileSearchSectionKind, string>;
+
+const FILE_SEARCH_SOURCE_LABELS = {
+  app: "App",
   workspace: "Workspace",
   "thread-storage": "Manager Storage",
 } satisfies Record<FileSearchSource, string>;
@@ -90,6 +98,9 @@ function getAvailableFileSearchSources({
   currentThreadType,
 }: GetAvailableFileSearchSourcesArgs): readonly FileSearchSource[] {
   const sources: FileSearchSource[] = [];
+  if (currentThreadId.length > 0) {
+    sources.push("app");
+  }
   if (projectId) {
     sources.push("workspace");
   }
@@ -100,8 +111,10 @@ function getAvailableFileSearchSources({
 }
 
 function getFileSearchResultId(suggestion: FileSearchSuggestion): string {
+  const idSegment =
+    suggestion.entryKind === "app" ? suggestion.appId : suggestion.path;
   return `file-search-result-${suggestion.source}-${encodeURIComponent(
-    suggestion.path,
+    idSegment,
   )}`;
 }
 
@@ -117,7 +130,16 @@ function splitPath(path: string): SplitPathResult {
 }
 
 function getFileSearchResultTitle(suggestion: FileSearchSuggestion): string {
-  return `${FILE_SEARCH_SECTION_LABELS[suggestion.source]}: ${suggestion.path}`;
+  if (suggestion.entryKind === "app") {
+    return `${FILE_SEARCH_SOURCE_LABELS.app}: ${suggestion.name}`;
+  }
+  return `${FILE_SEARCH_SOURCE_LABELS[suggestion.source]}: ${suggestion.path}`;
+}
+
+function getFileSearchSectionKind(
+  suggestion: FileSearchSuggestion,
+): FileSearchSectionKind {
+  return suggestion.entryKind === "app" ? "apps" : "files";
 }
 
 function groupFileSearchSections({
@@ -125,14 +147,15 @@ function groupFileSearchSections({
   suggestions,
 }: GroupFileSearchSectionsArgs): FileSearchSection[] {
   const allowedSources = new Set<FileSearchSource>(availableSources);
-  const sectionsBySource = new Map<FileSearchSource, FileSearchSection>();
+  const sectionsByKind = new Map<FileSearchSectionKind, FileSearchSection>();
 
   for (const suggestion of suggestions) {
     const source = suggestion.source;
     if (!allowedSources.has(source)) {
       continue;
     }
-    const existing = sectionsBySource.get(source);
+    const sectionKind = getFileSearchSectionKind(suggestion);
+    const existing = sectionsByKind.get(sectionKind);
     if (existing) {
       existing.items.push({
         suggestion,
@@ -141,16 +164,16 @@ function groupFileSearchSections({
       continue;
     }
 
-    sectionsBySource.set(source, {
-      source,
-      label: FILE_SEARCH_SECTION_LABELS[source],
+    sectionsByKind.set(sectionKind, {
+      kind: sectionKind,
+      label: FILE_SEARCH_SECTION_LABELS[sectionKind],
       items: [{ suggestion, index: 0 }],
     });
   }
 
   let nextIndex = 0;
-  return FILE_SEARCH_SECTION_ORDER.flatMap((source) => {
-    const section = sectionsBySource.get(source);
+  return FILE_SEARCH_SECTION_ORDER.flatMap((sectionKind) => {
+    const section = sectionsByKind.get(sectionKind);
     if (!section) {
       return [];
     }
@@ -189,12 +212,41 @@ function FileSearchResultRow({
   onActivate,
   onSelect,
 }: FileSearchResultRowProps) {
-  const { directory } = splitPath(suggestion.path);
-  const secondaryDirectory = directory || null;
   const handleSelect = useCallback(() => {
     onSelect(suggestion);
   }, [onSelect, suggestion]);
 
+  if (suggestion.entryKind === "app") {
+    return (
+      <button
+        type="button"
+        id={id}
+        role="option"
+        aria-selected={isActive}
+        onClick={handleSelect}
+        onMouseEnter={onActivate}
+        title={getFileSearchResultTitle(suggestion)}
+        className={cn(
+          "w-full scroll-mt-7 rounded px-2 py-1.5 text-left text-xs transition-colors",
+          isActive ? "bg-state-active" : "hover:bg-state-hover",
+        )}
+      >
+        <div className="flex min-w-0 items-center gap-1.5">
+          <ResolvedAppIcon icon={suggestion.app.icon} className="size-3.5" />
+          <span className="truncate">{suggestion.name}</span>
+          {suggestion.appId !== suggestion.name ? (
+            <TruncateStart className="text-muted-foreground [flex-shrink:9999]">
+              {suggestion.appId}
+            </TruncateStart>
+          ) : null}
+        </div>
+      </button>
+    );
+  }
+
+  const { directory } = splitPath(suggestion.path);
+  const secondaryDirectory = directory || null;
+
   return (
     <button
       type="button"
@@ -294,6 +346,14 @@ export function NewTabFileSearch({
 
   const handleSuggestionSelect = useCallback(
     (suggestion: FileSearchSuggestion) => {
+      if (suggestion.entryKind === "app") {
+        onSelect({
+          source: "app",
+          appId: suggestion.appId,
+        });
+        return;
+      }
+
       onSelect({
         source: suggestion.source,
         path: suggestion.path,
@@ -343,11 +403,15 @@ export function NewTabFileSearch({
           onChange={(event) => setQuery(event.target.value)}
           onKeyDown={handleInputKeyDown}
           disabled={isUnavailable}
-          aria-label="Search files"
+          aria-label="Search apps and files"
           aria-activedescendant={
-            activeSuggestion ? getFileSearchResultId(activeSuggestion) : undefined
+            activeSuggestion
+              ? getFileSearchResultId(activeSuggestion)
+              : undefined
+          }
+          placeholder={
+            isUnavailable ? "No searchable source" : "Search apps and files"
           }
-          placeholder={isUnavailable ? "No searchable source" : "Search files"}
           className="h-8 pl-8 pr-8 text-xs focus-visible:ring-0"
         />
         {isDebouncing ? (
@@ -361,28 +425,17 @@ export function NewTabFileSearch({
       {isUnavailable ? (
         <FileSearchMessage
           iconName="FileQuestion"
-          message="No searchable file source is available."
-        />
-      ) : isError ? (
-        <FileSearchMessage
-          iconName="AlertCircle"
-          message="File search failed."
-        />
-      ) : isLoading ? (
-        <FileSearchMessage
-          iconName="Spinner"
-          iconClassName="animate-spin"
-          message="Searching files..."
+          message="No searchable app or file source is available."
         />
       ) : sections.length > 0 ? (
         <div
           role="listbox"
-          aria-label="File search results"
+          aria-label="App and file search results"
           className="min-h-0 flex-1 overflow-y-auto pb-1"
         >
           {sections.map((section, sectionIndex) => (
             <div
-              key={section.source}
+              key={section.kind}
               className={cn(sectionIndex > 0 && "mt-2")}
             >
               <div
@@ -396,7 +449,11 @@ export function NewTabFileSearch({
               <div className="flex flex-col gap-px">
                 {section.items.map(({ suggestion, index }) => (
                   <FileSearchResultRow
-                    key={`${suggestion.source}:${suggestion.path}`}
+                    key={`${suggestion.source}:${
+                      suggestion.entryKind === "app"
+                        ? suggestion.appId
+                        : suggestion.path
+                    }`}
                     id={getFileSearchResultId(suggestion)}
                     suggestion={suggestion}
                     isActive={index === activeIndex}
@@ -408,10 +465,25 @@ export function NewTabFileSearch({
             </div>
           ))}
         </div>
+      ) : isError ? (
+        <FileSearchMessage
+          iconName="AlertCircle"
+          message="App and file search failed."
+        />
+      ) : isLoading ? (
+        <FileSearchMessage
+          iconName="Spinner"
+          iconClassName="animate-spin"
+          message="Searching apps and files..."
+        />
       ) : (
         <FileSearchMessage
           iconName={hasQuery ? "FileQuestion" : "File"}
-          message={hasQuery ? "No files match." : "Type to search files."}
+          message={
+            hasQuery
+              ? "No apps or files match."
+              : "Type to search apps and files."
+          }
         />
       )}
     </div>
diff --git a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
index 205af5582..976a27434 100644
--- a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
@@ -1,7 +1,7 @@
 // @vitest-environment jsdom
 
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import type { WorkspacePathEntry } from "@bb/server-contract";
+import type { AppSummary, WorkspacePathEntry } from "@bb/server-contract";
 import * as api from "@/lib/api";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createQueryClientTestHarness } from "@/test/queryClientTestHarness";
@@ -14,6 +14,7 @@ vi.mock("@/lib/api", async (importOriginal) => {
   return {
     ...actual,
     searchProjectPaths: vi.fn(),
+    listThreadApps: vi.fn(),
     listThreadStoragePaths: vi.fn(),
   };
 });
@@ -60,6 +61,14 @@ function makePathResponse(
   };
 }
 
+const STATUS_APP: AppSummary = {
+  id: "status",
+  name: "Status",
+  entry: { path: "index.html", kind: "html" },
+  capabilities: ["data", "message"],
+  icon: { kind: "builtin", name: "ListTodo" },
+};
+
 function renderNewTabPage(args: RenderNewTabPageArgs = {}) {
   const { wrapper } = createQueryClientTestHarness();
   const onSelect: (selection: FileSearchSelection) => void =
@@ -87,6 +96,7 @@ afterEach(() => {
 
 describe("NewTabPage", () => {
   it("autofocuses search and selects a workspace result", async () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
     vi.mocked(api.searchProjectPaths).mockResolvedValue(
       makePathResponse([
         {
@@ -98,10 +108,12 @@ describe("NewTabPage", () => {
     );
     const { onSelect } = renderNewTabPage({ projectId: "proj-1" });
 
-    const input = screen.getByRole("textbox", { name: "Search files" });
+    const input = screen.getByRole("textbox", {
+      name: "Search apps and files",
+    });
     expect(document.activeElement).toBe(input);
     fireEvent.change(input, { target: { value: "app" } });
-    expect(await screen.findByText("Workspace")).toBeTruthy();
+    expect(await screen.findByText("Files")).toBeTruthy();
     expect(await screen.findByText("app.ts")).toBeTruthy();
     expect(await screen.findByText(/src/u)).toBeTruthy();
     expect(screen.queryByText("Manager Storage")).toBeNull();
@@ -115,7 +127,24 @@ describe("NewTabPage", () => {
     });
   });
 
+  it("lists apps and opens an app selection", async () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([STATUS_APP]);
+    const { onSelect } = renderNewTabPage({
+      currentThreadId: "thr-manager",
+      currentThreadType: "manager",
+    });
+
+    expect(await screen.findByText("Apps")).toBeTruthy();
+    fireEvent.click(await screen.findByRole("option", { name: /Status/u }));
+
+    expect(onSelect).toHaveBeenCalledWith({
+      source: "app",
+      appId: "status",
+    });
+  });
+
   it("selects a manager thread-storage result with the keyboard", async () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
     vi.mocked(api.searchProjectPaths).mockResolvedValue(
       makePathResponse([
         {
@@ -141,10 +170,11 @@ describe("NewTabPage", () => {
       currentThreadType: "manager",
     });
 
-    const input = screen.getByRole("textbox", { name: "Search files" });
+    const input = screen.getByRole("textbox", {
+      name: "Search apps and files",
+    });
     fireEvent.change(input, { target: { value: "status" } });
-    await screen.findByText("Workspace");
-    await screen.findByText("Manager Storage");
+    await screen.findByText("Files");
     fireEvent.keyDown(input, { key: "ArrowDown" });
     fireEvent.keyDown(input, { key: "Enter" });
 
@@ -155,12 +185,13 @@ describe("NewTabPage", () => {
   });
 
   it("renders an unavailable state without querying", () => {
-    renderNewTabPage();
+    renderNewTabPage({ currentThreadId: "" });
 
     expect(
-      screen.getByText("No searchable file source is available."),
+      screen.getByText("No searchable app or file source is available."),
     ).toBeTruthy();
     expect(api.searchProjectPaths).not.toHaveBeenCalled();
+    expect(api.listThreadApps).not.toHaveBeenCalled();
     expect(api.listThreadStoragePaths).not.toHaveBeenCalled();
   });
 });
diff --git a/apps/app/src/components/secondary-panel/NewTabPage.tsx b/apps/app/src/components/secondary-panel/NewTabPage.tsx
index 29c7ef399..63ad3725a 100644
--- a/apps/app/src/components/secondary-panel/NewTabPage.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabPage.tsx
@@ -3,10 +3,9 @@ import { NewTabFileSearch, type NewTabFileSearchProps } from "./NewTabFileSearch
 export type NewTabPageProps = NewTabFileSearchProps;
 
 /**
- * Browser-style "New Tab" landing page for the secondary panel. Today its only
- * capability is file search, but it is structured as a page that hosts sections
- * so future entry points (e.g. open a terminal, quick links) can be added
- * alongside the search without reshaping the tab.
+ * Browser-style "New Tab" landing page for the secondary panel. It hosts the
+ * unified app and file launcher so future entry points can sit beside it
+ * without reshaping the tab.
  */
 export function NewTabPage(props: NewTabPageProps) {
   return (
diff --git a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.tsx b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.tsx
index d7a328aad..376c4bb0f 100644
--- a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.tsx
@@ -53,6 +53,7 @@ export interface SecondaryPanelFileTab {
   filename: string;
   isActive: boolean;
   isPinned?: boolean;
+  leadingVisual?: ReactNode;
   statusLabel: WorkspaceFilePreviewStatusLabel | null;
   onSelect: () => void;
   onClose: () => void;
@@ -403,6 +404,7 @@ function FileTab({ tab }: { tab: SecondaryPanelFileTab }) {
   return (
     <TabPill
       label={tab.filename}
+      leadingVisual={tab.leadingVisual}
       secondaryLabel={tab.statusLabel === null ? null : `(${tab.statusLabel})`}
       title={title}
       isActive={tab.isActive}
diff --git a/apps/app/src/components/secondary-panel/ThreadSecondaryPanelNewTab.stories.tsx b/apps/app/src/components/secondary-panel/ThreadSecondaryPanelNewTab.stories.tsx
index de2950dec..188d1d623 100644
--- a/apps/app/src/components/secondary-panel/ThreadSecondaryPanelNewTab.stories.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadSecondaryPanelNewTab.stories.tsx
@@ -1,6 +1,7 @@
 import { useMemo, useState, type ReactNode } from "react";
 import { QueryClientProvider } from "@tanstack/react-query";
 import type {
+  AppSummary,
   ThreadStoragePathListResponse,
   WorkspacePathEntry,
   WorkspacePathListResponse,
@@ -9,6 +10,7 @@ import { StoryCard, StoryRow } from "../../../.ladle/story-card";
 import { createAppQueryClient } from "@/lib/query-client";
 import {
   projectPathsQueryKey,
+  threadAppsQueryKey,
   threadStoragePathsQueryKey,
 } from "@/hooks/queries/query-keys";
 import { ThreadSecondaryPanel } from "./ThreadSecondaryPanel";
@@ -89,6 +91,16 @@ const THREAD_STORAGE_PATH_RESPONSE: ThreadStoragePathListResponse = {
   truncated: false,
 };
 
+const THREAD_APPS_RESPONSE: AppSummary[] = [
+  {
+    id: "status",
+    name: "Status",
+    entry: { path: "index.html", kind: "html" },
+    capabilities: ["data", "message"],
+    icon: { kind: "builtin", name: "ListTodo" },
+  },
+];
+
 interface PanelStageProps {
   children: ReactNode;
 }
@@ -126,6 +138,10 @@ function useStoryQueryClient() {
       ),
       WORKSPACE_PATH_RESPONSE,
     );
+    queryClient.setQueryData(
+      threadAppsQueryKey(THREAD_ID),
+      THREAD_APPS_RESPONSE,
+    );
     queryClient.setQueryData(
       threadStoragePathsQueryKey(THREAD_ID, {
         limit: STORY_SOURCE_LIMIT,
@@ -148,8 +164,14 @@ function NewTabPanelStory() {
         ? [NEW_TAB]
         : [
             {
-              id: `${selection.source}:${selection.path}`,
-              filename: selection.path.split("/").at(-1) ?? selection.path,
+              id:
+                selection.source === "app"
+                  ? `app:${selection.appId}`
+                  : `${selection.source}:${selection.path}`,
+              filename:
+                selection.source === "app"
+                  ? selection.appId
+                  : (selection.path.split("/").at(-1) ?? selection.path),
               isActive: true,
               statusLabel: null,
               onSelect: noop,
@@ -175,11 +197,14 @@ function NewTabPanelStory() {
       <div className="flex min-h-full flex-col justify-center px-4 text-sm">
         <p className="font-medium text-foreground">
           Selected{" "}
-          {selection.source === "workspace" ? "workspace" : "thread storage"}{" "}
-          file
+          {selection.source === "app"
+            ? "app"
+            : selection.source === "workspace"
+              ? "workspace file"
+              : "thread storage file"}
         </p>
         <p className="pt-1 font-mono text-xs text-muted-foreground">
-          {selection.path}
+          {selection.source === "app" ? selection.appId : selection.path}
         </p>
       </div>
     );
diff --git a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
index 5ef63f160..ecc1c06eb 100644
--- a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
@@ -1,5 +1,4 @@
 import { useMemo } from "react";
-import { defaultUrlTransform, type UrlTransform } from "react-markdown";
 import {
   FilePreview as FilePreviewSurface,
   type FilePreviewFile,
@@ -18,6 +17,7 @@ import {
   buildThreadStatusContentUrl,
   buildThreadStorageRawContentUrl,
 } from "@/lib/file-content-urls";
+import { createAssetMarkdownUrlTransform } from "@/lib/markdown-url-transform";
 import type { ThreadStatusVersionResponse } from "@bb/server-contract";
 import type {
   FilePreview,
@@ -68,30 +68,6 @@ function buildTextPreviewFile({
   };
 }
 
-const STATUS_RELATIVE_ASSET_URL_PATTERN =
-  /^(?![a-z][a-z\d+.-]*:|\/\/|\/|#|\?)/iu;
-
-function isStatusRelativeAssetUrl(url: string): boolean {
-  return url.length > 0 && STATUS_RELATIVE_ASSET_URL_PATTERN.test(url);
-}
-
-function resolveStatusAssetUrl(assetBaseUrl: string, url: string): string {
-  const baseUrl = new URL(assetBaseUrl, window.location.origin);
-  const assetUrl = new URL(url, baseUrl);
-  return `${assetUrl.pathname}${assetUrl.search}${assetUrl.hash}`;
-}
-
-function createStatusMarkdownUrlTransform(assetBaseUrl: string): UrlTransform {
-  return (url) => {
-    const transformedUrl = defaultUrlTransform(url);
-    if (!isStatusRelativeAssetUrl(transformedUrl)) {
-      return transformedUrl;
-    }
-
-    return resolveStatusAssetUrl(assetBaseUrl, transformedUrl);
-  };
-}
-
 function buildManagerStatusPreviewUrl(
   threadId: string,
   version: ThreadStatusVersionResponse,
@@ -266,7 +242,7 @@ export function ThreadStorageFilePreview({
     [threadId],
   );
   const statusMarkdownUrlTransform = useMemo(() => {
-    return createStatusMarkdownUrlTransform(statusMarkdownAssetBaseUrl);
+    return createAssetMarkdownUrlTransform(statusMarkdownAssetBaseUrl);
   }, [statusMarkdownAssetBaseUrl]);
 
   if (isManagerStatusTab) {
diff --git a/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx b/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
index a0e71ecc4..1f6d10eb4 100644
--- a/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
+++ b/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
@@ -48,6 +48,7 @@ interface TestWrapperProps {
 }
 
 interface HookProps {
+  apps?: readonly { id: string }[];
   environmentId: string | null | undefined;
   storageFiles: readonly { path: string }[] | undefined;
   threadId: string;
@@ -144,6 +145,10 @@ function storageFilePaths(
   return tabs.filter(isStorageFilePreviewTab).map((tab) => tab.path);
 }
 
+function appTabIds(tabs: readonly SecondaryFileFixedPanelTab[]): string[] {
+  return tabs.filter((tab) => tab.kind === "app").map((tab) => tab.appId);
+}
+
 function workspaceFileTabId(path: string): string {
   return `workspace-file-preview:${encodeURIComponent(path)}`;
 }
@@ -220,6 +225,12 @@ function getStoredStoragePaths(state: FixedPanelTabsState): string[] {
     .map((tab) => tab.path);
 }
 
+function getStoredAppIds(state: FixedPanelTabsState): string[] {
+  return state.secondary.tabs
+    .filter((tab) => tab.kind === "app")
+    .map((tab) => tab.appId);
+}
+
 afterEach(() => {
   cleanup();
   window.localStorage.clear();
@@ -867,6 +878,79 @@ describe("useThreadFileTabs", () => {
     ]);
   });
 
+  it("adds a pinned status app tab alongside the existing manager STATUS tab", async () => {
+    const { result } = renderThreadFileTabsHook({
+      apps: [{ id: "status" }],
+      environmentId: null,
+      threadType: "manager",
+      storageFiles: [{ path: "STATUS" }],
+      threadId: "thr-manager-status-app",
+    });
+
+    await waitFor(() => {
+      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
+        ["STATUS"],
+      );
+      expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+        "status",
+      ]);
+    });
+    expect(result.current.activeStorageFilePath).toBe("STATUS");
+    expect(result.current.activeAppId).toBeNull();
+  });
+
+  it("opens an app tab from launcher search selection", () => {
+    const { result } = renderThreadFileTabsHook({
+      apps: [{ id: "demo" }],
+      environmentId: "env-one",
+      threadType: "standard",
+      storageFiles: undefined,
+      threadId: "thr-app-selection",
+    });
+
+    act(() => {
+      result.current.openNewTab();
+      result.current.selectFileSearchResult({
+        source: "app",
+        appId: "demo",
+      });
+    });
+
+    expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+      "demo",
+    ]);
+    expect(result.current.activeAppId).toBe("demo");
+    expect(getStoredAppIds(readStoredState("thr-app-selection"))).toEqual([
+      "demo",
+    ]);
+  });
+
+  it("keeps the pinned status app tab open when close is requested", async () => {
+    const { result } = renderThreadFileTabsHook({
+      apps: [{ id: "status" }],
+      environmentId: null,
+      threadType: "manager",
+      storageFiles: [{ path: "STATUS" }],
+      threadId: "thr-manager-status-app-pinned",
+    });
+
+    await waitFor(() => {
+      expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+        "status",
+      ]);
+    });
+
+    act(() => {
+      result.current.activateAppTab("status");
+      result.current.closeAppTab("status");
+    });
+
+    expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+      "status",
+    ]);
+    expect(result.current.activeAppId).toBe("status");
+  });
+
   it("does not rewrite workspace tabs for no-op callbacks", () => {
     const dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(NOW);
     const threadId = "thr-workspace-no-op";
diff --git a/apps/app/src/components/secondary-panel/useThreadFileTabs.ts b/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
index ff848bdaf..58ab68ab1 100644
--- a/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
+++ b/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect } from "react";
+import { useCallback, useEffect, useMemo } from "react";
 import type { ThreadType } from "@bb/domain";
 import {
   useFixedPanelTabsState,
@@ -6,10 +6,12 @@ import {
 } from "@/lib/fixed-panel-tabs";
 import {
   areFixedPanelTabsEquivalent,
+  createAppFixedPanelTab,
   createHostFilePreviewFixedPanelTab,
   createNewTabFixedPanelTab,
   createThreadStorageFilePreviewFixedPanelTab,
   createWorkspaceFilePreviewFixedPanelTab,
+  type AppFixedPanelTab,
   type FixedPanelTab,
   type FixedPanelTabsState,
   type HostFilePreviewFixedPanelTab,
@@ -29,7 +31,14 @@ import {
   resolvePinnedManagerStorageFilePath,
 } from "./managerStorage";
 
+export const STATUS_APP_ID = "status";
+
+interface ThreadAppTabDescriptor {
+  id: string;
+}
+
 interface UseThreadFileTabsParams {
+  apps?: readonly ThreadAppTabDescriptor[] | undefined;
   threadId: string | null | undefined;
   environmentId: string | null | undefined;
   threadType: ThreadType | undefined;
@@ -58,9 +67,15 @@ export interface FileSearchThreadStorageSelection {
   path: string;
 }
 
+export interface FileSearchAppSelection {
+  source: "app";
+  appId: string;
+}
+
 export type FileSearchSelection =
   | FileSearchWorkspaceSelection
-  | FileSearchThreadStorageSelection;
+  | FileSearchThreadStorageSelection
+  | FileSearchAppSelection;
 
 function isWorkspaceFilePreviewTab(
   tab: FixedPanelTab,
@@ -80,6 +95,10 @@ function isStorageFilePreviewTab(
   return tab.kind === "thread-storage-file-preview";
 }
 
+function isAppTab(tab: FixedPanelTab): tab is AppFixedPanelTab {
+  return tab.kind === "app";
+}
+
 function isNewTab(tab: FixedPanelTab): tab is NewTabFixedPanelTab {
   return tab.kind === "new-tab";
 }
@@ -184,6 +203,16 @@ function pruneStorageTabs(
   return nextTabs.length === tabs.length ? tabs : nextTabs;
 }
 
+function pruneAppTabs(
+  tabs: readonly FixedPanelTab[],
+  knownAppIds: ReadonlySet<string>,
+): readonly FixedPanelTab[] {
+  const nextTabs = tabs.filter(
+    (tab) => !isAppTab(tab) || knownAppIds.has(tab.appId),
+  );
+  return nextTabs.length === tabs.length ? tabs : nextTabs;
+}
+
 function isActiveTabStillOpen(
   tabs: readonly FixedPanelTab[],
   activeTabId: string | null,
@@ -202,6 +231,10 @@ function createStorageTab(
   });
 }
 
+function createAppTab(appId: string): AppFixedPanelTab {
+  return createAppFixedPanelTab({ appId });
+}
+
 function getManagerDefaultActiveTabId(
   tabs: readonly FixedPanelTab[],
   pinnedStorageFilePath: string,
@@ -249,6 +282,18 @@ function findStorageFileTab(
   return null;
 }
 
+function findAppTab(
+  tabs: readonly FixedPanelTab[],
+  appId: string,
+): AppFixedPanelTab | null {
+  for (const tab of tabs) {
+    if (isAppTab(tab) && tab.appId === appId) {
+      return tab;
+    }
+  }
+  return null;
+}
+
 function findNewTab(
   tabs: readonly FixedPanelTab[],
 ): NewTabFixedPanelTab | null {
@@ -307,6 +352,14 @@ function isPinnedStorageTab(tab: SecondaryFileFixedPanelTab): boolean {
   return tab.kind === "thread-storage-file-preview" && tab.isPinned;
 }
 
+function isPinnedAppTab(tab: SecondaryFileFixedPanelTab): boolean {
+  return tab.kind === "app" && tab.appId === STATUS_APP_ID;
+}
+
+function isPinnedSecondaryFileTab(tab: SecondaryFileFixedPanelTab): boolean {
+  return isPinnedStorageTab(tab) || isPinnedAppTab(tab);
+}
+
 /**
  * Flattens the secondary panel's tabs into the closable file-tab strip, in the
  * order the user opened them. The pinned manager status tab is floated to the
@@ -330,6 +383,7 @@ function buildOrderedSecondaryFileTabs({
         }
         break;
       case "host-file-preview":
+      case "app":
       case "new-tab":
         displayable.push(tab);
         break;
@@ -345,12 +399,13 @@ function buildOrderedSecondaryFileTabs({
     }
   }
   return [
-    ...displayable.filter(isPinnedStorageTab),
-    ...displayable.filter((tab) => !isPinnedStorageTab(tab)),
+    ...displayable.filter(isPinnedSecondaryFileTab),
+    ...displayable.filter((tab) => !isPinnedSecondaryFileTab(tab)),
   ];
 }
 
 export function useThreadFileTabs({
+  apps,
   threadId,
   environmentId,
   threadType,
@@ -365,6 +420,10 @@ export function useThreadFileTabs({
   const resolvedEnvironmentId = isThreadResolved
     ? (environmentId ?? null)
     : undefined;
+  const appIds = useMemo(
+    () => (apps ? new Set(apps.map((app) => app.id)) : null),
+    [apps],
+  );
 
   useEffect(() => {
     if (resolvedEnvironmentId === undefined) return;
@@ -475,6 +534,41 @@ export function useThreadFileTabs({
     updateFixedPanelTabsState,
   ]);
 
+  useEffect(() => {
+    if (!isThreadResolved || appIds === null) return;
+    updateFixedPanelTabsState((state) => {
+      const tabs = pruneAppTabs(state.secondary.tabs, appIds);
+      const activeTabId = isActiveTabStillOpen(
+        tabs,
+        state.secondary.activeTabId,
+      )
+        ? state.secondary.activeTabId
+        : null;
+      return setSecondaryTabs({
+        activeTabId,
+        isOpen: state.secondary.isOpen,
+        state,
+        tabs,
+      });
+    });
+  }, [appIds, isThreadResolved, updateFixedPanelTabsState]);
+
+  useEffect(() => {
+    if (!isManagerThread || appIds === null || !appIds.has(STATUS_APP_ID)) {
+      return;
+    }
+    updateFixedPanelTabsState((state) => {
+      const statusAppTab = createAppTab(STATUS_APP_ID);
+      const tabs = upsertSecondaryTab(state.secondary.tabs, statusAppTab);
+      return setSecondaryTabs({
+        activeTabId: state.secondary.activeTabId,
+        isOpen: state.secondary.isOpen,
+        state,
+        tabs,
+      });
+    });
+  }, [appIds, isManagerThread, updateFixedPanelTabsState]);
+
   const openWorkspaceFile = useCallback(
     ({ lineNumber, path, source, statusLabel }: WorkspaceFileTabState) => {
       if (resolvedEnvironmentId === undefined) return;
@@ -651,6 +745,73 @@ export function useThreadFileTabs({
     [updateFixedPanelTabsState],
   );
 
+  const openApp = useCallback(
+    (appId: string) => {
+      const nextTab = createAppTab(appId);
+      updateFixedPanelTabsState((state) => {
+        const tabs = upsertSecondaryTab(state.secondary.tabs, nextTab);
+        if (
+          tabs === state.secondary.tabs &&
+          state.secondary.activeTabId === nextTab.id &&
+          state.secondary.isOpen
+        ) {
+          return state;
+        }
+        return setSecondaryTabs({
+          activeTabId: nextTab.id,
+          isOpen: true,
+          state,
+          tabs,
+        });
+      });
+    },
+    [updateFixedPanelTabsState],
+  );
+
+  const closeAppTab = useCallback(
+    (appId: string) => {
+      if (appId === STATUS_APP_ID) return;
+      updateFixedPanelTabsState((state) => {
+        const tab = findAppTab(state.secondary.tabs, appId);
+        if (!tab) {
+          return state;
+        }
+        const tabs = removeSecondaryTab(state.secondary.tabs, tab.id);
+        return setSecondaryTabs({
+          activeTabId:
+            state.secondary.activeTabId === tab.id
+              ? null
+              : state.secondary.activeTabId,
+          isOpen: state.secondary.isOpen,
+          state,
+          tabs,
+        });
+      });
+    },
+    [updateFixedPanelTabsState],
+  );
+
+  const activateAppTab = useCallback(
+    (appId: string) => {
+      updateFixedPanelTabsState((state) => {
+        const tab = findAppTab(state.secondary.tabs, appId);
+        if (!tab) {
+          return state;
+        }
+        if (state.secondary.activeTabId === tab.id && state.secondary.isOpen) {
+          return state;
+        }
+        return setSecondaryTabs({
+          activeTabId: tab.id,
+          isOpen: true,
+          state,
+          tabs: state.secondary.tabs,
+        });
+      });
+    },
+    [updateFixedPanelTabsState],
+  );
+
   const closeStorageFileTab = useCallback(
     (path: string) => {
       if (!isManagerThread || path === pinnedStorageFilePath) return;
@@ -759,6 +920,14 @@ export function useThreadFileTabs({
 
   const selectFileSearchResult = useCallback(
     (selection: FileSearchSelection) => {
+      if (selection.source === "app") {
+        const nextTab = createAppTab(selection.appId);
+        updateFixedPanelTabsState((state) =>
+          replaceNewTab({ nextTab, state }),
+        );
+        return;
+      }
+
       if (selection.source === "workspace") {
         if (resolvedEnvironmentId === undefined) return;
         const nextTab = createWorkspaceFilePreviewFixedPanelTab({
@@ -797,7 +966,8 @@ export function useThreadFileTabs({
         !activeTab ||
         (activeTab.kind !== "workspace-file-preview" &&
           activeTab.kind !== "host-file-preview" &&
-          activeTab.kind !== "thread-storage-file-preview")
+          activeTab.kind !== "thread-storage-file-preview" &&
+          activeTab.kind !== "app")
       ) {
         return state;
       }
@@ -827,14 +997,17 @@ export function useThreadFileTabs({
       : null;
   const activeHostFileTab =
     activeTab?.kind === "host-file-preview" ? activeTab : null;
+  const activeAppTab = activeTab?.kind === "app" ? activeTab : null;
   const activeNewTab = activeTab?.kind === "new-tab" ? activeTab : null;
 
   return {
     orderedSecondaryFileTabs,
+    activateAppTab,
     activateNewTab,
     activateHostFileTab,
     activateStorageFileTab,
     activateWorkspaceFileTab,
+    activeAppId: activeAppTab?.appId ?? null,
     activeHostFileLineNumber: activeHostFileTab?.lineNumber ?? null,
     activeHostFilePath: activeHostFileTab?.path ?? null,
     activeStorageFilePath: activeStorageFileTab?.path ?? null,
@@ -843,6 +1016,7 @@ export function useThreadFileTabs({
     activeWorkspaceFileSource: activeWorkspaceFileTab?.source ?? null,
     activeWorkspaceFileStatusLabel: activeWorkspaceFileTab?.statusLabel ?? null,
     clearActiveFileTabs,
+    closeAppTab,
     closeHostFileTab,
     closeNewTab,
     closeStorageFileTab,
@@ -850,6 +1024,7 @@ export function useThreadFileTabs({
     hasNewTab: findNewTab(fixedPanelTabsState.secondary.tabs) !== null,
     isNewTabActive: activeNewTab !== null,
     openNewTab,
+    openApp,
     openHostFile,
     openStorageFile,
     openWorkspaceFile,
diff --git a/apps/app/src/components/ui/tab-pill.tsx b/apps/app/src/components/ui/tab-pill.tsx
index c29fb5418..c981685e3 100644
--- a/apps/app/src/components/ui/tab-pill.tsx
+++ b/apps/app/src/components/ui/tab-pill.tsx
@@ -1,5 +1,6 @@
 import { Icon } from "@/components/ui/icon.js";
 import { cn } from "@/lib/utils";
+import type { ReactNode } from "react";
 
 const TAB_PILL_DEFAULT_LABEL_MAX_WIDTH_CLASS = "max-w-[180px]";
 
@@ -12,6 +13,7 @@ export interface TabPillCloseAction {
 
 export interface TabPillProps {
   label: string;
+  leadingVisual?: ReactNode;
   secondaryLabel?: string | null;
   /** Extra classes for the label text (e.g. `line-through` for a done tab). */
   labelClassName?: string;
@@ -24,6 +26,7 @@ export interface TabPillProps {
 
 export function TabPill({
   label,
+  leadingVisual,
   secondaryLabel = null,
   labelClassName,
   title,
@@ -52,6 +55,11 @@ export function TabPill({
           isClosable ? "pr-1" : "rounded-r-md pr-2",
         )}
       >
+        {leadingVisual ? (
+          <span className="mr-1.5 inline-flex shrink-0 items-center">
+            {leadingVisual}
+          </span>
+        ) : null}
         <span className={cn("truncate", labelMaxWidthClass, labelClassName)}>
           {label}
         </span>
diff --git a/apps/app/src/hooks/queries/query-keys.ts b/apps/app/src/hooks/queries/query-keys.ts
index dfe3b2580..9e2d47e65 100644
--- a/apps/app/src/hooks/queries/query-keys.ts
+++ b/apps/app/src/hooks/queries/query-keys.ts
@@ -40,6 +40,10 @@ export const THREAD_STORAGE_FILE_PREVIEW_QUERY_KEY = "threadStorageFilePreview";
 export const THREAD_STATUS_VERSION_QUERY_KEY = "threadStatusVersion";
 export const THREAD_STATUS_MARKDOWN_PREVIEW_QUERY_KEY =
   "threadStatusMarkdownPreview";
+export const THREAD_APPS_QUERY_KEY = "threadApps";
+export const THREAD_APP_QUERY_KEY = "threadApp";
+export const THREAD_APP_MARKDOWN_PREVIEW_QUERY_KEY =
+  "threadAppMarkdownPreview";
 export const THREAD_HOST_FILE_PREVIEW_QUERY_KEY = "threadHostFilePreview";
 export const ENVIRONMENT_QUERY_KEY = "environment";
 export const ENVIRONMENT_WORK_STATUS_QUERY_KEY = "environmentWorkStatus";
@@ -263,6 +267,21 @@ export type ThreadStatusMarkdownPreviewQueryKey = readonly [
   string,
   string | null | undefined,
 ];
+export type ThreadAppsQueryKey = readonly [
+  typeof THREAD_APPS_QUERY_KEY,
+  string,
+];
+export type ThreadAppQueryKey = readonly [
+  typeof THREAD_APP_QUERY_KEY,
+  string,
+  string,
+];
+export type ThreadAppMarkdownPreviewQueryKey = readonly [
+  typeof THREAD_APP_MARKDOWN_PREVIEW_QUERY_KEY,
+  string,
+  string,
+  string | null | undefined,
+];
 export type AllThreadHostFilePreviewQueryKeyPrefix = readonly [
   typeof THREAD_HOST_FILE_PREVIEW_QUERY_KEY,
 ];
@@ -702,6 +721,25 @@ export function threadStatusMarkdownPreviewQueryKey(
   return [THREAD_STATUS_MARKDOWN_PREVIEW_QUERY_KEY, threadId, versionHash];
 }
 
+export function threadAppsQueryKey(threadId: string): ThreadAppsQueryKey {
+  return [THREAD_APPS_QUERY_KEY, threadId];
+}
+
+export function threadAppQueryKey(
+  threadId: string,
+  appId: string,
+): ThreadAppQueryKey {
+  return [THREAD_APP_QUERY_KEY, threadId, appId];
+}
+
+export function threadAppMarkdownPreviewQueryKey(
+  threadId: string,
+  appId: string,
+  entryPath: string | null | undefined,
+): ThreadAppMarkdownPreviewQueryKey {
+  return [THREAD_APP_MARKDOWN_PREVIEW_QUERY_KEY, threadId, appId, entryPath];
+}
+
 export function threadHostFilePreviewQueryKey(
   threadId: string,
   environmentId: string | null | undefined,
diff --git a/apps/app/src/hooks/queries/thread-queries.ts b/apps/app/src/hooks/queries/thread-queries.ts
index be7823b41..aa8529a56 100644
--- a/apps/app/src/hooks/queries/thread-queries.ts
+++ b/apps/app/src/hooks/queries/thread-queries.ts
@@ -27,6 +27,8 @@ import type {
   ThreadTimelineResponse,
   TimelineTurnSummaryDetailsRequest,
   TimelineTurnSummaryDetailsResponse,
+  AppDetail,
+  AppSummary,
 } from "@bb/server-contract";
 import type { ThreadListFilters, FilePreview } from "@/lib/api";
 import type { PathListOptions } from "@/lib/path-list-options";
@@ -57,6 +59,9 @@ import {
   threadStorageFilePreviewQueryKey,
   threadStatusMarkdownPreviewQueryKey,
   threadStatusVersionQueryKey,
+  threadAppMarkdownPreviewQueryKey,
+  threadAppQueryKey,
+  threadAppsQueryKey,
   threadHostFilePreviewQueryKey,
   threadTimelineQueryKey,
   type ArchivedThreadsKindFilter,
@@ -674,6 +679,59 @@ export function useThreadStatusMarkdownPreview(
   });
 }
 
+export function useThreadApps(id: string, options?: QueryOptions) {
+  return useQuery<AppSummary[]>({
+    queryKey: threadAppsQueryKey(id),
+    queryFn: ({ signal }) =>
+      api.listThreadApps(requireThreadId(id, "useThreadApps"), signal),
+    enabled: (options?.enabled ?? true) && Boolean(id),
+    refetchOnMount: options?.refetchOnMount ?? true,
+    refetchOnWindowFocus: false,
+    staleTime: options?.staleTime,
+  });
+}
+
+export function useThreadApp(
+  id: string,
+  appId: string | null | undefined,
+  options?: QueryOptions,
+) {
+  return useQuery<AppDetail>({
+    queryKey: threadAppQueryKey(id, appId ?? ""),
+    queryFn: ({ signal }) =>
+      api.getThreadApp(requireThreadId(id, "useThreadApp"), appId ?? "", signal),
+    enabled: (options?.enabled ?? true) && Boolean(id) && Boolean(appId),
+    refetchOnMount: options?.refetchOnMount ?? true,
+    refetchOnWindowFocus: false,
+    staleTime: options?.staleTime,
+  });
+}
+
+export function useThreadAppMarkdownPreview(
+  id: string,
+  appId: string | null | undefined,
+  entryPath: string | null | undefined,
+  options?: QueryOptions,
+) {
+  return useQuery<FilePreview>({
+    queryKey: threadAppMarkdownPreviewQueryKey(id, appId ?? "", entryPath),
+    queryFn: ({ signal }) =>
+      api.getThreadAppMarkdownPreview(
+        requireThreadId(id, "useThreadAppMarkdownPreview"),
+        appId ?? "",
+        entryPath ?? "",
+        signal,
+      ),
+    enabled:
+      (options?.enabled ?? true) &&
+      Boolean(id) &&
+      Boolean(appId) &&
+      Boolean(entryPath),
+    refetchOnWindowFocus: false,
+    staleTime: options?.staleTime,
+  });
+}
+
 export function useThreadHostFilePreview(
   id: string,
   environmentId: string | null | undefined,
diff --git a/apps/app/src/hooks/useFileSearchSuggestions.test.tsx b/apps/app/src/hooks/useFileSearchSuggestions.test.tsx
index 11bd20d6a..c2937f257 100644
--- a/apps/app/src/hooks/useFileSearchSuggestions.test.tsx
+++ b/apps/app/src/hooks/useFileSearchSuggestions.test.tsx
@@ -1,11 +1,15 @@
 // @vitest-environment jsdom
 
 import { cleanup, renderHook, waitFor } from "@testing-library/react";
-import type { WorkspacePathEntry } from "@bb/server-contract";
+import type { AppSummary, WorkspacePathEntry } from "@bb/server-contract";
 import * as api from "@/lib/api";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createQueryClientTestHarness } from "@/test/queryClientTestHarness";
-import { useFileSearchSuggestions } from "./useFileSearchSuggestions";
+import {
+  useFileSearchSuggestions,
+  type FilePathSearchSuggestion,
+  type FileSearchSuggestion,
+} from "./useFileSearchSuggestions";
 
 vi.mock("@/lib/api", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@/lib/api")>();
@@ -13,6 +17,7 @@ vi.mock("@/lib/api", async (importOriginal) => {
   return {
     ...actual,
     searchProjectPaths: vi.fn(),
+    listThreadApps: vi.fn(),
     listThreadStoragePaths: vi.fn(),
   };
 });
@@ -52,6 +57,20 @@ function makePathResponse(
   };
 }
 
+function isFilePathSearchSuggestion(
+  suggestion: FileSearchSuggestion,
+): suggestion is FilePathSearchSuggestion {
+  return suggestion.entryKind === "file";
+}
+
+const STATUS_APP: AppSummary = {
+  id: "status",
+  name: "Status",
+  entry: { path: "index.html", kind: "html" },
+  capabilities: ["data", "message"],
+  icon: { kind: "builtin", name: "ListTodo" },
+};
+
 afterEach(() => {
   cleanup();
   vi.clearAllMocks();
@@ -59,6 +78,7 @@ afterEach(() => {
 
 describe("useFileSearchSuggestions", () => {
   it("merges workspace and manager thread-storage file results", async () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
     vi.mocked(api.searchProjectPaths).mockResolvedValue(
       makePathResponse([
         {
@@ -99,10 +119,11 @@ describe("useFileSearchSuggestions", () => {
       expect(result.current.suggestions).toHaveLength(2);
     });
 
-    expect(result.current.suggestions.map((suggestion) => suggestion.path)).toEqual([
-      "notes/status.md",
-      "src/project.ts",
-    ]);
+    expect(
+      result.current.suggestions
+        .filter(isFilePathSearchSuggestion)
+        .map((suggestion) => suggestion.path),
+    ).toEqual(["notes/status.md", "src/project.ts"]);
     expect(api.searchProjectPaths).toHaveBeenCalledWith({
       projectId: "proj-1",
       query: "status",
@@ -123,6 +144,52 @@ describe("useFileSearchSuggestions", () => {
     });
   });
 
+  it("returns matching apps before files", async () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([STATUS_APP]);
+    vi.mocked(api.searchProjectPaths).mockResolvedValue(
+      makePathResponse([
+        {
+          kind: "file",
+          path: "notes/status.md",
+          score: 90,
+        },
+      ]),
+    );
+    vi.mocked(api.listThreadStoragePaths).mockResolvedValue({
+      ...makePathResponse([]),
+      storageRootPath: "/tmp/thread-storage",
+    });
+
+    const { wrapper } = createQueryClientTestHarness();
+    const { result } = renderHook(
+      () =>
+        useFileSearchSuggestions({
+          projectId: "proj-1",
+          query: "status",
+          environmentId: "env-1",
+          currentThreadId: "thr-manager",
+          currentThreadType: "manager",
+        }),
+      { wrapper },
+    );
+
+    await waitFor(() => {
+      expect(result.current.suggestions).toHaveLength(2);
+    });
+
+    expect(result.current.suggestions[0]).toMatchObject({
+      source: "app",
+      entryKind: "app",
+      appId: "status",
+      name: "Status",
+    });
+    expect(result.current.suggestions[1]).toMatchObject({
+      source: "workspace",
+      entryKind: "file",
+      path: "notes/status.md",
+    });
+  });
+
   it("excludes directory results defensively", async () => {
     vi.mocked(api.searchProjectPaths).mockResolvedValue(
       makePathResponse([
diff --git a/apps/app/src/hooks/useFileSearchSuggestions.ts b/apps/app/src/hooks/useFileSearchSuggestions.ts
index 92196e0a3..af7c4e4b6 100644
--- a/apps/app/src/hooks/useFileSearchSuggestions.ts
+++ b/apps/app/src/hooks/useFileSearchSuggestions.ts
@@ -1,14 +1,25 @@
 import { useMemo } from "react";
 import type { ThreadType } from "@bb/domain";
+import type { AppSummary } from "@bb/server-contract";
 import {
   usePathSuggestions,
   type PathSuggestion,
   type PathSuggestionSource,
 } from "./usePathSuggestions";
+import { useThreadApps } from "./queries/thread-queries";
 
 const DEFAULT_FILE_SEARCH_SUGGESTION_LIMIT = 8;
 
-export interface FileSearchSuggestion {
+export interface AppSearchSuggestion {
+  source: "app";
+  entryKind: "app";
+  app: AppSummary;
+  appId: string;
+  name: string;
+  score: number;
+}
+
+export interface FilePathSearchSuggestion {
   source: PathSuggestionSource;
   entryKind: "file";
   path: string;
@@ -17,6 +28,10 @@ export interface FileSearchSuggestion {
   positions: number[];
 }
 
+export type FileSearchSuggestion =
+  | AppSearchSuggestion
+  | FilePathSearchSuggestion;
+
 export interface UseFileSearchSuggestionsArgs {
   projectId: string | undefined;
   query: string | null;
@@ -38,6 +53,12 @@ interface FilePathSuggestion extends PathSuggestion {
   entryKind: "file";
 }
 
+interface BuildAppSearchSuggestionsArgs {
+  apps: readonly AppSummary[];
+  limit: number;
+  query: string;
+}
+
 function isFilePathSuggestion(
   suggestion: PathSuggestion,
 ): suggestion is FilePathSuggestion {
@@ -46,7 +67,7 @@ function isFilePathSuggestion(
 
 function toFileSearchSuggestion(
   suggestion: FilePathSuggestion,
-): FileSearchSuggestion {
+): FilePathSearchSuggestion {
   return {
     source: suggestion.source,
     entryKind: "file",
@@ -57,6 +78,63 @@ function toFileSearchSuggestion(
   };
 }
 
+function scoreAppSearchMatch(app: AppSummary, normalizedQuery: string): number {
+  if (normalizedQuery.length === 0) {
+    return 0;
+  }
+
+  const normalizedName = app.name.toLowerCase();
+  const normalizedId = app.id.toLowerCase();
+  if (normalizedName === normalizedQuery || normalizedId === normalizedQuery) {
+    return 100;
+  }
+  if (
+    normalizedName.startsWith(normalizedQuery) ||
+    normalizedId.startsWith(normalizedQuery)
+  ) {
+    return 90;
+  }
+  if (normalizedName.includes(normalizedQuery)) {
+    return 80;
+  }
+  if (normalizedId.includes(normalizedQuery)) {
+    return 70;
+  }
+  return -1;
+}
+
+function buildAppSearchSuggestions({
+  apps,
+  limit,
+  query,
+}: BuildAppSearchSuggestionsArgs): AppSearchSuggestion[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  const suggestions: AppSearchSuggestion[] = [];
+  for (const app of apps) {
+    const score = scoreAppSearchMatch(app, normalizedQuery);
+    if (score < 0) {
+      continue;
+    }
+    suggestions.push({
+      source: "app",
+      entryKind: "app",
+      app,
+      appId: app.id,
+      name: app.name,
+      score,
+    });
+  }
+
+  return suggestions
+    .sort((left, right) => {
+      if (left.score !== right.score) {
+        return right.score - left.score;
+      }
+      return left.name.localeCompare(right.name);
+    })
+    .slice(0, limit);
+}
+
 export function useFileSearchSuggestions(
   args: UseFileSearchSuggestionsArgs,
 ): UseFileSearchSuggestionsResult {
@@ -70,22 +148,41 @@ export function useFileSearchSuggestions(
     currentThreadType: args.currentThreadType,
     includeDirectories: false,
   });
-  const suggestions = useMemo<FileSearchSuggestion[]>(
+  const canSearchApps = Boolean(args.currentThreadId);
+  const threadApps = useThreadApps(args.currentThreadId ?? "", {
+    enabled: canSearchApps,
+  });
+  const appSuggestions = useMemo<AppSearchSuggestion[]>(
+    () =>
+      buildAppSearchSuggestions({
+        apps: threadApps.data ?? [],
+        limit,
+        query: args.query ?? "",
+      }),
+    [args.query, limit, threadApps.data],
+  );
+  const fileSuggestions = useMemo<FilePathSearchSuggestion[]>(
     () =>
       pathSuggestions.suggestions
         .filter(isFilePathSuggestion)
         .map(toFileSearchSuggestion),
     [pathSuggestions.suggestions],
   );
+  const suggestions = useMemo<FileSearchSuggestion[]>(
+    () => [...appSuggestions, ...fileSuggestions],
+    [appSuggestions, fileSuggestions],
+  );
   const canSearchWorkspace = Boolean(args.projectId);
   const canSearchThreadStorage =
     args.currentThreadType === "manager" && Boolean(args.currentThreadId);
 
   return {
     suggestions,
-    isLoading: pathSuggestions.isLoading,
-    isError: pathSuggestions.isError,
+    isLoading:
+      suggestions.length === 0 &&
+      (pathSuggestions.isLoading || (canSearchApps && threadApps.isLoading)),
+    isError: pathSuggestions.isError || (canSearchApps && threadApps.isError),
     isDebouncing: pathSuggestions.isDebouncing,
-    isUnavailable: !canSearchWorkspace && !canSearchThreadStorage,
+    isUnavailable: !canSearchApps && !canSearchWorkspace && !canSearchThreadStorage,
   };
 }
diff --git a/apps/app/src/lib/api.ts b/apps/app/src/lib/api.ts
index edc0e6a9a..89d2b12c8 100644
--- a/apps/app/src/lib/api.ts
+++ b/apps/app/src/lib/api.ts
@@ -81,6 +81,8 @@ import type {
   ReplayCaptureListResponse,
   ReplayRunRequest,
   ReplayRunResponse,
+  AppDetail,
+  AppSummary,
 } from "@bb/server-contract";
 import { apiClient, toRelativeUrl } from "./api-server";
 import {
@@ -91,6 +93,7 @@ import {
   type FilePreviewTarget,
 } from "./file-preview";
 import {
+  buildThreadAppAssetUrl,
   buildThreadHostFileContentUrl,
   buildThreadStorageContentUrl,
 } from "./file-content-urls";
@@ -894,6 +897,47 @@ export async function getThreadStatusVersion(
   );
 }
 
+export async function listThreadApps(
+  id: string,
+  signal?: AbortSignal,
+): Promise<AppSummary[]> {
+  return request<AppSummary[]>(
+    apiClient.threads[":id"].apps.$get(
+      { param: { id } },
+      requestOptions(signal),
+    ),
+  );
+}
+
+export async function getThreadApp(
+  id: string,
+  appId: string,
+  signal?: AbortSignal,
+): Promise<AppDetail> {
+  return request<AppDetail>(
+    apiClient.threads[":id"].apps[":appId"].$get(
+      { param: { id, appId } },
+      requestOptions(signal),
+    ),
+  );
+}
+
+export async function getThreadAppMarkdownPreview(
+  id: string,
+  appId: string,
+  path: string,
+  signal?: AbortSignal,
+): Promise<FilePreview> {
+  return loadFilePreview(
+    {
+      name: path.split("/").at(-1),
+      path,
+      url: buildThreadAppAssetUrl(id, appId, path),
+    },
+    signal,
+  );
+}
+
 export async function getThreadHostFilePreview(
   id: string,
   path: string,
diff --git a/apps/app/src/lib/file-content-urls.ts b/apps/app/src/lib/file-content-urls.ts
index 92a07ab86..cb01284fd 100644
--- a/apps/app/src/lib/file-content-urls.ts
+++ b/apps/app/src/lib/file-content-urls.ts
@@ -45,6 +45,35 @@ export function buildThreadStatusContentUrl(
     : `${baseUrl}?v=${encodeURIComponent(hash)}`;
 }
 
+export function buildThreadAppEntryUrl(
+  threadId: string,
+  appId: string,
+): string {
+  return `/api/v1/threads/${encodeURIComponent(
+    threadId,
+  )}/apps/${encodeURIComponent(appId)}/`;
+}
+
+export function buildThreadAppAssetUrl(
+  threadId: string,
+  appId: string,
+  path: string,
+): string {
+  return `/api/v1/threads/${encodeURIComponent(
+    threadId,
+  )}/apps/${encodeURIComponent(appId)}/assets/${encodePathSegments(path)}`;
+}
+
+export function buildThreadAppAssetBaseUrl(
+  threadId: string,
+  appId: string,
+  entryPath: string,
+): string {
+  const lastSlash = entryPath.lastIndexOf("/");
+  const basePath = lastSlash === -1 ? "" : entryPath.slice(0, lastSlash + 1);
+  return buildThreadAppAssetUrl(threadId, appId, basePath);
+}
+
 export function buildThreadHostFileContentUrl(
   threadId: string,
   path: string,
diff --git a/apps/app/src/lib/fixed-panel-tabs-state.test.ts b/apps/app/src/lib/fixed-panel-tabs-state.test.ts
index e46fafd08..7368e46d8 100644
--- a/apps/app/src/lib/fixed-panel-tabs-state.test.ts
+++ b/apps/app/src/lib/fixed-panel-tabs-state.test.ts
@@ -4,6 +4,7 @@ import { afterEach, describe, expect, it } from "vitest";
 import {
   EMPTY_FIXED_PANEL_TABS_STATE,
   FIXED_PANEL_TABS_IDLE_EXPIRY_MS,
+  createAppFixedPanelTab,
   createEmptyFixedPanelTabsState,
   createNewTabFixedPanelTab,
   getFixedPanelTabsStateStorageKey,
@@ -25,6 +26,10 @@ function workspaceFileTabId(path: string): string {
   return `workspace-file-preview:${encodeURIComponent(path)}`;
 }
 
+function appTabId(appId: string): string {
+  return `app:${encodeURIComponent(appId)}`;
+}
+
 function terminalTabId(terminalId: string): string {
   return `terminal:${encodeURIComponent(terminalId)}`;
 }
@@ -80,6 +85,25 @@ describe("fixed panel tabs state storage", () => {
     ).toEqual(state);
   });
 
+  it("round-trips app tabs", () => {
+    const appTab = createAppFixedPanelTab({ appId: "status" });
+    const state = makeFixedPanelTabsState({
+      secondary: {
+        tabs: [appTab],
+        activeTabId: appTabId("status"),
+        isOpen: true,
+      },
+    });
+
+    expect(
+      parseFixedPanelTabsState({
+        initialValue: EMPTY_FIXED_PANEL_TABS_STATE,
+        now: NOW,
+        storedValue: serializeFixedPanelTabsState({ state }),
+      }),
+    ).toEqual(state);
+  });
+
   it("falls back for invalid JSON, invalid shapes, and unsupported regions", () => {
     const validState = makeFixedPanelTabsState();
     const invalidStoredValues = [
diff --git a/apps/app/src/lib/fixed-panel-tabs-state.ts b/apps/app/src/lib/fixed-panel-tabs-state.ts
index af0dac2d8..88e9d3e49 100644
--- a/apps/app/src/lib/fixed-panel-tabs-state.ts
+++ b/apps/app/src/lib/fixed-panel-tabs-state.ts
@@ -76,6 +76,13 @@ const threadStorageFilePreviewFixedPanelTabSchema = z
     path: z.string().min(1),
   })
   .strict();
+const appFixedPanelTabSchema = z
+  .object({
+    appId: z.string().min(1),
+    id: z.string().min(1),
+    kind: z.literal("app"),
+  })
+  .strict();
 const newTabFixedPanelTabSchema = z
   .object({
     id: z.literal(NEW_TAB_TAB_ID),
@@ -95,6 +102,7 @@ const secondaryFixedPanelTabSchema = z.discriminatedUnion("kind", [
   workspaceFilePreviewFixedPanelTabSchema,
   hostFilePreviewFixedPanelTabSchema,
   threadStorageFilePreviewFixedPanelTabSchema,
+  appFixedPanelTabSchema,
   newTabFixedPanelTabSchema,
 ]);
 const bottomFixedPanelTabSchema = z.discriminatedUnion("kind", [
@@ -172,6 +180,12 @@ export interface ThreadStorageFilePreviewFixedPanelTab {
   path: string;
 }
 
+export interface AppFixedPanelTab {
+  appId: string;
+  id: string;
+  kind: "app";
+}
+
 export interface NewTabFixedPanelTab {
   id: typeof NEW_TAB_TAB_ID;
   kind: "new-tab";
@@ -189,6 +203,7 @@ export type SecondaryFixedPanelTab =
   | WorkspaceFilePreviewFixedPanelTab
   | HostFilePreviewFixedPanelTab
   | ThreadStorageFilePreviewFixedPanelTab
+  | AppFixedPanelTab
   | NewTabFixedPanelTab;
 
 /**
@@ -200,6 +215,7 @@ export type SecondaryFileFixedPanelTab =
   | WorkspaceFilePreviewFixedPanelTab
   | HostFilePreviewFixedPanelTab
   | ThreadStorageFilePreviewFixedPanelTab
+  | AppFixedPanelTab
   | NewTabFixedPanelTab;
 
 export type BottomFixedPanelTab = TerminalFixedPanelTab;
@@ -270,6 +286,10 @@ interface CreateThreadStorageFilePreviewFixedPanelTabArgs {
   path: string;
 }
 
+interface CreateAppFixedPanelTabArgs {
+  appId: string;
+}
+
 interface CreateWorkspaceFilePreviewFixedPanelTabArgs {
   environmentId: string | null;
   tab: WorkspaceFileTabState;
@@ -346,6 +366,16 @@ export function createThreadStorageFilePreviewFixedPanelTab({
   };
 }
 
+export function createAppFixedPanelTab({
+  appId,
+}: CreateAppFixedPanelTabArgs): AppFixedPanelTab {
+  return {
+    appId,
+    id: `app:${encodeURIComponent(appId)}`,
+    kind: "app",
+  };
+}
+
 export function createNewTabFixedPanelTab(): NewTabFixedPanelTab {
   return {
     id: NEW_TAB_TAB_ID,
@@ -616,6 +646,8 @@ export function areFixedPanelTabsEquivalent(
         a.lineNumber === b.lineNumber &&
         a.path === b.path
       );
+    case "app":
+      return b.kind === "app" && a.appId === b.appId;
     case "thread-storage-file-preview":
       return (
         b.kind === "thread-storage-file-preview" &&
diff --git a/apps/app/src/lib/markdown-url-transform.ts b/apps/app/src/lib/markdown-url-transform.ts
new file mode 100644
index 000000000..5ca43e8c1
--- /dev/null
+++ b/apps/app/src/lib/markdown-url-transform.ts
@@ -0,0 +1,27 @@
+import { defaultUrlTransform, type UrlTransform } from "react-markdown";
+
+const RELATIVE_ASSET_URL_PATTERN =
+  /^(?![a-z][a-z\d+.-]*:|\/\/|\/|#|\?)/iu;
+
+function isRelativeAssetUrl(url: string): boolean {
+  return url.length > 0 && RELATIVE_ASSET_URL_PATTERN.test(url);
+}
+
+function resolveAssetUrl(assetBaseUrl: string, url: string): string {
+  const baseUrl = new URL(assetBaseUrl, window.location.origin);
+  const assetUrl = new URL(url, baseUrl);
+  return `${assetUrl.pathname}${assetUrl.search}${assetUrl.hash}`;
+}
+
+export function createAssetMarkdownUrlTransform(
+  assetBaseUrl: string,
+): UrlTransform {
+  return (url) => {
+    const transformedUrl = defaultUrlTransform(url);
+    if (!isRelativeAssetUrl(transformedUrl)) {
+      return transformedUrl;
+    }
+
+    return resolveAssetUrl(assetBaseUrl, transformedUrl);
+  };
+}
diff --git a/apps/app/src/views/thread-detail/ThreadDetailView.tsx b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
index af3c24409..323dcc1db 100644
--- a/apps/app/src/views/thread-detail/ThreadDetailView.tsx
+++ b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
@@ -32,6 +32,7 @@ import {
   getLatestPendingInteraction,
   useProjectThreadSubset,
   useThread,
+  useThreadApps,
   useThreadComposerBootstrap,
   useThreadDetailBootstrap,
   useThreadPendingInteractions,
@@ -79,9 +80,14 @@ import {
   ThreadStorageFilePreviewTabContent,
   WorkspaceFilePreviewTabContent,
 } from "@/components/secondary-panel/ThreadSecondaryPanelTabContent";
+import { AppTabContent } from "@/components/secondary-panel/AppTabContent";
 import { NewTabPage } from "@/components/secondary-panel/NewTabPage";
+import { ResolvedAppIcon } from "@/components/secondary-panel/AppIcon";
 import { useManagerStorageBrowser } from "@/components/secondary-panel/useManagerStorageBrowser";
-import { useThreadFileTabs } from "@/components/secondary-panel/useThreadFileTabs";
+import {
+  STATUS_APP_ID,
+  useThreadFileTabs,
+} from "@/components/secondary-panel/useThreadFileTabs";
 import type { SecondaryPanelFileTab } from "@/components/secondary-panel/ThreadSecondaryPanel";
 import { useEnvironmentMergeBase } from "@/components/secondary-panel/git-diff/useEnvironmentMergeBase";
 import { useThreadGitActions } from "./useThreadGitActions";
@@ -266,11 +272,16 @@ export function ThreadDetailView() {
     threadId,
     threadType: thread?.type,
   });
+  const threadAppsQuery = useThreadApps(threadId ?? "", {
+    enabled: Boolean(threadId) && thread !== undefined,
+  });
   const {
+    activateAppTab,
     activateNewTab,
     activateHostFileTab,
     activateStorageFileTab,
     activateWorkspaceFileTab,
+    activeAppId,
     activeHostFileLineNumber,
     activeHostFilePath,
     activeStorageFilePath,
@@ -279,6 +290,7 @@ export function ThreadDetailView() {
     activeWorkspaceFileSource,
     activeWorkspaceFileStatusLabel,
     clearActiveFileTabs,
+    closeAppTab,
     closeHostFileTab,
     closeNewTab,
     closeStorageFileTab,
@@ -292,6 +304,7 @@ export function ThreadDetailView() {
     pinnedStorageFilePath,
     selectFileSearchResult,
   } = useThreadFileTabs({
+    apps: threadAppsQuery.data,
     threadId,
     environmentId: thread?.environmentId,
     threadType: thread?.type,
@@ -500,10 +513,32 @@ export function ThreadDetailView() {
     },
     [openSecondaryPanelDiffFile, openWorkspaceFile],
   );
+  const threadAppsById = useMemo(() => {
+    const entries = new Map(
+      (threadAppsQuery.data ?? []).map((app) => [app.id, app]),
+    );
+    return entries;
+  }, [threadAppsQuery.data]);
   const fileTabs = useMemo<SecondaryPanelFileTab[] | undefined>(() => {
     const filenameOf = (path: string) => path.split("/").at(-1) ?? path;
     const tabs = orderedSecondaryFileTabs.map((tab): SecondaryPanelFileTab => {
       switch (tab.kind) {
+        case "app": {
+          const app = threadAppsById.get(tab.appId);
+          const appName = app?.name ?? tab.appId;
+          return {
+            id: tab.id,
+            filename: appName,
+            isActive: tab.appId === activeAppId,
+            isPinned: tab.appId === STATUS_APP_ID,
+            leadingVisual: app ? (
+              <ResolvedAppIcon icon={app.icon} className="size-3.5" />
+            ) : undefined,
+            statusLabel: null,
+            onSelect: () => activateAppTab(tab.appId),
+            onClose: () => closeAppTab(tab.appId),
+          };
+        }
         case "workspace-file-preview":
           return {
             id: tab.id,
@@ -545,19 +580,23 @@ export function ThreadDetailView() {
     });
     return tabs.length > 0 ? tabs : undefined;
   }, [
+    activateAppTab,
     activateNewTab,
     activateHostFileTab,
     activateStorageFileTab,
     activateWorkspaceFileTab,
+    activeAppId,
     activeHostFilePath,
     activeStorageFilePath,
     activeWorkspaceFilePath,
+    closeAppTab,
     closeHostFileTab,
     closeNewTab,
     closeStorageFileTab,
     closeWorkspaceFileTab,
     isNewTabActive,
     orderedSecondaryFileTabs,
+    threadAppsById,
   ]);
   const requestedMergeBaseBranch =
     selectedMergeBaseBranch ?? environmentMergeBaseBranch;
@@ -1085,6 +1124,8 @@ export function ThreadDetailView() {
       focusRequest={newTabFocusRequest}
       onSelect={selectFileSearchResult}
     />
+  ) : activeAppId ? (
+    <AppTabContent appId={activeAppId} threadId={thread.id} />
   ) : activeWorkspaceFilePath ? (
     <WorkspaceFilePreviewTabContent
       activePath={activeWorkspaceFilePath}
diff --git a/apps/app/src/views/thread-detail/threadSecondaryPanelSelection.ts b/apps/app/src/views/thread-detail/threadSecondaryPanelSelection.ts
index c204bca47..ab3ecedef 100644
--- a/apps/app/src/views/thread-detail/threadSecondaryPanelSelection.ts
+++ b/apps/app/src/views/thread-detail/threadSecondaryPanelSelection.ts
@@ -56,6 +56,7 @@ function getSecondaryPanelForFixedTab(
     case "workspace-file-preview":
     case "host-file-preview":
     case "thread-storage-file-preview":
+    case "app":
     case "new-tab":
       return "thread-info";
     case "terminal":
diff --git a/apps/server/src/services/threads/app-client-script.ts b/apps/server/src/services/threads/app-client-script.ts
index 5bcf56cc7..262e3708d 100644
--- a/apps/server/src/services/threads/app-client-script.ts
+++ b/apps/server/src/services/threads/app-client-script.ts
@@ -238,14 +238,17 @@ function buildAppClientJavascript(bootstrapJson: string): string {
   var reconnectDelay = 1000;
   var listeners = [];
   var socketHasOpened = false;
+  var socketSubscribed = false;
   var subscriptionReady = null;
   var resolveSubscriptionReady = null;
+  var subscriptionEntityId = bootstrap.threadId + ":app:" + bootstrap.appId + ":data";
 
   function pathMatchesPrefix(path, prefix) {
     return prefix === "" || path === prefix || path.indexOf(prefix + "/") === 0;
   }
 
   function callListener(listener, event) {
+    if (!listener.active) return;
     if (!pathMatchesPrefix(event.path, listener.prefix)) return;
     try {
       listener.callback({
@@ -259,6 +262,7 @@ function buildAppClientJavascript(bootstrapJson: string): string {
   }
 
   function deliverOrBufferListener(listener, event) {
+    if (!listener.active) return;
     if (!pathMatchesPrefix(event.path, listener.prefix)) return;
     if (listener.replaying) {
       listener.bufferedEvents.push(event);
@@ -295,12 +299,45 @@ function buildAppClientJavascript(bootstrapJson: string): string {
     });
   }
 
+  function sendSubscriptionMessage(type) {
+    if (!socket || socket.readyState !== WebSocket.OPEN) return;
+    socket.send(JSON.stringify({
+      type: type,
+      entity: "thread",
+      id: subscriptionEntityId
+    }));
+  }
+
   function resetSubscriptionReady() {
     subscriptionReady = new Promise(function (resolve) {
       resolveSubscriptionReady = resolve;
     });
   }
 
+  function closeSocketIfIdle() {
+    if (listeners.length > 0) return;
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (!socket) return;
+    if (resolveSubscriptionReady) {
+      resolveSubscriptionReady();
+      resolveSubscriptionReady = null;
+    }
+    if (socket.readyState === WebSocket.OPEN && socketSubscribed) {
+      sendSubscriptionMessage("unsubscribe");
+      socketSubscribed = false;
+    }
+    if (
+      socket.readyState === WebSocket.OPEN ||
+      socket.readyState === WebSocket.CONNECTING
+    ) {
+      socketHasOpened = false;
+      socket.close();
+    }
+  }
+
   function connectSocket() {
     if (!subscriptionReady) resetSubscriptionReady();
     if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return subscriptionReady;
@@ -309,15 +346,15 @@ function buildAppClientJavascript(bootstrapJson: string): string {
       var reconnected = socketHasOpened;
       socketHasOpened = true;
       reconnectDelay = 1000;
-      socket.send(JSON.stringify({
-        type: "subscribe",
-        entity: "thread",
-        id: bootstrap.threadId + ":app:" + bootstrap.appId + ":data"
-      }));
+      if (listeners.length > 0) {
+        sendSubscriptionMessage("subscribe");
+        socketSubscribed = true;
+      }
       if (resolveSubscriptionReady) {
         resolveSubscriptionReady();
         resolveSubscriptionReady = null;
       }
+      closeSocketIfIdle();
       if (reconnected) {
         listeners.slice().forEach(function (listener) {
           replayExisting(listener);
@@ -333,7 +370,9 @@ function buildAppClientJavascript(bootstrapJson: string): string {
       }
     };
     socket.onclose = function () {
+      socketSubscribed = false;
       resetSubscriptionReady();
+      if (listeners.length === 0) return;
       if (reconnectTimer) return;
       reconnectTimer = setTimeout(function () {
         reconnectTimer = null;
@@ -348,12 +387,16 @@ function buildAppClientJavascript(bootstrapJson: string): string {
   }
 
   function replayExisting(listener) {
+    if (!listener.active) return Promise.resolve();
     listener.replayPromise = (listener.replayPromise || Promise.resolve()).then(function () {
+      if (!listener.active) return;
       listener.replaying = true;
       listener.bufferedEvents = [];
       return connectSocket().then(function () {
+        if (!listener.active) return null;
         return listEntries(listener.prefix);
       }).then(function (entries) {
+        if (!listener.active || !entries) return;
         var replayedVersions = Object.create(null);
         entries.forEach(function (entry) {
           replayedVersions[entry.path] = entry.version;
@@ -372,6 +415,7 @@ function buildAppClientJavascript(bootstrapJson: string): string {
         listener.bufferedEvents = [];
       });
     }).catch(function (error) {
+      if (!listener.active) return;
       console.error("window.bb.data.onChange replay failed", error);
     });
     return listener.replayPromise;
@@ -386,6 +430,7 @@ function buildAppClientJavascript(bootstrapJson: string): string {
     var listener = {
       prefix: effectivePrefix,
       callback: callback,
+      active: true,
       replaying: false,
       bufferedEvents: [],
       replayPromise: null
@@ -393,9 +438,13 @@ function buildAppClientJavascript(bootstrapJson: string): string {
     listeners.push(listener);
     replayExisting(listener);
     return function () {
+      if (!listener.active) return;
+      listener.active = false;
+      listener.bufferedEvents = [];
       listeners = listeners.filter(function (candidate) {
         return candidate !== listener;
       });
+      closeSocketIfIdle();
     };
   }
 
diff --git a/apps/server/test/services/threads/app-client-script.test.ts b/apps/server/test/services/threads/app-client-script.test.ts
index e1e0f9af7..c2ad6b769 100644
--- a/apps/server/test/services/threads/app-client-script.test.ts
+++ b/apps/server/test/services/threads/app-client-script.test.ts
@@ -28,6 +28,11 @@ interface ExecuteScriptArgs {
   windowObject: ScriptWindow;
 }
 
+interface DeferredResponse {
+  promise: Promise<Response>;
+  resolve(response: Response): void;
+}
+
 const bootstrap: AppClientBootstrap = {
   appId: "status",
   capabilities: ["data", "message"],
@@ -104,6 +109,17 @@ function requireBb(windowObject: ScriptWindow): Bb {
   return windowObject.bb;
 }
 
+function createDeferredResponse(): DeferredResponse {
+  let resolvePromise: DeferredResponse["resolve"] = () => {};
+  const promise = new Promise<Response>((resolve) => {
+    resolvePromise = resolve;
+  });
+  return {
+    promise,
+    resolve: resolvePromise,
+  };
+}
+
 async function flushPromises(): Promise<void> {
   await Promise.resolve();
   await Promise.resolve();
@@ -139,6 +155,55 @@ describe("app client script", () => {
     );
   });
 
+  it("does not deliver initial replay entries after onChange unsubscribe", async () => {
+    const deferred = createDeferredResponse();
+    const fetchMock = vi.fn(async () => deferred.promise);
+    const windowObject: ScriptWindow = {};
+    executeScript({ fetchMock, windowObject });
+
+    const bb = requireBb(windowObject);
+    const callback = vi.fn();
+    const unsubscribe = bb.data?.onChange("", callback);
+    await Promise.resolve();
+    const socket = FakeWebSocket.instances[0];
+    if (!socket) {
+      throw new Error("Expected websocket");
+    }
+    socket.open();
+    await flushPromises();
+
+    unsubscribe?.();
+    deferred.resolve(
+      listResponse({
+        entries: [
+          {
+            path: "state.json",
+            value: { count: 1 },
+            version: "v1",
+            sizeBytes: 1,
+            modifiedAtMs: 1,
+          },
+        ],
+      }),
+    );
+    await flushPromises();
+
+    expect(callback).not.toHaveBeenCalled();
+    expect(socket.readyState).toBe(FakeWebSocket.CLOSED);
+    expect(socket.messages.map((message) => JSON.parse(message))).toEqual([
+      {
+        type: "subscribe",
+        entity: "thread",
+        id: "thr_123:app:status:data",
+      },
+      {
+        type: "unsubscribe",
+        entity: "thread",
+        id: "thr_123:app:status:data",
+      },
+    ]);
+  });
+
   it("replays existing data when a resync hint arrives", async () => {
     const fetchMock = vi
       .fn()

From 937bfc2819554edc5da019e8f0b741afe5711d69 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 18:24:52 -0700
Subject: [PATCH 03/13] apps system phase 3: prompt/guide cutover + STATUS
 removal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Removes the legacy STATUS system end to end (no backwards compat) and makes
the Apps system the only path:
- Delete STATUS server routes/injection/status-data/status-version, the WS hub
  status method, the daemon status commands (HOST_DAEMON_PROTOCOL_VERSION→26),
  the frontend manager-status surface + useThreadStatusVersion, and all
  STATUS-specific tests.
- Rewrite manager/thread system prompts + instructions to the apps model
  (apps/status, data/state.json, window.bb, bb app CLI).
- bb-guide-status-state → bb-guide-app (bb guide app); fold bb guide styling
  into it; regenerate templates. New managers seed only the `status` app.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |    2 +-
 .../secondary-panel/FilePreview.stories.tsx   |   12 -
 .../secondary-panel/FilePreview.tsx           |   16 +-
 .../ManagerThreadStorageBrowser.stories.tsx   |    7 +-
 .../ThreadSecondaryPanel.stories.tsx          |    6 +-
 .../ThreadSecondaryPanel.test.tsx             |   16 +-
 .../ThreadSecondaryPanelTabContent.tsx        |   11 +-
 .../ThreadStorageFilePreview.test.tsx         |  234 +---
 .../ThreadStorageFilePreview.tsx              |  179 +--
 .../secondary-panel/managerStorage.ts         |   13 -
 .../useThreadFileTabs.test.tsx                |  302 ++---
 .../secondary-panel/useThreadFileTabs.ts      |  135 +--
 .../src/hooks/environment-cache-effects.ts    |    4 -
 apps/app/src/hooks/mutation-cache-effects.ts  |    4 -
 apps/app/src/hooks/queries/query-keys.ts      |   28 +-
 .../src/hooks/queries/thread-queries.test.tsx |   99 +-
 apps/app/src/hooks/queries/thread-queries.ts  |   46 +-
 .../src/hooks/realtime-cache-effects.test.ts  |   52 +-
 apps/app/src/hooks/realtime-cache-registry.ts |    2 -
 apps/app/src/lib/api.ts                       |   13 -
 apps/app/src/lib/file-content-urls.ts         |   10 -
 apps/app/src/lib/manager-status-storage.ts    |   31 -
 .../views/thread-detail/ThreadDetailView.tsx  |    9 +-
 ...threadLocalFileHtmlPreviewRouting.test.tsx |    5 -
 apps/cli/src/__tests__/command-output.test.ts |   23 +-
 apps/cli/src/commands/guide.ts                |    4 +-
 apps/host-daemon/src/app.ts                   |   45 +-
 apps/host-daemon/src/command-dispatch.ts      |   39 -
 .../src/command-handlers/host-files.test.ts   |  255 +----
 .../src/command-handlers/host-files.ts        |    3 -
 .../manager-templates.test.ts                 |   18 +-
 .../src/command-handlers/status-data.test.ts  |  419 -------
 .../src/command-handlers/status-data.ts       |  555 ---------
 .../src/command-handlers/status-version.ts    |  491 --------
 apps/host-daemon/src/command-router.ts        |   50 -
 apps/host-daemon/src/runtime-manager.test.ts  |   14 +-
 apps/host-daemon/src/runtime-manager.ts       |   22 -
 apps/host-daemon/src/server-client.test.ts    |   46 -
 apps/host-daemon/src/server-client.ts         |   24 -
 .../src/status-data-change-reporter.test.ts   |  792 -------------
 .../src/status-data-change-reporter.ts        |  437 -------
 .../src/status-data-reporter-cache.ts         |  148 ---
 .../src/status-data-snapshot-diff.ts          |  136 ---
 .../test/command/command-router.test.ts       |   24 +-
 .../src/internal/command-result-owners.ts     |    5 -
 .../src/internal/status-data-changes.ts       |   69 --
 apps/server/src/routes/threads/data.ts        |  345 +-----
 apps/server/src/routes/threads/index.ts       |    2 -
 apps/server/src/routes/threads/status-data.ts |  300 -----
 apps/server/src/server.ts                     |    6 +-
 .../threads/default-template/STATUS.html      |  380 ------
 .../threads/manager-storage-templates.ts      |    9 +-
 .../src/services/threads/status-data-files.ts |   43 -
 .../threads/status-state-client-script.ts     |  533 ---------
 apps/server/src/ws/hub.ts                     |    9 -
 apps/server/test/app/hub.test.ts              |   33 -
 .../internal-status-data-change.test.ts       |  131 ---
 .../test/public/public-thread-data.test.ts    | 1020 +----------------
 ...blic-threads.manager-and-ownership.test.ts |   21 +-
 .../status-state-client-script.test.ts        |  743 ------------
 .../threads/manager-storage-templates.test.ts |   33 +-
 packages/domain/src/index.ts                  |    3 -
 packages/domain/src/status-data.ts            |    4 -
 packages/host-daemon-contract/src/commands.ts |  211 +---
 packages/host-daemon-contract/src/index.ts    |   19 -
 packages/host-daemon-contract/src/session.ts  |   74 --
 .../test/contract.test.ts                     |  320 +-----
 .../host-watcher/src/host-watcher-types.ts    |   13 +-
 packages/host-watcher/src/index.ts            |    6 -
 .../host-watcher/src/parcel-host-watcher.ts   |   49 +-
 .../host-watcher/src/status-data-paths.ts     |   19 -
 .../test/thread-storage-watch.test.ts         |   73 +-
 packages/server-contract/src/api-types.ts     |  155 +--
 packages/server-contract/src/index.ts         |   27 -
 packages/server-contract/src/public-api.ts    |   21 +-
 .../server-contract/test/contract.test.ts     |   36 -
 .../src/generated/templates.generated.ts      |   44 +-
 .../templates/src/templates/bb-guide-app.md   |  208 ++++
 .../templates/bb-guide-manager-templates.md   |   64 +-
 .../src/templates/bb-guide-overview.md        |    4 +-
 .../src/templates/bb-guide-status-state.md    |  195 ----
 .../src/templates/bb-guide-styling.md         |  286 -----
 .../templates/manager-agent-instructions.md   |    6 +-
 .../system-message-manager-welcome.md         |   20 +-
 packages/templates/test/templates.test.ts     |   41 +-
 .../fake/smoke/status-data-watch.test.ts      |  354 ------
 86 files changed, 600 insertions(+), 10115 deletions(-)
 delete mode 100644 apps/app/src/components/secondary-panel/managerStorage.ts
 delete mode 100644 apps/app/src/lib/manager-status-storage.ts
 delete mode 100644 apps/host-daemon/src/command-handlers/status-data.test.ts
 delete mode 100644 apps/host-daemon/src/command-handlers/status-data.ts
 delete mode 100644 apps/host-daemon/src/command-handlers/status-version.ts
 delete mode 100644 apps/host-daemon/src/status-data-change-reporter.test.ts
 delete mode 100644 apps/host-daemon/src/status-data-change-reporter.ts
 delete mode 100644 apps/host-daemon/src/status-data-reporter-cache.ts
 delete mode 100644 apps/host-daemon/src/status-data-snapshot-diff.ts
 delete mode 100644 apps/server/src/internal/status-data-changes.ts
 delete mode 100644 apps/server/src/routes/threads/status-data.ts
 delete mode 100644 apps/server/src/services/threads/default-template/STATUS.html
 delete mode 100644 apps/server/src/services/threads/status-data-files.ts
 delete mode 100644 apps/server/src/services/threads/status-state-client-script.ts
 delete mode 100644 apps/server/test/internal/internal-status-data-change.test.ts
 delete mode 100644 apps/server/test/services/threads/status-state-client-script.test.ts
 delete mode 100644 packages/domain/src/status-data.ts
 delete mode 100644 packages/host-watcher/src/status-data-paths.ts
 create mode 100644 packages/templates/src/templates/bb-guide-app.md
 delete mode 100644 packages/templates/src/templates/bb-guide-status-state.md
 delete mode 100644 packages/templates/src/templates/bb-guide-styling.md
 delete mode 100644 tests/integration/fake/smoke/status-data-watch.test.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0bc2632ea..955644ca6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,3 @@
 # Changelog
 
-- Removed `bb status-state`; write reactive STATUS JSON directly under `$BB_THREAD_STORAGE/STATUS-data/`.
+- Removed the legacy STATUS system; use the built-in `status` app and `apps/status/data/state.json` for manager status.
diff --git a/apps/app/src/components/secondary-panel/FilePreview.stories.tsx b/apps/app/src/components/secondary-panel/FilePreview.stories.tsx
index 13bbfd73a..f54d62e2d 100644
--- a/apps/app/src/components/secondary-panel/FilePreview.stories.tsx
+++ b/apps/app/src/components/secondary-panel/FilePreview.stories.tsx
@@ -92,7 +92,6 @@ Button.displayName = "Button";
 const README_PATH = "docs/secondary-panel/README.md";
 const BUTTON_PATH = "apps/app/src/components/ui/button.tsx";
 const DELETED_BUTTON_PATH = "apps/app/src/components/ui/legacy-button.tsx";
-const STATUS_PATH = "agents/manager-42/STATUS.md";
 const SCREENSHOT_PATH = "docs/screenshots/secondary-panel.svg";
 
 const SAMPLE_IMAGE_URL =
@@ -217,17 +216,6 @@ export function Overview() {
           />
         </PreviewStage>
       </StoryRow>
-      <StoryRow
-        label="manager status pending"
-        hint="STATUS.md doesn't exist yet for a freshly-created manager"
-      >
-        <PreviewStage>
-          <FilePreview
-            path={STATUS_PATH}
-            state={{ kind: "manager-status-pending" }}
-          />
-        </PreviewStage>
-      </StoryRow>
       <StoryRow
         label="failed to load"
         hint="Preview fetch failed for some other reason (network, 500, etc.)"
diff --git a/apps/app/src/components/secondary-panel/FilePreview.tsx b/apps/app/src/components/secondary-panel/FilePreview.tsx
index da523db46..b65f2b957 100644
--- a/apps/app/src/components/secondary-panel/FilePreview.tsx
+++ b/apps/app/src/components/secondary-panel/FilePreview.tsx
@@ -35,7 +35,6 @@ export type FilePreviewState =
   | { kind: "loading" }
   | { kind: "empty" }
   | { kind: "not-found" }
-  | { kind: "manager-status-pending" }
   | { kind: "error"; message?: string }
   | { kind: "image"; url: string }
   | ({ kind: "iframe" } & IframeFilePreviewTarget)
@@ -222,11 +221,6 @@ function FilePreviewBody({ state, path, viewMode }: FilePreviewBodyProps) {
   if (state.kind === "not-found") {
     return <FilePreviewMessage message="File not found." role="alert" />;
   }
-  if (state.kind === "manager-status-pending") {
-    return (
-      <FilePreviewMessage message="Manager hasn't written a status yet." />
-    );
-  }
   if (state.kind === "error") {
     return (
       <FilePreviewMessage
@@ -460,10 +454,7 @@ function FilePreviewLoading() {
   );
 }
 
-function FilePreviewMessage({
-  message,
-  role,
-}: FilePreviewMessageProps) {
+function FilePreviewMessage({ message, role }: FilePreviewMessageProps) {
   return (
     <p
       role={role}
@@ -474,10 +465,7 @@ function FilePreviewMessage({
   );
 }
 
-function FilePreviewCode({
-  file,
-  lineNumber,
-}: FilePreviewCodeProps) {
+function FilePreviewCode({ file, lineNumber }: FilePreviewCodeProps) {
   const preferredTheme = usePreferredTheme();
   const containerRef = useRef<HTMLDivElement>(null);
   const options = useMemo(
diff --git a/apps/app/src/components/secondary-panel/ManagerThreadStorageBrowser.stories.tsx b/apps/app/src/components/secondary-panel/ManagerThreadStorageBrowser.stories.tsx
index f78dcad00..dc1fe0d6a 100644
--- a/apps/app/src/components/secondary-panel/ManagerThreadStorageBrowser.stories.tsx
+++ b/apps/app/src/components/secondary-panel/ManagerThreadStorageBrowser.stories.tsx
@@ -14,9 +14,7 @@ export default {
 function PanelStage({ children }: { children: ReactNode }) {
   return (
     <div className="flex h-[360px] w-full max-w-[460px] min-w-0 flex-col overflow-hidden rounded-md border border-border bg-background px-4 py-3">
-      <DetailCard
-        className="h-full min-h-0 flex-1 rounded-none border-0 bg-transparent px-0 py-0"
-      >
+      <DetailCard className="h-full min-h-0 flex-1 rounded-none border-0 bg-transparent px-0 py-0">
         {children}
       </DetailCard>
     </div>
@@ -30,7 +28,8 @@ function makeFile(path: string): WorkspaceFile {
 
 const FILES: WorkspaceFile[] = [
   makeFile("ASYNC.md"),
-  makeFile("STATUS.md"),
+  makeFile("apps/status/manifest.json"),
+  makeFile("apps/status/data/state.json"),
   makeFile("PREFERENCES.md"),
 ];
 
diff --git a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.stories.tsx b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.stories.tsx
index 372e55be1..715c0c955 100644
--- a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.stories.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.stories.tsx
@@ -208,9 +208,9 @@ export function Overview() {
         hint="leftmost tab is pinned (no close X); other tabs render the close affordance as usual"
       >
         <FileTabsShellRow
-          filenames={["STATUS.md", "useGitDiffPanelState.ts"]}
-          pinnedFilename="STATUS.md"
-          initialActiveFilename="STATUS.md"
+          filenames={["Status", "useGitDiffPanelState.ts"]}
+          pinnedFilename="Status"
+          initialActiveFilename="Status"
         />
       </StoryRow>
       <StoryRow
diff --git a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.test.tsx b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.test.tsx
index 136e05c8c..58edd6bbe 100644
--- a/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.test.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadSecondaryPanel.test.tsx
@@ -162,13 +162,13 @@ afterEach(() => {
 describe("ThreadSecondaryPanel", () => {
   it.each<SecondaryPanelChromeDragScenario>([
     {
-      name: "STATUS iframe",
+      name: "status app iframe",
       activeTab: buildActiveFileTab({
-        id: "storage:STATUS",
-        filename: "STATUS",
+        id: "app:status",
+        filename: "Status",
         isPinned: true,
       }),
-      iframeTitle: "Manager status",
+      iframeTitle: "Status app",
       closeButtonLabel: null,
     },
     {
@@ -249,8 +249,8 @@ describe("ThreadSecondaryPanel", () => {
     "keeps iframe previews interactable after secondary panel resize ends via $name",
     async ({ finishDrag }) => {
       const activeStatusTab: SecondaryPanelFileTab = {
-        id: "storage:STATUS",
-        filename: "STATUS",
+        id: "app:status",
+        filename: "Status",
         isActive: true,
         isPinned: true,
         statusLabel: null,
@@ -260,7 +260,7 @@ describe("ThreadSecondaryPanel", () => {
 
       renderPanel({
         fileTabs: [activeStatusTab],
-        fileTabContent: <iframe title="Manager status" />,
+        fileTabContent: <iframe title="Status app" />,
         renderAsDrawer: false,
       });
 
@@ -268,7 +268,7 @@ describe("ThreadSecondaryPanel", () => {
         "#thread-detail-secondary-panel",
       );
       const aside = panel?.querySelector("aside");
-      const iframe = screen.getByTitle("Manager status");
+      const iframe = screen.getByTitle("Status app");
       const resizeHandle = screen.getByLabelText(
         "Resize thread and secondary panels",
       );
diff --git a/apps/app/src/components/secondary-panel/ThreadSecondaryPanelTabContent.tsx b/apps/app/src/components/secondary-panel/ThreadSecondaryPanelTabContent.tsx
index a6b75bb5e..d4a7a274e 100644
--- a/apps/app/src/components/secondary-panel/ThreadSecondaryPanelTabContent.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadSecondaryPanelTabContent.tsx
@@ -26,7 +26,6 @@ import {
   SecondaryPanelFilePreview,
   ThreadStorageFilePreview,
 } from "./ThreadStorageFilePreview";
-import { isManagerStatusStorageFilePath } from "./managerStorage";
 
 const GIT_DIFF_SKELETON_FILE_COUNT = 3;
 const PANEL_SCROLL_SLOT_CLASS =
@@ -100,9 +99,7 @@ export interface HostFilePreviewTabContentProps {
 export interface ThreadStorageFilePreviewTabContentProps {
   activePath: string;
   copyPath?: string | null;
-  isManagerThread: boolean;
   onOpenInEditor?: (path: string) => void;
-  pinnedPath: string;
   threadId: string;
 }
 
@@ -362,19 +359,14 @@ export function HostFilePreviewTabContent({
 export function ThreadStorageFilePreviewTabContent({
   activePath,
   copyPath = null,
-  isManagerThread,
   onOpenInEditor,
-  pinnedPath,
   threadId,
 }: ThreadStorageFilePreviewTabContentProps) {
-  const isManagerStatusTab = isManagerStatusStorageFilePath(activePath);
   const {
     data: threadStorageFilePreview,
     error: threadStorageFilePreviewError,
     isLoading: isThreadStorageFilePreviewLoading,
-  } = useThreadStorageFilePreview(threadId, activePath, {
-    enabled: isManagerThread && !isManagerStatusTab,
-  });
+  } = useThreadStorageFilePreview(threadId, activePath);
 
   return (
     <ThreadStorageFilePreview
@@ -384,7 +376,6 @@ export function ThreadStorageFilePreviewTabContent({
       filePreview={threadStorageFilePreview}
       isLoading={isThreadStorageFilePreviewLoading}
       onOpenInEditor={onOpenInEditor}
-      pinnedPath={pinnedPath}
       threadId={threadId}
     />
   );
diff --git a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.test.tsx b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.test.tsx
index 33309a1c8..1aea540dc 100644
--- a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.test.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.test.tsx
@@ -1,22 +1,8 @@
 // @vitest-environment jsdom
 
-import {
-  cleanup,
-  fireEvent,
-  render,
-  screen,
-  waitFor,
-} from "@testing-library/react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { FilePreview } from "@/lib/file-preview";
-import { createQueryClientTestHarness } from "@/test/queryClientTestHarness";
-import { installFetchRoutes, jsonResponse } from "@/test/http-test-utils";
-import {
-  MANAGER_STATUS_FILE_PATH,
-  MANAGER_STATUS_HTML_FILE_PATH,
-  MANAGER_STATUS_INDEX_FILE_PATH,
-  MANAGER_STATUS_MARKDOWN_FILE_PATH,
-} from "./managerStorage";
 import {
   SecondaryPanelFilePreview,
   ThreadStorageFilePreview,
@@ -134,236 +120,26 @@ describe("ThreadStorageFilePreview", () => {
     expect(screen.queryByText("Empty file.")).toBeNull();
   });
 
-  it("renders raw STATUS html and folder sources in an unsandboxed iframe", async () => {
-    let resolveVersion = (response: Response) => response;
-    const versionResponse = new Promise<Response>((resolve) => {
-      resolveVersion = (response: Response) => {
-        resolve(response);
-        return response;
-      };
-    });
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thr_manager/status-version",
-        handler: () => versionResponse,
-      },
-    ]);
-    const { wrapper } = createQueryClientTestHarness();
-    const { container } = render(
-      <ThreadStorageFilePreview
-        activePath={MANAGER_STATUS_FILE_PATH}
-        copyPath="/Users/me/.bb/thread-storage/thr_manager/STATUS"
-        filePreview={undefined}
-        isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
-        threadId="thr_manager"
-      />,
-      { wrapper },
-    );
-
-    expect(container.querySelector("iframe")).toBeNull();
-    expect(screen.queryByText(MANAGER_STATUS_FILE_PATH)).toBeNull();
-    expect(
-      screen.queryByRole("button", { name: "Copy file path" }),
-    ).toBeNull();
-
-    resolveVersion(jsonResponse({ source: "html", hash: "status-hash-1" }));
-
-    await vi.waitFor(() => {
-      const iframe = container.querySelector("iframe");
-      expect(iframe).not.toBeNull();
-      expect(iframe?.getAttribute("src")).toBe(
-        "/api/v1/threads/thr_manager/status/?v=status-hash-1",
-      );
-      expect(iframe?.hasAttribute("sandbox")).toBe(false);
-      expect(iframe?.style.width).toBe("100%");
-      expect(iframe?.style.height).toBe("100%");
-      expect(iframe?.style.border).toBe("0px");
-    });
-    expect(screen.queryByText(MANAGER_STATUS_FILE_PATH)).toBeNull();
-    expect(
-      screen.queryByRole("button", { name: "Copy file path" }),
-    ).toBeNull();
-  });
-
-  it("updates the STATUS iframe src when the polled hash changes", async () => {
-    let requestCount = 0;
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thr_manager/status-version",
-        handler: () => {
-          requestCount += 1;
-          return jsonResponse({
-            source: "folder",
-            hash: requestCount === 1 ? "status-hash-1" : "status-hash-2",
-          });
-        },
-      },
-    ]);
-    const { wrapper } = createQueryClientTestHarness();
-    const { container } = render(
-      <ThreadStorageFilePreview
-        activePath={MANAGER_STATUS_FILE_PATH}
-        filePreview={undefined}
-        isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
-        threadId="thr_manager"
-      />,
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(container.querySelector("iframe")?.getAttribute("src")).toBe(
-        "/api/v1/threads/thr_manager/status/?v=status-hash-1",
-      );
-    });
-
-    await waitFor(
-      () => {
-        expect(container.querySelector("iframe")?.getAttribute("src")).toBe(
-          "/api/v1/threads/thr_manager/status/?v=status-hash-2",
-        );
-      },
-      { timeout: 2_500 },
-    );
-  }, 8_000);
-
   it("renders generic storage HTML files through a sandboxed raw iframe", () => {
-    const { wrapper } = createQueryClientTestHarness();
     const { container } = render(
       <ThreadStorageFilePreview
-        activePath="reports/status.html"
+        activePath="reports/preview.html"
         filePreview={makeTextPreview({
           content: "<script>window.preview = true</script>",
-          path: "reports/status.html",
+          path: "reports/preview.html",
         })}
         isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
         threadId="thr_manager"
       />,
-      { wrapper },
     );
 
     const iframe = container.querySelector("iframe");
     expect(iframe).not.toBeNull();
     expect(iframe?.getAttribute("src")).toBe(
-      "/api/v1/threads/thr_manager/thread-storage/files/reports/status.html",
+      "/api/v1/threads/thr_manager/thread-storage/files/reports/preview.html",
     );
     expect(iframe?.getAttribute("sandbox")).toBe("allow-scripts");
     expect(iframe?.getAttribute("srcdoc")).toBeNull();
-    expect(container.textContent).not.toContain("bbStatusState");
-    expect(container.textContent).not.toContain("bbThreadTell");
-  });
-
-  it.each([
-    MANAGER_STATUS_HTML_FILE_PATH,
-    MANAGER_STATUS_INDEX_FILE_PATH,
-    MANAGER_STATUS_MARKDOWN_FILE_PATH,
-  ])("renders %s through the unified STATUS route", async (activePath) => {
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thr_manager/status-version",
-        handler: () => jsonResponse({ source: "html", hash: "status-hash" }),
-      },
-    ]);
-    const { wrapper } = createQueryClientTestHarness();
-    const { container } = render(
-      <ThreadStorageFilePreview
-        activePath={activePath}
-        filePreview={makeTextPreview({
-          content: "# Status",
-          path: activePath,
-        })}
-        isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
-        threadId="thr_manager"
-      />,
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(container.querySelector("iframe")?.getAttribute("src")).toBe(
-        "/api/v1/threads/thr_manager/status/?v=status-hash",
-      );
-    });
-  });
-
-  it("renders STATUS.md directly with relative status assets resolved", async () => {
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thr_manager/status-version",
-        handler: () => jsonResponse({ source: "md", hash: "status-hash" }),
-      },
-      {
-        pathname: "/api/v1/threads/thr_manager/thread-storage/content",
-        handler: (request) => {
-          const url = new URL(request.url);
-          expect(url.searchParams.get("path")).toBe(
-            MANAGER_STATUS_MARKDOWN_FILE_PATH,
-          );
-          return new Response(
-            "![chart](./chart.png)\n\n[details](details.html)",
-            {
-              headers: { "content-type": "text/markdown" },
-            },
-          );
-        },
-      },
-    ]);
-    const { wrapper } = createQueryClientTestHarness();
-    const { container } = render(
-      <ThreadStorageFilePreview
-        activePath={MANAGER_STATUS_MARKDOWN_FILE_PATH}
-        copyPath="/Users/me/.bb/thread-storage/thr_manager/STATUS.md"
-        filePreview={makeTextPreview({
-          content: "# Status",
-          path: MANAGER_STATUS_MARKDOWN_FILE_PATH,
-        })}
-        isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
-        threadId="thr_manager"
-      />,
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(
-        screen.getByRole("img", { name: "chart" }).getAttribute("src"),
-      ).toBe("/api/v1/threads/thr_manager/status/chart.png");
-    });
-    expect(
-      screen.getByRole("link", { name: "details" }).getAttribute("href"),
-    ).toBe("/api/v1/threads/thr_manager/status/details.html");
-    expect(
-      screen.queryByRole("tablist", { name: "Markdown view mode" }),
-    ).toBeNull();
-    expect(screen.queryByText(MANAGER_STATUS_MARKDOWN_FILE_PATH)).toBeNull();
-    expect(
-      screen.queryByRole("button", { name: "Copy file path" }),
-    ).toBeNull();
-    expect(container.querySelector("iframe")).toBeNull();
-  });
-
-  it("renders empty STATUS directly", async () => {
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thr_manager/status-version",
-        handler: () => jsonResponse({ source: "empty", hash: "status-hash" }),
-      },
-    ]);
-    const { wrapper } = createQueryClientTestHarness();
-    const { container } = render(
-      <ThreadStorageFilePreview
-        activePath={MANAGER_STATUS_FILE_PATH}
-        filePreview={undefined}
-        isLoading={false}
-        pinnedPath={MANAGER_STATUS_FILE_PATH}
-        threadId="thr_manager"
-      />,
-      { wrapper },
-    );
-
-    await screen.findByText("Manager hasn't written a status yet.");
-    expect(container.querySelector("iframe")).toBeNull();
+    expect(container.textContent).not.toContain("window.bb");
   });
 });
diff --git a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
index ecc1c06eb..998b4b6c3 100644
--- a/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
+++ b/apps/app/src/components/secondary-panel/ThreadStorageFilePreview.tsx
@@ -1,24 +1,9 @@
-import { useMemo } from "react";
 import {
   FilePreview as FilePreviewSurface,
   type FilePreviewFile,
-  type FilePreviewHeaderMode,
 } from "./FilePreview";
-import {
-  MANAGER_STATUS_MARKDOWN_FILE_PATH,
-  isManagerStatusStorageFilePath,
-} from "./managerStorage";
-import {
-  useThreadStatusMarkdownPreview,
-  useThreadStatusVersion,
-} from "@/hooks/queries/thread-queries";
 import { HttpError } from "@/lib/api";
-import {
-  buildThreadStatusContentUrl,
-  buildThreadStorageRawContentUrl,
-} from "@/lib/file-content-urls";
-import { createAssetMarkdownUrlTransform } from "@/lib/markdown-url-transform";
-import type { ThreadStatusVersionResponse } from "@bb/server-contract";
+import { buildThreadStorageRawContentUrl } from "@/lib/file-content-urls";
 import type {
   FilePreview,
   TextFilePreview,
@@ -30,7 +15,6 @@ import { isHtmlFilePreviewPath } from "@/lib/file-preview";
 // realistic previews, but omit allow-same-origin so the frame gets an opaque
 // origin and cannot read bb app cookies, storage, or same-origin APIs.
 const GENERIC_HTML_IFRAME_SANDBOX = "allow-scripts";
-const MANAGER_STATUS_HEADER_MODE: FilePreviewHeaderMode = "none";
 
 interface FilePreviewBaseProps {
   activePath: string;
@@ -43,13 +27,11 @@ interface FilePreviewBaseProps {
 }
 
 interface ThreadStorageFilePreviewProps extends FilePreviewBaseProps {
-  pinnedPath: string;
   threadId: string;
 }
 
 interface SecondaryPanelFilePreviewProps extends FilePreviewBaseProps {
   htmlPreviewUrl?: string | null;
-  pendingNotFoundPath?: string;
   statusLabel?: WorkspaceFilePreviewStatusLabel | null;
 }
 
@@ -68,13 +50,6 @@ function buildTextPreviewFile({
   };
 }
 
-function buildManagerStatusPreviewUrl(
-  threadId: string,
-  version: ThreadStatusVersionResponse,
-): string {
-  return buildThreadStatusContentUrl(threadId, version.hash);
-}
-
 export function SecondaryPanelFilePreview({
   activePath,
   copyPath = null,
@@ -84,22 +59,10 @@ export function SecondaryPanelFilePreview({
   isLoading,
   lineNumber = null,
   onOpenInEditor,
-  pendingNotFoundPath,
   statusLabel = null,
 }: SecondaryPanelFilePreviewProps) {
   if (error) {
     const isNotFound = error instanceof HttpError && error.status === 404;
-    if (isNotFound && activePath === pendingNotFoundPath) {
-      return (
-        <FilePreviewSurface
-          path={activePath}
-          copyPath={copyPath}
-          onOpenInEditor={onOpenInEditor}
-          statusLabel={statusLabel}
-          state={{ kind: "manager-status-pending" }}
-        />
-      );
-    }
     return (
       <FilePreviewSurface
         path={activePath}
@@ -223,147 +186,8 @@ export function ThreadStorageFilePreview({
   isLoading,
   lineNumber,
   onOpenInEditor,
-  pinnedPath,
   threadId,
 }: ThreadStorageFilePreviewProps) {
-  const isManagerStatusTab = isManagerStatusStorageFilePath(activePath);
-  const statusVersion = useThreadStatusVersion(threadId, {
-    enabled: isManagerStatusTab,
-  });
-  const statusMarkdownPreview = useThreadStatusMarkdownPreview(
-    threadId,
-    statusVersion.data?.hash,
-    {
-      enabled: isManagerStatusTab && statusVersion.data?.source === "md",
-    },
-  );
-  const statusMarkdownAssetBaseUrl = useMemo(
-    () => buildThreadStatusContentUrl(threadId),
-    [threadId],
-  );
-  const statusMarkdownUrlTransform = useMemo(() => {
-    return createAssetMarkdownUrlTransform(statusMarkdownAssetBaseUrl);
-  }, [statusMarkdownAssetBaseUrl]);
-
-  if (isManagerStatusTab) {
-    if (statusVersion.isError) {
-      return (
-        <FilePreviewSurface
-          path={activePath}
-          copyPath={copyPath}
-          headerMode={MANAGER_STATUS_HEADER_MODE}
-          state={{
-            kind: "error",
-            message:
-              statusVersion.error instanceof Error
-                ? statusVersion.error.message
-                : "Failed to load manager status.",
-          }}
-        />
-      );
-    }
-
-    if (!statusVersion.data) {
-      return (
-        <FilePreviewSurface
-          path={activePath}
-          copyPath={copyPath}
-          headerMode={MANAGER_STATUS_HEADER_MODE}
-          state={{ kind: "loading" }}
-        />
-      );
-    }
-
-    if (statusVersion.data.source === "empty") {
-      return (
-        <FilePreviewSurface
-          path={activePath}
-          copyPath={copyPath}
-          headerMode={MANAGER_STATUS_HEADER_MODE}
-          state={{ kind: "manager-status-pending" }}
-        />
-      );
-    }
-
-    if (statusVersion.data.source === "md") {
-      if (statusMarkdownPreview.isError) {
-        return (
-          <FilePreviewSurface
-            path={activePath}
-            copyPath={copyPath}
-            headerMode={MANAGER_STATUS_HEADER_MODE}
-            state={{
-              kind: "error",
-              message:
-                statusMarkdownPreview.error instanceof Error
-                  ? statusMarkdownPreview.error.message
-                  : "Failed to load manager status.",
-            }}
-          />
-        );
-      }
-
-      if (!statusMarkdownPreview.data) {
-        return (
-          <FilePreviewSurface
-            path={activePath}
-            copyPath={copyPath}
-            headerMode={MANAGER_STATUS_HEADER_MODE}
-            state={{ kind: "loading" }}
-          />
-        );
-      }
-
-      if (statusMarkdownPreview.data.kind !== "text") {
-        return (
-          <FilePreviewSurface
-            path={activePath}
-            copyPath={copyPath}
-            headerMode={MANAGER_STATUS_HEADER_MODE}
-            state={{
-              kind: "error",
-              message: `Preview not available for ${statusMarkdownPreview.data.mimeType}.`,
-            }}
-          />
-        );
-      }
-
-      return (
-        <FilePreviewSurface
-          path={activePath}
-          copyPath={copyPath}
-          headerMode={MANAGER_STATUS_HEADER_MODE}
-          state={{
-            kind: "ready",
-            lineNumber: null,
-            showMarkdownModeToggle: false,
-            markdownUrlTransform: statusMarkdownUrlTransform,
-            file: {
-              name:
-                statusMarkdownPreview.data.name ??
-                MANAGER_STATUS_MARKDOWN_FILE_PATH,
-              contents: statusMarkdownPreview.data.content,
-            },
-          }}
-        />
-      );
-    }
-
-    return (
-      <FilePreviewSurface
-        path={activePath}
-        copyPath={copyPath}
-        headerMode={MANAGER_STATUS_HEADER_MODE}
-        state={{
-          kind: "iframe",
-          sandbox: null,
-          title: "Manager status",
-          url: buildManagerStatusPreviewUrl(threadId, statusVersion.data),
-        }}
-      />
-    );
-  }
-
   return (
     <SecondaryPanelFilePreview
       activePath={activePath}
@@ -374,7 +198,6 @@ export function ThreadStorageFilePreview({
       isLoading={isLoading}
       lineNumber={lineNumber}
       onOpenInEditor={onOpenInEditor}
-      pendingNotFoundPath={pinnedPath}
     />
   );
 }
diff --git a/apps/app/src/components/secondary-panel/managerStorage.ts b/apps/app/src/components/secondary-panel/managerStorage.ts
deleted file mode 100644
index 68225d95a..000000000
--- a/apps/app/src/components/secondary-panel/managerStorage.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export {
-  MANAGER_STATUS_FILE_PATH,
-  MANAGER_STATUS_HTML_FILE_PATH,
-  MANAGER_STATUS_INDEX_FILE_PATH,
-  MANAGER_STATUS_MARKDOWN_FILE_PATH,
-  isManagerStatusStorageFilePath,
-  resolveManagerStatusStorageTabPath,
-  resolvePinnedManagerStorageFilePath,
-} from "@/lib/manager-status-storage";
-export type {
-  ManagerStorageFileEntry,
-  ManagerStorageFiles,
-} from "@/lib/manager-status-storage";
diff --git a/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx b/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
index 1f6d10eb4..c25947537 100644
--- a/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
+++ b/apps/app/src/components/secondary-panel/useThreadFileTabs.test.tsx
@@ -17,6 +17,7 @@ import {
   getFixedPanelTabsStateStorageKey,
   parseFixedPanelTabsState,
   serializeFixedPanelTabsState,
+  type AppFixedPanelTab,
   type FixedPanelTab,
   type FixedPanelTabsState,
   type HostFilePreviewFixedPanelTab,
@@ -25,13 +26,7 @@ import {
   type WorkspaceFilePreviewFixedPanelTab,
 } from "@/lib/fixed-panel-tabs-state";
 import { useFixedPanelTabsState } from "@/lib/fixed-panel-tabs";
-import {
-  MANAGER_STATUS_FILE_PATH,
-  MANAGER_STATUS_HTML_FILE_PATH,
-  MANAGER_STATUS_INDEX_FILE_PATH,
-  MANAGER_STATUS_MARKDOWN_FILE_PATH,
-} from "./managerStorage";
-import { useThreadFileTabs } from "./useThreadFileTabs";
+import { STATUS_APP_ID, useThreadFileTabs } from "./useThreadFileTabs";
 
 const NOW = 1_700_000_000_000;
 const WORKING_TREE_SOURCE: EnvironmentFilePreviewSource = {
@@ -119,6 +114,10 @@ function isHostFilePreviewTab(
   return tab.kind === "host-file-preview";
 }
 
+function isAppTab(tab: FixedPanelTab): tab is AppFixedPanelTab {
+  return tab.kind === "app";
+}
+
 function workspaceFileStates(
   tabs: readonly SecondaryFileFixedPanelTab[],
 ): WorkspaceFileTabState[] {
@@ -146,7 +145,11 @@ function storageFilePaths(
 }
 
 function appTabIds(tabs: readonly SecondaryFileFixedPanelTab[]): string[] {
-  return tabs.filter((tab) => tab.kind === "app").map((tab) => tab.appId);
+  return tabs.filter(isAppTab).map((tab) => tab.appId);
+}
+
+function tabIds(tabs: readonly SecondaryFileFixedPanelTab[]): string[] {
+  return tabs.map((tab) => tab.id);
 }
 
 function workspaceFileTabId(path: string): string {
@@ -161,6 +164,10 @@ function hostFileTabId(path: string): string {
   return `host-file-preview:${encodeURIComponent(path)}`;
 }
 
+function appTabId(appId: string): string {
+  return `app:${encodeURIComponent(appId)}`;
+}
+
 function newTabId(): string {
   return "new-tab";
 }
@@ -185,7 +192,7 @@ function createStoredStorageTab(
 ): ThreadStorageFilePreviewFixedPanelTab {
   return {
     id: storageFileTabId(path),
-    isPinned: path === MANAGER_STATUS_FILE_PATH,
+    isPinned: false,
     kind: "thread-storage-file-preview",
     path,
   };
@@ -226,9 +233,7 @@ function getStoredStoragePaths(state: FixedPanelTabsState): string[] {
 }
 
 function getStoredAppIds(state: FixedPanelTabsState): string[] {
-  return state.secondary.tabs
-    .filter((tab) => tab.kind === "app")
-    .map((tab) => tab.appId);
+  return state.secondary.tabs.filter(isAppTab).map((tab) => tab.appId);
 }
 
 afterEach(() => {
@@ -309,18 +314,14 @@ describe("useThreadFileTabs", () => {
     expect(result.current.activeWorkspaceFilePath).toBe("src/one.ts");
   });
 
-  it("keeps workspace and storage active tabs mutually exclusive", async () => {
+  it("keeps workspace and storage active tabs mutually exclusive", () => {
     const { result } = renderThreadFileTabsHook({
       environmentId: "env-one",
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
+      storageFiles: [{ path: "notes.md" }],
       threadId: "thr-manager",
     });
 
-    await waitFor(() => {
-      expect(result.current.activeStorageFilePath).toBe("STATUS");
-    });
-
     act(() => {
       result.current.openWorkspaceFile(
         buildWorkspaceFileTab({
@@ -383,39 +384,31 @@ describe("useThreadFileTabs", () => {
     expect(result.current.activeHostFilePath).toBeNull();
   });
 
-  it("orders file tabs by open order with the pinned status tab first", async () => {
+  it("orders file tabs by open order with the pinned status app first", async () => {
     const { result } = renderThreadFileTabsHook({
+      apps: [{ id: STATUS_APP_ID }],
       environmentId: "env-one",
       threadType: "manager",
-      storageFiles: [{ path: "STATUS.md" }, { path: "notes.md" }],
+      storageFiles: [{ path: "notes.md" }],
       threadId: "thr-manager-open-order",
     });
 
     await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS"],
-      );
+      expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+        STATUS_APP_ID,
+      ]);
     });
 
     act(() => {
       result.current.openWorkspaceFile(
         buildWorkspaceFileTab({ lineNumber: null, path: "src/app.ts" }),
       );
-    });
-    act(() => {
       result.current.openStorageFile("notes.md");
-    });
-    act(() => {
       result.current.openHostFile({ lineNumber: null, path: "/tmp/host.md" });
     });
 
-    // notes.md is opened after the workspace file, so it stays after it —
-    // tabs interleave by open order rather than grouping by type, while the
-    // pinned STATUS tab remains first.
-    expect(
-      result.current.orderedSecondaryFileTabs.map((tab) => tab.id),
-    ).toEqual([
-      storageFileTabId("STATUS"),
+    expect(tabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+      appTabId(STATUS_APP_ID),
       workspaceFileTabId("src/app.ts"),
       storageFileTabId("notes.md"),
       hostFileTabId("/tmp/host.md"),
@@ -555,112 +548,37 @@ describe("useThreadFileTabs", () => {
     expect(result.current.activeWorkspaceFilePath).toBeNull();
   });
 
-  it("seeds and prunes manager storage tabs", async () => {
+  it("prunes manager storage tabs against the current storage file list", async () => {
     const { result, rerender } = renderThreadFileTabsHook({
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
+      storageFiles: [{ path: "notes.md" }, { path: "plan.md" }],
       threadId: "thr-manager",
     });
 
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS"],
-      );
-    });
-
     act(() => {
       result.current.openStorageFile("notes.md");
+      result.current.openStorageFile("plan.md");
     });
     expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual([
-      "STATUS",
       "notes.md",
+      "plan.md",
     ]);
+    expect(result.current.activeStorageFilePath).toBe("plan.md");
 
     rerender({
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [{ path: "STATUS" }],
-      threadId: "thr-manager",
-    });
-
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS"],
-      );
-    });
-    expect(result.current.activeStorageFilePath).toBe("STATUS");
-  });
-
-  it("uses the unified STATUS tab even when STATUS.html is present", async () => {
-    const { result } = renderThreadFileTabsHook({
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [
-        { path: MANAGER_STATUS_MARKDOWN_FILE_PATH },
-        { path: MANAGER_STATUS_HTML_FILE_PATH },
-        { path: "notes.md" },
-      ],
-      threadId: "thr-manager-html-status",
-    });
-
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        [MANAGER_STATUS_FILE_PATH],
-      );
-    });
-    expect(result.current.activeStorageFilePath).toBe(
-      MANAGER_STATUS_FILE_PATH,
-    );
-    expect(result.current.pinnedStorageFilePath).toBe(
-      MANAGER_STATUS_FILE_PATH,
-    );
-
-    act(() => {
-      result.current.openStorageFile(MANAGER_STATUS_HTML_FILE_PATH);
-      result.current.openStorageFile(MANAGER_STATUS_MARKDOWN_FILE_PATH);
-      result.current.openStorageFile(MANAGER_STATUS_INDEX_FILE_PATH);
-    });
-
-    expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual([
-      MANAGER_STATUS_FILE_PATH,
-    ]);
-    expect(result.current.activeStorageFilePath).toBe(
-      MANAGER_STATUS_FILE_PATH,
-    );
-  });
-
-  it("uses STATUS for the pinned manager storage tab without STATUS.html", async () => {
-    const { result } = renderThreadFileTabsHook({
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [{ path: MANAGER_STATUS_MARKDOWN_FILE_PATH }],
-      threadId: "thr-manager-md-status",
-    });
-
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        [MANAGER_STATUS_FILE_PATH],
-      );
-    });
-    expect(result.current.pinnedStorageFilePath).toBe(MANAGER_STATUS_FILE_PATH);
-  });
-
-  it("keeps the STATUS pending tab when no status file exists", async () => {
-    const { result } = renderThreadFileTabsHook({
       environmentId: null,
       threadType: "manager",
       storageFiles: [{ path: "notes.md" }],
-      threadId: "thr-manager-no-status",
+      threadId: "thr-manager",
     });
 
     await waitFor(() => {
       expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        [MANAGER_STATUS_FILE_PATH],
+        ["notes.md"],
       );
     });
-    expect(result.current.activeStorageFilePath).toBe(MANAGER_STATUS_FILE_PATH);
-    expect(result.current.pinnedStorageFilePath).toBe(MANAGER_STATUS_FILE_PATH);
+    expect(result.current.activeStorageFilePath).toBeNull();
   });
 
   it("keeps seeded manager storage tabs while thread type is unresolved", async () => {
@@ -671,7 +589,7 @@ describe("useThreadFileTabs", () => {
       createEmptyFixedPanelTabsState({
         secondary: {
           tabs: [
-            createStoredStorageTab("STATUS"),
+            createStoredStorageTab("overview.md"),
             createStoredStorageTab("notes.md"),
           ],
           activeTabId: storageFileTabId("notes.md"),
@@ -691,7 +609,7 @@ describe("useThreadFileTabs", () => {
       [],
     );
     expect(getStoredStoragePaths(readStoredState(threadId))).toEqual([
-      "STATUS",
+      "overview.md",
       "notes.md",
     ]);
     expect(readStoredState(threadId).secondary.activeTabId).toBe(
@@ -701,13 +619,13 @@ describe("useThreadFileTabs", () => {
     rerender({
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
+      storageFiles: [{ path: "overview.md" }, { path: "notes.md" }],
       threadId,
     });
 
     await waitFor(() => {
       expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS", "notes.md"],
+        ["overview.md", "notes.md"],
       );
     });
     expect(result.current.activeStorageFilePath).toBe("notes.md");
@@ -763,7 +681,7 @@ describe("useThreadFileTabs", () => {
     expect(result.current.activeWorkspaceFilePath).toBe("src/app.ts");
   });
 
-  it("seeds the pinned manager tab without stealing active seeded storage", async () => {
+  it("keeps active seeded storage when it remains in the file list", async () => {
     vi.spyOn(Date, "now").mockReturnValue(NOW);
     const threadId = "thr-manager-seeded-active";
     seedStoredState(
@@ -780,52 +698,24 @@ describe("useThreadFileTabs", () => {
     const { result } = renderThreadFileTabsHook({
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
+      storageFiles: [{ path: "notes.md" }],
       threadId,
     });
 
     await waitFor(() => {
       expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS", "notes.md"],
+        ["notes.md"],
       );
     });
     expect(result.current.activeStorageFilePath).toBe("notes.md");
   });
 
-  it("keeps the pinned manager storage tab open when close is requested", async () => {
+  it("closes manager storage tabs", () => {
     const { result } = renderThreadFileTabsHook({
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }],
-      threadId: "thr-manager-pinned",
-    });
-
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS"],
-      );
-    });
-
-    act(() => {
-      result.current.closeStorageFileTab("STATUS");
-    });
-
-    expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual([
-      "STATUS",
-    ]);
-    expect(result.current.activeStorageFilePath).toBe("STATUS");
-  });
-
-  it("returns to the pinned manager storage tab when the active storage tab closes", async () => {
-    const { result } = renderThreadFileTabsHook({
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
-      threadId: "thr-manager-close-active",
-    });
-
-    await waitFor(() => {
-      expect(result.current.activeStorageFilePath).toBe("STATUS");
+      storageFiles: [{ path: "notes.md" }],
+      threadId: "thr-manager-storage-close",
     });
 
     act(() => {
@@ -837,66 +727,36 @@ describe("useThreadFileTabs", () => {
       result.current.closeStorageFileTab("notes.md");
     });
 
-    await waitFor(() => {
-      expect(result.current.activeStorageFilePath).toBe("STATUS");
-    });
-  });
-
-  it("keeps the pinned manager storage tab when the file list omits it", async () => {
-    vi.spyOn(Date, "now").mockReturnValue(NOW);
-    const threadId = "thr-manager-pinned-omitted";
-    seedStoredState(
-      threadId,
-      createEmptyFixedPanelTabsState({
-        secondary: {
-          tabs: [
-            createStoredStorageTab("STATUS"),
-            createStoredStorageTab("notes.md"),
-          ],
-          activeTabId: storageFileTabId("STATUS"),
-          isOpen: true,
-        },
-        lastUsedAt: NOW,
-      }),
+    expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
+      [],
     );
-    const { result } = renderThreadFileTabsHook({
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [{ path: "notes.md" }],
-      threadId,
-    });
-
-    await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS", "notes.md"],
-      );
-    });
-    expect(result.current.activeStorageFilePath).toBe("STATUS");
-    expect(getStoredStoragePaths(readStoredState(threadId))).toEqual([
-      "STATUS",
-      "notes.md",
-    ]);
+    expect(result.current.activeStorageFilePath).toBeNull();
   });
 
-  it("adds a pinned status app tab alongside the existing manager STATUS tab", async () => {
+  it("opens the status app tab for managers and keeps it pinned", async () => {
     const { result } = renderThreadFileTabsHook({
-      apps: [{ id: "status" }],
+      apps: [{ id: STATUS_APP_ID }],
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }],
+      storageFiles: undefined,
       threadId: "thr-manager-status-app",
     });
 
     await waitFor(() => {
-      expect(storageFilePaths(result.current.orderedSecondaryFileTabs)).toEqual(
-        ["STATUS"],
-      );
       expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
-        "status",
+        STATUS_APP_ID,
       ]);
     });
-    expect(result.current.activeStorageFilePath).toBe("STATUS");
-    expect(result.current.activeAppId).toBeNull();
+    expect(result.current.activeAppId).toBe(STATUS_APP_ID);
+
+    act(() => {
+      result.current.closeAppTab(STATUS_APP_ID);
+    });
+
+    expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
+      STATUS_APP_ID,
+    ]);
+    expect(result.current.activeAppId).toBe(STATUS_APP_ID);
   });
 
   it("opens an app tab from launcher search selection", () => {
@@ -925,32 +785,6 @@ describe("useThreadFileTabs", () => {
     ]);
   });
 
-  it("keeps the pinned status app tab open when close is requested", async () => {
-    const { result } = renderThreadFileTabsHook({
-      apps: [{ id: "status" }],
-      environmentId: null,
-      threadType: "manager",
-      storageFiles: [{ path: "STATUS" }],
-      threadId: "thr-manager-status-app-pinned",
-    });
-
-    await waitFor(() => {
-      expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
-        "status",
-      ]);
-    });
-
-    act(() => {
-      result.current.activateAppTab("status");
-      result.current.closeAppTab("status");
-    });
-
-    expect(appTabIds(result.current.orderedSecondaryFileTabs)).toEqual([
-      "status",
-    ]);
-    expect(result.current.activeAppId).toBe("status");
-  });
-
   it("does not rewrite workspace tabs for no-op callbacks", () => {
     const dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(NOW);
     const threadId = "thr-workspace-no-op";
@@ -999,7 +833,7 @@ describe("useThreadFileTabs", () => {
       createEmptyFixedPanelTabsState({
         secondary: {
           tabs: [
-            createStoredStorageTab("STATUS"),
+            createStoredStorageTab("overview.md"),
             createStoredStorageTab("notes.md"),
           ],
           activeTabId: storageFileTabId("notes.md"),
@@ -1011,7 +845,7 @@ describe("useThreadFileTabs", () => {
     const { result } = renderThreadFileTabsHook({
       environmentId: null,
       threadType: "manager",
-      storageFiles: [{ path: "STATUS" }, { path: "notes.md" }],
+      storageFiles: [{ path: "overview.md" }, { path: "notes.md" }],
       threadId,
     });
 
@@ -1023,12 +857,12 @@ describe("useThreadFileTabs", () => {
     act(() => {
       result.current.openStorageFile("notes.md");
       result.current.activateStorageFileTab("notes.md");
-      result.current.closeStorageFileTab("STATUS");
+      result.current.closeStorageFileTab("missing.md");
     });
 
     expect(readStoredState(threadId).lastUsedAt).toBe(NOW);
     expect(getStoredStoragePaths(readStoredState(threadId))).toEqual([
-      "STATUS",
+      "overview.md",
       "notes.md",
     ]);
   });
@@ -1039,8 +873,8 @@ describe("useThreadFileTabs", () => {
       threadId,
       createEmptyFixedPanelTabsState({
         secondary: {
-          tabs: [createStoredStorageTab("STATUS")],
-          activeTabId: storageFileTabId("STATUS"),
+          tabs: [createStoredStorageTab("notes.md")],
+          activeTabId: storageFileTabId("notes.md"),
           isOpen: true,
         },
         lastUsedAt: Date.now(),
diff --git a/apps/app/src/components/secondary-panel/useThreadFileTabs.ts b/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
index 58ab68ab1..ecc890f55 100644
--- a/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
+++ b/apps/app/src/components/secondary-panel/useThreadFileTabs.ts
@@ -25,11 +25,6 @@ import {
   type HostFileTabState,
   type WorkspaceFileTabState,
 } from "@/lib/file-preview";
-import {
-  isManagerStatusStorageFilePath,
-  resolveManagerStatusStorageTabPath,
-  resolvePinnedManagerStorageFilePath,
-} from "./managerStorage";
 
 export const STATUS_APP_ID = "status";
 
@@ -137,19 +132,6 @@ function setSecondaryTabs({
   };
 }
 
-function removeMismatchedManagerStatusTabs(
-  tabs: readonly FixedPanelTab[],
-  pinnedStorageFilePath: string,
-): readonly FixedPanelTab[] {
-  const nextTabs = tabs.filter(
-    (tab) =>
-      !isStorageFilePreviewTab(tab) ||
-      tab.path === pinnedStorageFilePath ||
-      !isManagerStatusStorageFilePath(tab.path),
-  );
-  return nextTabs.length === tabs.length ? tabs : nextTabs;
-}
-
 function upsertSecondaryTab(
   tabs: readonly FixedPanelTab[],
   nextTab: FixedPanelTab,
@@ -220,14 +202,10 @@ function isActiveTabStillOpen(
   return activeTabId !== null && tabs.some((tab) => tab.id === activeTabId);
 }
 
-function createStorageTab(
-  path: string,
-  pinnedStorageFilePath: string,
-): ThreadStorageFilePreviewFixedPanelTab {
-  const tabPath = resolveManagerStatusStorageTabPath(path);
+function createStorageTab(path: string): ThreadStorageFilePreviewFixedPanelTab {
   return createThreadStorageFilePreviewFixedPanelTab({
-    isPinned: tabPath === pinnedStorageFilePath,
-    path: tabPath,
+    isPinned: false,
+    path,
   });
 }
 
@@ -235,17 +213,6 @@ function createAppTab(appId: string): AppFixedPanelTab {
   return createAppFixedPanelTab({ appId });
 }
 
-function getManagerDefaultActiveTabId(
-  tabs: readonly FixedPanelTab[],
-  pinnedStorageFilePath: string,
-): string {
-  const pinnedTab = findStorageFileTab(tabs, pinnedStorageFilePath);
-  return (
-    pinnedTab?.id ??
-    createStorageTab(pinnedStorageFilePath, pinnedStorageFilePath).id
-  );
-}
-
 function findWorkspaceTab(
   tabs: readonly FixedPanelTab[],
   path: string,
@@ -348,21 +315,17 @@ interface BuildOrderedSecondaryFileTabsArgs {
   isManagerThread: boolean;
 }
 
-function isPinnedStorageTab(tab: SecondaryFileFixedPanelTab): boolean {
-  return tab.kind === "thread-storage-file-preview" && tab.isPinned;
-}
-
 function isPinnedAppTab(tab: SecondaryFileFixedPanelTab): boolean {
   return tab.kind === "app" && tab.appId === STATUS_APP_ID;
 }
 
 function isPinnedSecondaryFileTab(tab: SecondaryFileFixedPanelTab): boolean {
-  return isPinnedStorageTab(tab) || isPinnedAppTab(tab);
+  return isPinnedAppTab(tab);
 }
 
 /**
  * Flattens the secondary panel's tabs into the closable file-tab strip, in the
- * order the user opened them. The pinned manager status tab is floated to the
+ * order the user opened them. The pinned manager status app is floated to the
  * front; everything else (workspace, host, storage, new tab) keeps its
  * insertion order regardless of type.
  */
@@ -415,8 +378,6 @@ export function useThreadFileTabs({
   const updateFixedPanelTabsState = useUpdateFixedPanelTabsState(threadId);
   const isThreadResolved = threadType !== undefined;
   const isManagerThread = threadType === "manager";
-  const pinnedStorageFilePath =
-    resolvePinnedManagerStorageFilePath(storageFiles);
   const resolvedEnvironmentId = isThreadResolved
     ? (environmentId ?? null)
     : undefined;
@@ -469,56 +430,18 @@ export function useThreadFileTabs({
     });
   }, [isManagerThread, isThreadResolved, updateFixedPanelTabsState]);
 
-  useEffect(() => {
-    if (!isManagerThread) {
-      return;
-    }
-    updateFixedPanelTabsState((state) => {
-      const pinnedTab = createStorageTab(
-        pinnedStorageFilePath,
-        pinnedStorageFilePath,
-      );
-      const baseTabs = removeMismatchedManagerStatusTabs(
-        state.secondary.tabs,
-        pinnedStorageFilePath,
-      );
-      const tabs = upsertSecondaryTab(baseTabs, pinnedTab);
-      const activeTabId = isActiveTabStillOpen(
-        tabs,
-        state.secondary.activeTabId,
-      )
-        ? state.secondary.activeTabId
-        : pinnedTab.id;
-      return setSecondaryTabs({
-        activeTabId,
-        isOpen: state.secondary.isOpen,
-        state,
-        tabs,
-      });
-    });
-  }, [
-    fixedPanelTabsState.secondary.activeTabId,
-    fixedPanelTabsState.secondary.tabs,
-    isManagerThread,
-    pinnedStorageFilePath,
-    updateFixedPanelTabsState,
-  ]);
-
   useEffect(() => {
     if (!isThreadResolved || !storageFiles) return;
     if (!isManagerThread) return;
     updateFixedPanelTabsState((state) => {
-      const knownPaths = new Set([
-        pinnedStorageFilePath,
-        ...storageFiles.map((file) => file.path),
-      ]);
+      const knownPaths = new Set(storageFiles.map((file) => file.path));
       const tabs = pruneStorageTabs(state.secondary.tabs, knownPaths);
       const activeTabId = isActiveTabStillOpen(
         tabs,
         state.secondary.activeTabId,
       )
         ? state.secondary.activeTabId
-        : getManagerDefaultActiveTabId(tabs, pinnedStorageFilePath);
+        : null;
       return setSecondaryTabs({
         activeTabId,
         isOpen: state.secondary.isOpen,
@@ -529,7 +452,6 @@ export function useThreadFileTabs({
   }, [
     isManagerThread,
     isThreadResolved,
-    pinnedStorageFilePath,
     storageFiles,
     updateFixedPanelTabsState,
   ]);
@@ -560,8 +482,14 @@ export function useThreadFileTabs({
     updateFixedPanelTabsState((state) => {
       const statusAppTab = createAppTab(STATUS_APP_ID);
       const tabs = upsertSecondaryTab(state.secondary.tabs, statusAppTab);
+      const activeTabId = isActiveTabStillOpen(
+        tabs,
+        state.secondary.activeTabId,
+      )
+        ? state.secondary.activeTabId
+        : statusAppTab.id;
       return setSecondaryTabs({
-        activeTabId: state.secondary.activeTabId,
+        activeTabId,
         isOpen: state.secondary.isOpen,
         state,
         tabs,
@@ -652,7 +580,7 @@ export function useThreadFileTabs({
   const openStorageFile = useCallback(
     (path: string) => {
       if (!isManagerThread) return;
-      const nextTab = createStorageTab(path, pinnedStorageFilePath);
+      const nextTab = createStorageTab(path);
       updateFixedPanelTabsState((state) => {
         const tabs = upsertSecondaryTab(state.secondary.tabs, nextTab);
         if (
@@ -670,7 +598,7 @@ export function useThreadFileTabs({
         });
       });
     },
-    [isManagerThread, pinnedStorageFilePath, updateFixedPanelTabsState],
+    [isManagerThread, updateFixedPanelTabsState],
   );
 
   const openHostFile = useCallback(
@@ -814,7 +742,7 @@ export function useThreadFileTabs({
 
   const closeStorageFileTab = useCallback(
     (path: string) => {
-      if (!isManagerThread || path === pinnedStorageFilePath) return;
+      if (!isManagerThread) return;
       updateFixedPanelTabsState((state) => {
         const tab = findStorageFileTab(state.secondary.tabs, path);
         if (!tab) {
@@ -832,7 +760,7 @@ export function useThreadFileTabs({
         });
       });
     },
-    [isManagerThread, pinnedStorageFilePath, updateFixedPanelTabsState],
+    [isManagerThread, updateFixedPanelTabsState],
   );
 
   const activateStorageFileTab = useCallback(
@@ -884,10 +812,7 @@ export function useThreadFileTabs({
       if (!existingTab) {
         return state;
       }
-      if (
-        state.secondary.activeTabId === newTab.id &&
-        state.secondary.isOpen
-      ) {
+      if (state.secondary.activeTabId === newTab.id && state.secondary.isOpen) {
         return state;
       }
       return setSecondaryTabs({
@@ -922,9 +847,7 @@ export function useThreadFileTabs({
     (selection: FileSearchSelection) => {
       if (selection.source === "app") {
         const nextTab = createAppTab(selection.appId);
-        updateFixedPanelTabsState((state) =>
-          replaceNewTab({ nextTab, state }),
-        );
+        updateFixedPanelTabsState((state) => replaceNewTab({ nextTab, state }));
         return;
       }
 
@@ -939,24 +862,15 @@ export function useThreadFileTabs({
             statusLabel: null,
           },
         });
-        updateFixedPanelTabsState((state) =>
-          replaceNewTab({ nextTab, state }),
-        );
+        updateFixedPanelTabsState((state) => replaceNewTab({ nextTab, state }));
         return;
       }
 
       if (!isManagerThread) return;
-      const nextTab = createStorageTab(selection.path, pinnedStorageFilePath);
-      updateFixedPanelTabsState((state) =>
-        replaceNewTab({ nextTab, state }),
-      );
+      const nextTab = createStorageTab(selection.path);
+      updateFixedPanelTabsState((state) => replaceNewTab({ nextTab, state }));
     },
-    [
-      isManagerThread,
-      pinnedStorageFilePath,
-      resolvedEnvironmentId,
-      updateFixedPanelTabsState,
-    ],
+    [isManagerThread, resolvedEnvironmentId, updateFixedPanelTabsState],
   );
 
   const clearActiveFileTabs = useCallback(() => {
@@ -1028,7 +942,6 @@ export function useThreadFileTabs({
     openHostFile,
     openStorageFile,
     openWorkspaceFile,
-    pinnedStorageFilePath,
     selectFileSearchResult,
   };
 }
diff --git a/apps/app/src/hooks/environment-cache-effects.ts b/apps/app/src/hooks/environment-cache-effects.ts
index 4352a2e6d..721138eb1 100644
--- a/apps/app/src/hooks/environment-cache-effects.ts
+++ b/apps/app/src/hooks/environment-cache-effects.ts
@@ -12,7 +12,6 @@ import {
   threadStorageFilePreviewQueryKeyPrefix,
   threadStorageFilesForThreadQueryKeyPrefix,
   threadStoragePathsForThreadQueryKeyPrefix,
-  threadStatusVersionQueryKey,
 } from "./queries/query-keys";
 import type {
   EnvironmentArg,
@@ -106,7 +105,4 @@ export function invalidateThreadStorageQueries({
   queryClient.invalidateQueries({
     queryKey: threadStorageFilePreviewQueryKeyPrefix(threadId),
   });
-  queryClient.invalidateQueries({
-    queryKey: threadStatusVersionQueryKey(threadId),
-  });
 }
diff --git a/apps/app/src/hooks/mutation-cache-effects.ts b/apps/app/src/hooks/mutation-cache-effects.ts
index 576797eb8..787b9a9a9 100644
--- a/apps/app/src/hooks/mutation-cache-effects.ts
+++ b/apps/app/src/hooks/mutation-cache-effects.ts
@@ -20,7 +20,6 @@ import {
   threadStorageFilePreviewQueryKeyPrefix,
   threadStorageFilesForThreadQueryKeyPrefix,
   threadStoragePathsForThreadQueryKeyPrefix,
-  threadStatusVersionQueryKey,
   threadTimelineQueryKeyPrefix,
 } from "./queries/query-keys";
 import type {
@@ -248,9 +247,6 @@ export function removeThreadScopedQueries({
   queryClient.removeQueries({
     queryKey: threadStorageFilePreviewQueryKeyPrefix(threadId),
   });
-  queryClient.removeQueries({
-    queryKey: threadStatusVersionQueryKey(threadId),
-  });
 }
 
 export { removeEnvironmentScopedQueries };
diff --git a/apps/app/src/hooks/queries/query-keys.ts b/apps/app/src/hooks/queries/query-keys.ts
index 9e2d47e65..5350b6620 100644
--- a/apps/app/src/hooks/queries/query-keys.ts
+++ b/apps/app/src/hooks/queries/query-keys.ts
@@ -37,13 +37,9 @@ export const THREAD_TERMINALS_QUERY_KEY = "threadTerminals";
 export const THREAD_STORAGE_FILES_QUERY_KEY = "threadStorageFiles";
 export const THREAD_STORAGE_PATHS_QUERY_KEY = "threadStoragePaths";
 export const THREAD_STORAGE_FILE_PREVIEW_QUERY_KEY = "threadStorageFilePreview";
-export const THREAD_STATUS_VERSION_QUERY_KEY = "threadStatusVersion";
-export const THREAD_STATUS_MARKDOWN_PREVIEW_QUERY_KEY =
-  "threadStatusMarkdownPreview";
 export const THREAD_APPS_QUERY_KEY = "threadApps";
 export const THREAD_APP_QUERY_KEY = "threadApp";
-export const THREAD_APP_MARKDOWN_PREVIEW_QUERY_KEY =
-  "threadAppMarkdownPreview";
+export const THREAD_APP_MARKDOWN_PREVIEW_QUERY_KEY = "threadAppMarkdownPreview";
 export const THREAD_HOST_FILE_PREVIEW_QUERY_KEY = "threadHostFilePreview";
 export const ENVIRONMENT_QUERY_KEY = "environment";
 export const ENVIRONMENT_WORK_STATUS_QUERY_KEY = "environmentWorkStatus";
@@ -258,15 +254,6 @@ export type ThreadStorageFilePreviewQueryKeyPrefix = readonly [
   typeof THREAD_STORAGE_FILE_PREVIEW_QUERY_KEY,
   string,
 ];
-export type ThreadStatusVersionQueryKey = readonly [
-  typeof THREAD_STATUS_VERSION_QUERY_KEY,
-  string,
-];
-export type ThreadStatusMarkdownPreviewQueryKey = readonly [
-  typeof THREAD_STATUS_MARKDOWN_PREVIEW_QUERY_KEY,
-  string,
-  string | null | undefined,
-];
 export type ThreadAppsQueryKey = readonly [
   typeof THREAD_APPS_QUERY_KEY,
   string,
@@ -708,19 +695,6 @@ export function threadStorageFilePreviewQueryKeyPrefix(
   return [THREAD_STORAGE_FILE_PREVIEW_QUERY_KEY, threadId];
 }
 
-export function threadStatusVersionQueryKey(
-  threadId: string,
-): ThreadStatusVersionQueryKey {
-  return [THREAD_STATUS_VERSION_QUERY_KEY, threadId];
-}
-
-export function threadStatusMarkdownPreviewQueryKey(
-  threadId: string,
-  versionHash: string | null | undefined,
-): ThreadStatusMarkdownPreviewQueryKey {
-  return [THREAD_STATUS_MARKDOWN_PREVIEW_QUERY_KEY, threadId, versionHash];
-}
-
 export function threadAppsQueryKey(threadId: string): ThreadAppsQueryKey {
   return [THREAD_APPS_QUERY_KEY, threadId];
 }
diff --git a/apps/app/src/hooks/queries/thread-queries.test.tsx b/apps/app/src/hooks/queries/thread-queries.test.tsx
index 2b29bab47..ac217d051 100644
--- a/apps/app/src/hooks/queries/thread-queries.test.tsx
+++ b/apps/app/src/hooks/queries/thread-queries.test.tsx
@@ -26,8 +26,6 @@ import {
   useThreadQueuedMessages,
   useThreadPendingInteractions,
   useThreadPromptHistory,
-  useThreadStatusMarkdownPreview,
-  useThreadStatusVersion,
 } from "./thread-queries";
 import {
   hostsQueryKey,
@@ -40,8 +38,6 @@ import {
   threadPromptHistoryQueryKey,
   threadListQueryKey,
   threadQueryKey,
-  threadStatusMarkdownPreviewQueryKey,
-  threadStatusVersionQueryKey,
   threadTimelineQueryKey,
 } from "./query-keys";
 
@@ -332,10 +328,9 @@ describe("thread query bootstraps", () => {
       queryClient.getQueryData(threadTimelineQueryKey("thread-1", "standard")),
     ).toBeUndefined();
 
-    const timelineResult = renderHook(
-      () => useThreadTimeline("thread-1"),
-      { wrapper },
-    );
+    const timelineResult = renderHook(() => useThreadTimeline("thread-1"), {
+      wrapper,
+    });
 
     await waitFor(() => {
       expect(timelineResult.result.current.data).toEqual(timeline);
@@ -447,11 +442,7 @@ describe("thread query bootstraps", () => {
               supportsRename: true,
               supportsServiceTier: true,
               supportsUserQuestion: true,
-              supportedPermissionModes: [
-                "full",
-                "workspace-write",
-                "readonly",
-              ],
+              supportedPermissionModes: ["full", "workspace-write", "readonly"],
             },
           },
         ],
@@ -866,88 +857,6 @@ describe("thread prompt history query", () => {
   });
 });
 
-describe("thread status version query", () => {
-  it("polls every two seconds and stops when unmounted", async () => {
-    vi.useFakeTimers();
-    let requestCount = 0;
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thread-1/status-version",
-        handler: () => {
-          requestCount += 1;
-          return jsonResponse({
-            source: "folder",
-            hash: `status-hash-${requestCount}`,
-          });
-        },
-      },
-    ]);
-    const { queryClient, wrapper } = createWrapper();
-
-    const { result, unmount } = renderHook(
-      () => useThreadStatusVersion("thread-1"),
-      { wrapper },
-    );
-
-    await vi.waitFor(() => {
-      expect(result.current.status).toBe("success");
-    });
-    expect(requestCount).toBe(1);
-
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(2_000);
-    });
-    expect(requestCount).toBe(2);
-    expect(
-      queryClient.getQueryData(threadStatusVersionQueryKey("thread-1")),
-    ).toEqual({ source: "folder", hash: "status-hash-2" });
-
-    unmount();
-
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(2_100);
-    });
-    expect(requestCount).toBe(2);
-  });
-});
-
-describe("thread status markdown preview query", () => {
-  it("loads STATUS.md through the existing storage preview route under the status hash", async () => {
-    installFetchRoutes([
-      {
-        pathname: "/api/v1/threads/thread-1/thread-storage/content",
-        handler: (request) => {
-          const url = new URL(request.url);
-          expect(url.searchParams.get("path")).toBe("STATUS.md");
-          return new Response("# Status\n", {
-            headers: { "content-type": "text/markdown" },
-          });
-        },
-      },
-    ]);
-    const { queryClient, wrapper } = createWrapper();
-
-    const { result } = renderHook(
-      () => useThreadStatusMarkdownPreview("thread-1", "status-hash-1"),
-      { wrapper },
-    );
-
-    await waitFor(() => {
-      expect(result.current.status).toBe("success");
-    });
-    expect(
-      queryClient.getQueryData(
-        threadStatusMarkdownPreviewQueryKey("thread-1", "status-hash-1"),
-      ),
-    ).toMatchObject({
-      kind: "text",
-      content: "# Status\n",
-      mimeType: "text/markdown",
-      path: "STATUS.md",
-    });
-  });
-});
-
 describe("thread host file preview query", () => {
   it("loads host file content lazily through the thread-scoped route", async () => {
     const hostPath = "/Users/me/notes/plan.md";
diff --git a/apps/app/src/hooks/queries/thread-queries.ts b/apps/app/src/hooks/queries/thread-queries.ts
index aa8529a56..e5fccb611 100644
--- a/apps/app/src/hooks/queries/thread-queries.ts
+++ b/apps/app/src/hooks/queries/thread-queries.ts
@@ -20,7 +20,6 @@ import type {
   ManagerTimelineView,
   ThreadPendingInteractionsResponse,
   ThreadResponse,
-  ThreadStatusVersionResponse,
   ThreadWithIncludesResponse,
   ThreadStorageFileListResponse,
   ThreadStoragePathListResponse,
@@ -57,8 +56,6 @@ import {
   threadStorageFilesQueryKey,
   threadStoragePathsQueryKey,
   threadStorageFilePreviewQueryKey,
-  threadStatusMarkdownPreviewQueryKey,
-  threadStatusVersionQueryKey,
   threadAppMarkdownPreviewQueryKey,
   threadAppQueryKey,
   threadAppsQueryKey,
@@ -67,7 +64,6 @@ import {
   type ArchivedThreadsKindFilter,
 } from "./query-keys";
 import { ARCHIVED_THREADS_PAGE_SIZE } from "./archived-threads-page-size";
-import { MANAGER_STATUS_MARKDOWN_FILE_PATH } from "@/lib/manager-status-storage";
 
 interface QueryOptions {
   enabled?: boolean;
@@ -76,7 +72,6 @@ interface QueryOptions {
 }
 
 const THREAD_LIST_STALE_TIME_MS = 10_000;
-const THREAD_STATUS_VERSION_REFETCH_INTERVAL_MS = 2_000;
 
 interface ThreadComposerBootstrapQueryOptions extends QueryOptions {
   environmentId?: string;
@@ -644,41 +639,6 @@ export function useThreadStorageFilePreview(
   });
 }
 
-export function useThreadStatusVersion(id: string, options?: QueryOptions) {
-  return useQuery<ThreadStatusVersionResponse>({
-    queryKey: threadStatusVersionQueryKey(id),
-    queryFn: ({ signal }) =>
-      api.getThreadStatusVersion(
-        requireThreadId(id, "useThreadStatusVersion"),
-        signal,
-      ),
-    enabled: (options?.enabled ?? true) && Boolean(id),
-    refetchInterval: THREAD_STATUS_VERSION_REFETCH_INTERVAL_MS,
-    refetchIntervalInBackground: false,
-    refetchOnWindowFocus: true,
-    staleTime: options?.staleTime,
-  });
-}
-
-export function useThreadStatusMarkdownPreview(
-  id: string,
-  versionHash: string | null | undefined,
-  options?: QueryOptions,
-) {
-  return useQuery<FilePreview>({
-    queryKey: threadStatusMarkdownPreviewQueryKey(id, versionHash),
-    queryFn: ({ signal }) =>
-      api.getThreadStorageFilePreview(
-        requireThreadId(id, "useThreadStatusMarkdownPreview"),
-        MANAGER_STATUS_MARKDOWN_FILE_PATH,
-        signal,
-      ),
-    enabled: (options?.enabled ?? true) && Boolean(id) && Boolean(versionHash),
-    refetchOnWindowFocus: false,
-    staleTime: options?.staleTime,
-  });
-}
-
 export function useThreadApps(id: string, options?: QueryOptions) {
   return useQuery<AppSummary[]>({
     queryKey: threadAppsQueryKey(id),
@@ -699,7 +659,11 @@ export function useThreadApp(
   return useQuery<AppDetail>({
     queryKey: threadAppQueryKey(id, appId ?? ""),
     queryFn: ({ signal }) =>
-      api.getThreadApp(requireThreadId(id, "useThreadApp"), appId ?? "", signal),
+      api.getThreadApp(
+        requireThreadId(id, "useThreadApp"),
+        appId ?? "",
+        signal,
+      ),
     enabled: (options?.enabled ?? true) && Boolean(id) && Boolean(appId),
     refetchOnMount: options?.refetchOnMount ?? true,
     refetchOnWindowFocus: false,
diff --git a/apps/app/src/hooks/realtime-cache-effects.test.ts b/apps/app/src/hooks/realtime-cache-effects.test.ts
index 8dfefb3e2..044a23a52 100644
--- a/apps/app/src/hooks/realtime-cache-effects.test.ts
+++ b/apps/app/src/hooks/realtime-cache-effects.test.ts
@@ -6,7 +6,6 @@ import {
   PROJECT_CHANGE_KINDS,
   THREAD_CHANGE_KINDS,
 } from "@bb/domain";
-import type { ThreadStatusVersionResponse } from "@bb/server-contract";
 import { createAppQueryClient } from "@/lib/query-client";
 import {
   archivedThreadsListQueryKey,
@@ -22,7 +21,7 @@ import {
   threadPromptHistoryQueryKey,
   threadQueryKey,
   threadTerminalsQueryKey,
-  threadStatusVersionQueryKey,
+  threadStorageFilePreviewQueryKey,
   threadTimelineQueryKey,
 } from "./queries/query-keys";
 import { createRealtimeCacheEffects } from "./realtime-cache-effects";
@@ -462,32 +461,43 @@ describe("createRealtimeCacheEffects", () => {
     effects.dispose();
   });
 
-  it("refetches active status version queries for thread storage changes", async () => {
+  it("refetches active thread storage preview queries for thread storage changes", async () => {
     vi.useFakeTimers();
     const { effects, queryClient } = createRealtimeEffectsTestContext();
     const threadKey = threadQueryKey("thr_1");
-    const statusVersionKey = threadStatusVersionQueryKey("thr_1");
-    const initialStatusVersion: ThreadStatusVersionResponse = {
-      source: "folder",
-      hash: "status-old",
+    const storagePreviewKey = threadStorageFilePreviewQueryKey(
+      "thr_1",
+      "notes.md",
+    );
+    const initialStoragePreview = {
+      kind: "text",
+      content: "old",
+      mimeType: "text/plain",
+      path: "notes.md",
+      url: "/old",
     };
-    const nextStatusVersion: ThreadStatusVersionResponse = {
-      source: "folder",
-      hash: "status-new",
+    const nextStoragePreview = {
+      kind: "text",
+      content: "new",
+      mimeType: "text/plain",
+      path: "notes.md",
+      url: "/new",
     };
     queryClient.setQueryData(threadKey, {
       id: "thr_1",
       environmentId: "env-1",
     });
-    queryClient.setQueryData(statusVersionKey, initialStatusVersion);
-    const statusVersionQueryFn = vi.fn(async () => nextStatusVersion);
-    const statusVersionObserver = new QueryObserver(queryClient, {
-      queryKey: statusVersionKey,
-      queryFn: statusVersionQueryFn,
+    queryClient.setQueryData(storagePreviewKey, initialStoragePreview);
+    const storagePreviewQueryFn = vi.fn(async () => nextStoragePreview);
+    const storagePreviewObserver = new QueryObserver(queryClient, {
+      queryKey: storagePreviewKey,
+      queryFn: storagePreviewQueryFn,
       staleTime: Infinity,
     });
-    const unsubscribeStatusVersion = statusVersionObserver.subscribe(() => {});
-    statusVersionQueryFn.mockClear();
+    const unsubscribeStoragePreview = storagePreviewObserver.subscribe(
+      () => {},
+    );
+    storagePreviewQueryFn.mockClear();
 
     effects.handleChanged({
       type: "changed",
@@ -497,12 +507,12 @@ describe("createRealtimeCacheEffects", () => {
     });
     await vi.advanceTimersByTimeAsync(250);
 
-    expect(statusVersionQueryFn).toHaveBeenCalledTimes(1);
-    expect(queryClient.getQueryData(statusVersionKey)).toEqual(
-      nextStatusVersion,
+    expect(storagePreviewQueryFn).toHaveBeenCalledTimes(1);
+    expect(queryClient.getQueryData(storagePreviewKey)).toEqual(
+      nextStoragePreview,
     );
 
-    unsubscribeStatusVersion();
+    unsubscribeStoragePreview();
     effects.dispose();
   });
 
diff --git a/apps/app/src/hooks/realtime-cache-registry.ts b/apps/app/src/hooks/realtime-cache-registry.ts
index 944d0dfdc..f85bc809e 100644
--- a/apps/app/src/hooks/realtime-cache-registry.ts
+++ b/apps/app/src/hooks/realtime-cache-registry.ts
@@ -50,7 +50,6 @@ import {
   threadStorageFilePreviewQueryKeyPrefix,
   threadStorageFilesForThreadQueryKeyPrefix,
   threadStoragePathsForThreadQueryKeyPrefix,
-  threadStatusVersionQueryKey,
   threadTimelineQueryKeyPrefix,
 } from "./queries/query-keys";
 
@@ -565,7 +564,6 @@ function dirtyThreadStorageQueriesForEnvironment({
     queryKeys.push(threadStorageFilesForThreadQueryKeyPrefix(threadId));
     queryKeys.push(threadStoragePathsForThreadQueryKeyPrefix(threadId));
     queryKeys.push(threadStorageFilePreviewQueryKeyPrefix(threadId));
-    queryKeys.push(threadStatusVersionQueryKey(threadId));
   }
   return queryKeys;
 }
diff --git a/apps/app/src/lib/api.ts b/apps/app/src/lib/api.ts
index 89d2b12c8..ca01d786e 100644
--- a/apps/app/src/lib/api.ts
+++ b/apps/app/src/lib/api.ts
@@ -53,7 +53,6 @@ import type {
   ThreadQueuedMessageListResponse,
   ThreadListResponse,
   ThreadResponse,
-  ThreadStatusVersionResponse,
   ThreadWithIncludesResponse,
   PathListIncludeQueryValue,
   BranchListQuery,
@@ -885,18 +884,6 @@ export async function getThreadStorageFilePreview(
   );
 }
 
-export async function getThreadStatusVersion(
-  id: string,
-  signal?: AbortSignal,
-): Promise<ThreadStatusVersionResponse> {
-  return request<ThreadStatusVersionResponse>(
-    apiClient.threads[":id"]["status-version"].$get(
-      { param: { id } },
-      requestOptions(signal),
-    ),
-  );
-}
-
 export async function listThreadApps(
   id: string,
   signal?: AbortSignal,
diff --git a/apps/app/src/lib/file-content-urls.ts b/apps/app/src/lib/file-content-urls.ts
index cb01284fd..31a87fcfe 100644
--- a/apps/app/src/lib/file-content-urls.ts
+++ b/apps/app/src/lib/file-content-urls.ts
@@ -35,16 +35,6 @@ export function buildThreadStorageRawContentUrl(
   return `/api/v1/threads/${encodeURIComponent(threadId)}/thread-storage/files/${encodePathSegments(path)}`;
 }
 
-export function buildThreadStatusContentUrl(
-  threadId: string,
-  hash?: string,
-): string {
-  const baseUrl = `/api/v1/threads/${encodeURIComponent(threadId)}/status/`;
-  return hash === undefined
-    ? baseUrl
-    : `${baseUrl}?v=${encodeURIComponent(hash)}`;
-}
-
 export function buildThreadAppEntryUrl(
   threadId: string,
   appId: string,
diff --git a/apps/app/src/lib/manager-status-storage.ts b/apps/app/src/lib/manager-status-storage.ts
deleted file mode 100644
index 5cd646c19..000000000
--- a/apps/app/src/lib/manager-status-storage.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-export const MANAGER_STATUS_FILE_PATH = "STATUS";
-export const MANAGER_STATUS_INDEX_FILE_PATH = "STATUS/index.html";
-export const MANAGER_STATUS_MARKDOWN_FILE_PATH = "STATUS.md";
-export const MANAGER_STATUS_HTML_FILE_PATH = "STATUS.html";
-
-export interface ManagerStorageFileEntry {
-  path: string;
-}
-
-export type ManagerStorageFiles = readonly ManagerStorageFileEntry[];
-
-export function isManagerStatusStorageFilePath(path: string): boolean {
-  return (
-    path === MANAGER_STATUS_FILE_PATH ||
-    path === MANAGER_STATUS_INDEX_FILE_PATH ||
-    path === MANAGER_STATUS_MARKDOWN_FILE_PATH ||
-    path === MANAGER_STATUS_HTML_FILE_PATH
-  );
-}
-
-export function resolveManagerStatusStorageTabPath(path: string): string {
-  return isManagerStatusStorageFilePath(path)
-    ? MANAGER_STATUS_FILE_PATH
-    : path;
-}
-
-export function resolvePinnedManagerStorageFilePath(
-  _storageFiles: ManagerStorageFiles | undefined,
-): string {
-  return MANAGER_STATUS_FILE_PATH;
-}
diff --git a/apps/app/src/views/thread-detail/ThreadDetailView.tsx b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
index 323dcc1db..589e94f41 100644
--- a/apps/app/src/views/thread-detail/ThreadDetailView.tsx
+++ b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
@@ -297,11 +297,11 @@ export function ThreadDetailView() {
     closeWorkspaceFileTab,
     isNewTabActive,
     openNewTab,
+    openApp,
     openHostFile,
     openStorageFile,
     openWorkspaceFile,
     orderedSecondaryFileTabs,
-    pinnedStorageFilePath,
     selectFileSearchResult,
   } = useThreadFileTabs({
     apps: threadAppsQuery.data,
@@ -321,7 +321,7 @@ export function ThreadDetailView() {
       return;
     }
     if (isManagerThread && activeFixedSecondaryTab === null) {
-      openStorageFile(pinnedStorageFilePath);
+      openApp(STATUS_APP_ID);
       return;
     }
     toggleDefaultPersistedSecondaryPanel();
@@ -329,8 +329,7 @@ export function ThreadDetailView() {
     activeFixedSecondaryTab,
     fixedPanelTabsState.secondary.isOpen,
     isManagerThread,
-    openStorageFile,
-    pinnedStorageFilePath,
+    openApp,
     setThreadSecondaryPanel,
     toggleDefaultPersistedSecondaryPanel,
   ]);
@@ -1149,9 +1148,7 @@ export function ThreadDetailView() {
     <ThreadStorageFilePreviewTabContent
       activePath={activeStorageFilePath}
       copyPath={storageFileCopyPath}
-      isManagerThread={isManagerThread}
       onOpenInEditor={handleOpenStorageFileInEditor}
-      pinnedPath={pinnedStorageFilePath}
       threadId={thread.id}
     />
   ) : undefined;
diff --git a/apps/app/src/views/thread-detail/threadLocalFileHtmlPreviewRouting.test.tsx b/apps/app/src/views/thread-detail/threadLocalFileHtmlPreviewRouting.test.tsx
index 4d0365ddf..b83a59c92 100644
--- a/apps/app/src/views/thread-detail/threadLocalFileHtmlPreviewRouting.test.tsx
+++ b/apps/app/src/views/thread-detail/threadLocalFileHtmlPreviewRouting.test.tsx
@@ -13,7 +13,6 @@ import {
   HostFilePreviewTabContent,
   ThreadStorageFilePreviewTabContent,
 } from "@/components/secondary-panel/ThreadSecondaryPanelTabContent";
-import { MANAGER_STATUS_FILE_PATH } from "@/components/secondary-panel/managerStorage";
 import { useThreadStorageViewer } from "@/components/secondary-panel/useThreadStorageViewer";
 import type { ThreadTimelineLocalFileLink } from "@/components/thread/timeline";
 import { MarkdownPreview } from "@/components/ui/markdown-preview";
@@ -123,8 +122,6 @@ function MarkdownHtmlPreviewHarness({
       {openedFile?.kind === "thread-storage" ? (
         <ThreadStorageFilePreviewTabContent
           activePath={openedFile.path}
-          isManagerThread
-          pinnedPath={MANAGER_STATUS_FILE_PATH}
           threadId={THREAD_ID}
         />
       ) : null}
@@ -225,8 +222,6 @@ function PanelClosedThreadStorageMarkdownLinkHarness({
       {openedFile?.kind === "thread-storage" ? (
         <ThreadStorageFilePreviewTabContent
           activePath={openedFile.path}
-          isManagerThread
-          pinnedPath={MANAGER_STATUS_FILE_PATH}
           threadId={THREAD_ID}
         />
       ) : null}
diff --git a/apps/cli/src/__tests__/command-output.test.ts b/apps/cli/src/__tests__/command-output.test.ts
index b64008599..a92a9226b 100644
--- a/apps/cli/src/__tests__/command-output.test.ts
+++ b/apps/cli/src/__tests__/command-output.test.ts
@@ -401,14 +401,14 @@ describe("CLI command output contracts", () => {
     vi.unstubAllEnvs();
   });
 
-  it("bb guide styling prints the styling chapter", async () => {
+  it("bb guide styling redirects to the app chapter", async () => {
     await runCommand(["guide", "styling"], registerGuideCommand);
 
     const output = collectLogPayloads(vi.mocked(console.log)).join("\n");
     expect(output.trim().length).toBeGreaterThan(0);
-    expect(output).toContain("Status styling");
+    expect(output).toContain("Apps");
+    expect(output).toContain("Styling:");
     expect(output).toContain("https://cdn.tailwindcss.com");
-    expect(output).toContain("--background: oklch(0.9551 0 0);");
     expect(output).toContain("@media (prefers-color-scheme: dark)");
   });
 
@@ -434,19 +434,18 @@ describe("CLI command output contracts", () => {
     expect(output).not.toContain("~/.bb/manager-templates");
     expect(output).not.toContain("~/.bb-dev/manager-templates");
     expect(output).toContain("bb manager hire --template sawyer-next");
-    expect(output).toContain("Only top-level regular files are copied");
+    expect(output).toContain("recursively copies every regular file");
   });
 
-  it("bb guide status-state prints the STATUS state chapter", async () => {
-    await runCommand(["guide", "status-state"], registerGuideCommand);
+  it("bb guide app prints the app chapter", async () => {
+    await runCommand(["guide", "app"], registerGuideCommand);
 
     const output = collectLogPayloads(vi.mocked(console.log)).join("\n");
     expect(output.trim().length).toBeGreaterThan(0);
-    expect(output).toContain("STATUS state");
-    expect(output).toContain("window.bbStatusState");
-    expect(output).toContain("Sending a message to the manager");
-    expect(output).toContain("window.bbThreadTell(text)");
-    expect(output).toContain("$BB_THREAD_STORAGE/STATUS-data");
+    expect(output).toContain("Apps");
+    expect(output).toContain("apps/status/data/state.json");
+    expect(output).toContain("window.bb.data");
+    expect(output).toContain("bb app list --self");
   });
 
   it("bb guide unknown chapter lists styling in available chapters", async () => {
@@ -457,7 +456,7 @@ describe("CLI command output contracts", () => {
     const errorOutput = collectLogLines(vi.mocked(console.error)).join("\n");
     expect(errorOutput).toContain("Unknown guide chapter 'missing'");
     expect(errorOutput).toContain(
-      "Available: threads, environments, managers, manager-templates, status-state, providers, projects, hosts, styling, async.",
+      "Available: threads, environments, managers, manager-templates, app, providers, projects, hosts, styling, async.",
     );
   });
 
diff --git a/apps/cli/src/commands/guide.ts b/apps/cli/src/commands/guide.ts
index 04dc40b84..ec9a97cf5 100644
--- a/apps/cli/src/commands/guide.ts
+++ b/apps/cli/src/commands/guide.ts
@@ -9,11 +9,11 @@ const guideChapters: Record<string, TemplateId> = {
   environments: "bbGuideEnvironments",
   managers: "bbGuideManagers",
   "manager-templates": "bbGuideManagerTemplates",
-  "status-state": "bbGuideStatusState",
+  app: "bbGuideApp",
   providers: "bbGuideProviders",
   projects: "bbGuideProjects",
   hosts: "bbGuideHosts",
-  styling: "bbGuideStyling",
+  styling: "bbGuideApp",
   async: "bbGuideAsync",
 };
 
diff --git a/apps/host-daemon/src/app.ts b/apps/host-daemon/src/app.ts
index 96d248d82..7142cbe93 100644
--- a/apps/host-daemon/src/app.ts
+++ b/apps/host-daemon/src/app.ts
@@ -1,8 +1,5 @@
 import path from "node:path";
-import {
-  CommandRouter,
-  isStatusDataSetCommandResultNotification,
-} from "./command-router.js";
+import { CommandRouter } from "./command-router.js";
 import { createDaemon, type HostDaemon } from "./daemon.js";
 import {
   createEventBuffer,
@@ -35,7 +32,6 @@ import {
 import { createReplayCaptureService } from "@bb/replay-capture/writer";
 import { createServerClient } from "./server-client.js";
 import { AppDataChangeReporter } from "./app-data-change-reporter.js";
-import { StatusDataChangeReporter } from "./status-data-change-reporter.js";
 import {
   ServerConnection,
   type CreateReconnectingWebSocket,
@@ -373,11 +369,6 @@ export async function createHostDaemonApp(
     reportEnvironmentChange: (change) =>
       serverClient.postEnvironmentChange(change),
   });
-  const statusDataChangeReporter = new StatusDataChangeReporter({
-    logger: options.logger,
-    postStatusDataChange: (payload) =>
-      serverClient.postStatusDataChange(payload),
-  });
   const appDataChangeReporter = new AppDataChangeReporter({
     logger: options.logger,
     postAppDataChange: (payload) => serverClient.postAppDataChange(payload),
@@ -511,13 +502,6 @@ export async function createHostDaemonApp(
       replayCapture?.recordRuntimeCaptureEntry(entry);
     },
     onEvent: ({ environmentId, event }) => {
-      const threadStatusDataTarget = {
-        threadId: event.threadId,
-        threadStoragePath: path.join(threadStorageRootPath, event.threadId),
-      };
-      statusDataChangeReporter.trackThread({
-        threadId: event.threadId,
-      });
       try {
         eventBuffer.push({
           threadId: event.threadId,
@@ -542,9 +526,6 @@ export async function createHostDaemonApp(
         threadId: event.threadId,
         event,
       });
-      if (event.type === "turn/completed") {
-        void statusDataChangeReporter.reconcileThread(threadStatusDataTarget);
-      }
     },
     onThreadStorageChanged: ({ environmentId }) => {
       environmentChangeReporter.queue({
@@ -552,9 +533,6 @@ export async function createHostDaemonApp(
         change: "thread-storage-changed",
       });
     },
-    onThreadStatusDataChanged: (change) => {
-      void statusDataChangeReporter.observe(change);
-    },
     onThreadAppDataChanged: (change) => {
       void appDataChangeReporter.observe(change);
     },
@@ -705,21 +683,6 @@ export async function createHostDaemonApp(
       emit: (event) => eventBuffer.push(event),
       flush: () => eventBuffer.flush(),
     },
-    onStatusDataCommandResult: (notification) => {
-      if (isStatusDataSetCommandResultNotification(notification)) {
-        statusDataChangeReporter.recordCommandSet({
-          threadId: notification.command.threadId,
-          key: notification.result.key,
-          value: notification.result.value,
-          version: notification.result.version,
-        });
-        return;
-      }
-      statusDataChangeReporter.recordCommandDelete({
-        threadId: notification.command.threadId,
-        key: notification.result.key,
-      });
-    },
     reportResult: async (report) => {
       await serverClient.reportCommandResult(report);
     },
@@ -757,12 +720,6 @@ export async function createHostDaemonApp(
       runtimeManager.replaceTrackedThreadStorageTargets(
         session.trackedThreadTargets,
       );
-      void statusDataChangeReporter.replaceTrackedThreads({
-        targets: session.trackedThreadTargets.map((target) => ({
-          threadId: target.threadId,
-          threadStoragePath: path.join(threadStorageRootPath, target.threadId),
-        })),
-      });
       void appDataChangeReporter.replaceTrackedThreads({
         targets: session.trackedThreadTargets.map((target) => ({
           threadId: target.threadId,
diff --git a/apps/host-daemon/src/command-dispatch.ts b/apps/host-daemon/src/command-dispatch.ts
index fa9c3f2c8..f93ac13b7 100644
--- a/apps/host-daemon/src/command-dispatch.ts
+++ b/apps/host-daemon/src/command-dispatch.ts
@@ -25,7 +25,6 @@ import {
   readHostFile,
   readHostFileMetadata,
   readHostRelativeFile,
-  readHostStatusVersion,
   writeHostRelativeFile,
 } from "./command-handlers/host-files.js";
 import { resolveInteractiveRequest } from "./command-handlers/interactive.js";
@@ -40,12 +39,6 @@ import {
   transcribeCodexVoice,
 } from "./codex-chatgpt-client.js";
 import { listManagerTemplatesCommand } from "./command-handlers/manager-templates.js";
-import {
-  deleteHostStatusData,
-  listHostStatusData,
-  readHostStatusData,
-  writeHostStatusData,
-} from "./command-handlers/status-data.js";
 import {
   ensureThreadRuntime,
   handleThreadDeleted,
@@ -294,38 +287,6 @@ const commandHandlers: CommandHandlerMap = {
     command: Extract<HostDaemonCommand, { type: "host.file_metadata" }>,
     _options: CommandDispatchOptions,
   ) => readHostFileMetadata(command),
-  "host.status_version": async (
-    command: Extract<HostDaemonCommand, { type: "host.status_version" }>,
-    _options: CommandDispatchOptions,
-  ) => readHostStatusVersion(command),
-  "host.status_data.list": async (
-    command: Extract<HostDaemonCommand, { type: "host.status_data.list" }>,
-    options: CommandDispatchOptions,
-  ) =>
-    listHostStatusData(command, {
-      threadStorageRootPath: options.threadStorageRootPath,
-    }),
-  "host.status_data.get": async (
-    command: Extract<HostDaemonCommand, { type: "host.status_data.get" }>,
-    options: CommandDispatchOptions,
-  ) =>
-    readHostStatusData(command, {
-      threadStorageRootPath: options.threadStorageRootPath,
-    }),
-  "host.status_data.set": async (
-    command: Extract<HostDaemonCommand, { type: "host.status_data.set" }>,
-    options: CommandDispatchOptions,
-  ) =>
-    writeHostStatusData(command, {
-      threadStorageRootPath: options.threadStorageRootPath,
-    }),
-  "host.status_data.delete": async (
-    command: Extract<HostDaemonCommand, { type: "host.status_data.delete" }>,
-    options: CommandDispatchOptions,
-  ) =>
-    deleteHostStatusData(command, {
-      threadStorageRootPath: options.threadStorageRootPath,
-    }),
   "host.read_file": async (
     command: Extract<HostDaemonCommand, { type: "host.read_file" }>,
     _options: CommandDispatchOptions,
diff --git a/apps/host-daemon/src/command-handlers/host-files.test.ts b/apps/host-daemon/src/command-handlers/host-files.test.ts
index c19278b5e..7e3d356b1 100644
--- a/apps/host-daemon/src/command-handlers/host-files.test.ts
+++ b/apps/host-daemon/src/command-handlers/host-files.test.ts
@@ -14,7 +14,6 @@ import {
   readHostFile,
   readHostFileMetadata,
   readHostRelativeFile,
-  readHostStatusVersion,
   writeHostRelativeFile,
   deleteHostRelativeFile,
   deleteHostRelativePath,
@@ -22,24 +21,6 @@ import {
 
 const execFileAsync = promisify(execFile);
 const tempDirs: string[] = [];
-const EXPECTED_UNREADABLE_DIRECTORY_HASH_SENTINEL = "unreadable-directory";
-
-type ExpectedStatusVersionSource = "folder" | "html" | "md" | "empty";
-type ExpectedStatusVersionHashEntry =
-  | ExpectedStatusVersionFileHashEntry
-  | ExpectedStatusVersionUnreadableHashEntry;
-
-interface ExpectedStatusVersionFileHashEntry {
-  kind: "file";
-  modifiedAtNs: bigint;
-  path: string;
-  sizeBytes: bigint;
-}
-
-interface ExpectedStatusVersionUnreadableHashEntry {
-  kind: "unreadable";
-  path: string;
-}
 
 async function makeTempDir(prefix: string): Promise<string> {
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
@@ -87,56 +68,6 @@ async function captureReadHostRelativeFileError(
   throw new Error("Expected readHostRelativeFile to fail");
 }
 
-function makeStatusVersionCommand(
-  storageRootPath: string,
-): CommandOf<"host.status_version"> {
-  return {
-    type: "host.status_version",
-    sources: [
-      {
-        source: "folder",
-        rootPath: path.join(storageRootPath, "STATUS"),
-        indexPath: "index.html",
-        dotfiles: "deny",
-      },
-      {
-        source: "html",
-        rootPath: storageRootPath,
-        path: "STATUS.html",
-        dotfiles: "allow",
-      },
-      {
-        source: "md",
-        rootPath: storageRootPath,
-        path: "STATUS.md",
-        dotfiles: "allow",
-      },
-    ],
-  };
-}
-
-function hashExpectedStatusVersion(
-  source: ExpectedStatusVersionSource,
-  entries: readonly ExpectedStatusVersionHashEntry[],
-): string {
-  const hash = createHash("sha256");
-  hash.update(`source:${source}\n`);
-  for (const entry of [...entries].sort((left, right) =>
-    left.path.localeCompare(right.path),
-  )) {
-    if (entry.kind === "unreadable") {
-      hash.update(
-        `${entry.path}\0${EXPECTED_UNREADABLE_DIRECTORY_HASH_SENTINEL}\n`,
-      );
-      continue;
-    }
-    hash.update(
-      `${entry.path}\0${entry.sizeBytes.toString()}\0${entry.modifiedAtNs.toString()}\n`,
-    );
-  }
-  return hash.digest("hex");
-}
-
 afterEach(async () => {
   while (tempDirs.length > 0) {
     const dir = tempDirs.pop();
@@ -191,7 +122,7 @@ describe("readHostFile (no ref — disk read)", () => {
 
   it("marks missing targets under an existing root as expected", async () => {
     const repoPath = await initRepo();
-    const missingPath = path.join(repoPath, "STATUS.md");
+    const missingPath = path.join(repoPath, "notes.md");
     const thrown = await captureReadHostFileError({
       type: "host.read_file",
       path: missingPath,
@@ -226,7 +157,7 @@ describe("readHostFile (no ref — disk read)", () => {
   it("marks missing roots as expected", async () => {
     const parentPath = await makeTempDir("bb-host-files-missing-root-");
     const rootPath = path.join(parentPath, "missing-root");
-    const missingPath = path.join(rootPath, "STATUS.md");
+    const missingPath = path.join(rootPath, "notes.md");
     const thrown = await captureReadHostFileError({
       type: "host.read_file",
       path: missingPath,
@@ -314,23 +245,23 @@ describe("readHostFileMetadata", () => {
 describe("writeHostRelativeFile and deleteHostRelativeFile", () => {
   it("writes JSON bytes beneath the root and returns a content hash", async () => {
     const rootPath = await makeTempDir("bb-host-relative-write-");
-    const content = "{\"ok\":true}\n";
+    const content = '{"ok":true}\n';
     const result = await writeHostRelativeFile({
       type: "host.write_file_relative",
       rootPath,
-      path: "STATUS-data/tasks.json",
+      path: "apps/status/data/state.json",
       dotfiles: "deny",
       content,
       contentEncoding: "utf8",
     });
 
     expect(result).toMatchObject({
-      path: "STATUS-data/tasks.json",
+      path: "apps/status/data/state.json",
       hash: createHash("sha256").update(content).digest("hex"),
       sizeBytes: Buffer.byteLength(content),
     });
     await expect(
-      fs.readFile(path.join(rootPath, "STATUS-data/tasks.json"), "utf8"),
+      fs.readFile(path.join(rootPath, "apps/status/data/state.json"), "utf8"),
     ).resolves.toBe(content);
   });
 
@@ -410,9 +341,9 @@ describe("writeHostRelativeFile and deleteHostRelativeFile", () => {
       deleted: true,
       previousHash: written.hash,
     });
-    await expect(fs.stat(path.join(rootPath, "tasks.json"))).rejects.toMatchObject(
-      { code: "ENOENT" },
-    );
+    await expect(
+      fs.stat(path.join(rootPath, "tasks.json")),
+    ).rejects.toMatchObject({ code: "ENOENT" });
 
     await expect(
       deleteHostRelativeFile({
@@ -473,174 +404,6 @@ describe("writeHostRelativeFile and deleteHostRelativeFile", () => {
   });
 });
 
-describe("readHostStatusVersion", () => {
-  it("hashes folder mode from stat metadata and changes on file mutations", async () => {
-    const storageRootPath = await makeTempDir("bb-status-version-test-");
-    const statusRootPath = path.join(storageRootPath, "STATUS");
-    await fs.mkdir(statusRootPath);
-    const indexPath = path.join(statusRootPath, "index.html");
-    await fs.writeFile(indexPath, "<h1>Ready</h1>", "utf8");
-
-    const command = makeStatusVersionCommand(storageRootPath);
-    const initial = await readHostStatusVersion(command);
-    const unchanged = await readHostStatusVersion(command);
-
-    expect(initial.source).toBe("folder");
-    expect(unchanged.hash).toBe(initial.hash);
-
-    const assetPath = path.join(statusRootPath, "logo.png");
-    await fs.writeFile(assetPath, "asset", "utf8");
-    const afterAdd = await readHostStatusVersion(command);
-    expect(afterAdd.hash).not.toBe(initial.hash);
-
-    await fs.rm(assetPath);
-    const afterRemove = await readHostStatusVersion(command);
-    expect(afterRemove.hash).not.toBe(afterAdd.hash);
-
-    const bumpedTime = new Date(Date.now() + 10_000);
-    await fs.utimes(indexPath, bumpedTime, bumpedTime);
-    const afterMtime = await readHostStatusVersion(command);
-    expect(afterMtime.hash).not.toBe(afterRemove.hash);
-
-    await fs.writeFile(indexPath, "<h1>Ready now</h1>", "utf8");
-    const afterSize = await readHostStatusVersion(command);
-    expect(afterSize.hash).not.toBe(afterMtime.hash);
-  });
-
-  it("tracks source precedence across folder, html, md, and empty modes", async () => {
-    const storageRootPath = await makeTempDir("bb-status-version-precedence-");
-    const command = makeStatusVersionCommand(storageRootPath);
-
-    const empty = await readHostStatusVersion(command);
-    expect(empty.source).toBe("empty");
-
-    await fs.writeFile(
-      path.join(storageRootPath, "STATUS.md"),
-      "# Status",
-      "utf8",
-    );
-    const markdown = await readHostStatusVersion(command);
-    expect(markdown.source).toBe("md");
-    expect(markdown.hash).not.toBe(empty.hash);
-
-    await fs.writeFile(
-      path.join(storageRootPath, "STATUS.html"),
-      "<h1>Status</h1>",
-      "utf8",
-    );
-    const html = await readHostStatusVersion(command);
-    expect(html.source).toBe("html");
-    expect(html.hash).not.toBe(markdown.hash);
-
-    const statusRootPath = path.join(storageRootPath, "STATUS");
-    await fs.mkdir(statusRootPath);
-    await fs.writeFile(
-      path.join(statusRootPath, "index.html"),
-      "<h1>Folder</h1>",
-      "utf8",
-    );
-    const folder = await readHostStatusVersion(command);
-    expect(folder.source).toBe("folder");
-    expect(folder.hash).not.toBe(html.hash);
-  });
-
-  it("hashes single-file modes from stat metadata", async () => {
-    const storageRootPath = await makeTempDir("bb-status-version-single-file-");
-    const command = makeStatusVersionCommand(storageRootPath);
-    const statusHtmlPath = path.join(storageRootPath, "STATUS.html");
-
-    await fs.writeFile(statusHtmlPath, "<h1>Status</h1>", "utf8");
-    const initial = await readHostStatusVersion(command);
-    const unchanged = await readHostStatusVersion(command);
-
-    expect(initial.source).toBe("html");
-    expect(unchanged.hash).toBe(initial.hash);
-
-    const bumpedTime = new Date(Date.now() + 10_000);
-    await fs.utimes(statusHtmlPath, bumpedTime, bumpedTime);
-    const afterMtime = await readHostStatusVersion(command);
-    expect(afterMtime.hash).not.toBe(initial.hash);
-
-    await fs.writeFile(statusHtmlPath, "<h1>Status changed</h1>", "utf8");
-    const afterSize = await readHostStatusVersion(command);
-    expect(afterSize.hash).not.toBe(afterMtime.hash);
-  });
-
-  it("does not hash dotfiles or symlink escapes under STATUS", async () => {
-    const storageRootPath = await makeTempDir("bb-status-version-hidden-");
-    const statusRootPath = path.join(storageRootPath, "STATUS");
-    await fs.mkdir(statusRootPath);
-    await fs.writeFile(
-      path.join(statusRootPath, "index.html"),
-      "ready",
-      "utf8",
-    );
-    const command = makeStatusVersionCommand(storageRootPath);
-    const initial = await readHostStatusVersion(command);
-
-    await fs.writeFile(path.join(statusRootPath, ".env"), "secret", "utf8");
-    const afterDotfile = await readHostStatusVersion(command);
-    expect(afterDotfile.hash).toBe(initial.hash);
-
-    const outsidePath = path.join(storageRootPath, "outside.txt");
-    const symlinkPath = path.join(statusRootPath, "outside-link.txt");
-    await fs.writeFile(outsidePath, "outside", "utf8");
-    await fs.symlink(outsidePath, symlinkPath);
-    const afterSymlinkEscape = await readHostStatusVersion(command);
-    expect(afterSymlinkEscape.hash).toBe(initial.hash);
-  });
-
-  it("keeps folder mode and marks unreadable child directories in the hash", async () => {
-    const storageRootPath = await makeTempDir(
-      "bb-status-version-unreadable-child-",
-    );
-    const statusRootPath = path.join(storageRootPath, "STATUS");
-    const unreadableDirPath = path.join(statusRootPath, "private");
-    await fs.mkdir(unreadableDirPath, { recursive: true });
-    const indexPath = path.join(statusRootPath, "index.html");
-    await fs.writeFile(indexPath, "<h1>Ready</h1>", "utf8");
-    await fs.writeFile(
-      path.join(unreadableDirPath, "nested.txt"),
-      "secret",
-      "utf8",
-    );
-
-    const command = makeStatusVersionCommand(storageRootPath);
-    const indexStat = await fs.stat(indexPath, { bigint: true });
-    let unreadableHash = "";
-
-    await fs.chmod(unreadableDirPath, 0);
-    try {
-      const unreadable = await readHostStatusVersion(command);
-      const unreadableAgain = await readHostStatusVersion(command);
-
-      expect(unreadable.source).toBe("folder");
-      expect(unreadableAgain.hash).toBe(unreadable.hash);
-      expect(unreadable.hash).toBe(
-        hashExpectedStatusVersion("folder", [
-          {
-            kind: "file",
-            modifiedAtNs: indexStat.mtimeNs,
-            path: "index.html",
-            sizeBytes: indexStat.size,
-          },
-          {
-            kind: "unreadable",
-            path: "private",
-          },
-        ]),
-      );
-      unreadableHash = unreadable.hash;
-    } finally {
-      await fs.chmod(unreadableDirPath, 0o700);
-    }
-
-    const restored = await readHostStatusVersion(command);
-    expect(restored.source).toBe("folder");
-    expect(restored.hash).not.toBe(unreadableHash);
-  });
-});
-
 describe("readHostFile (with ref — git history read)", () => {
   it("rejects ref reads without rootPath", async () => {
     const repoPath = await initRepo();
diff --git a/apps/host-daemon/src/command-handlers/host-files.ts b/apps/host-daemon/src/command-handlers/host-files.ts
index 2b766b3ab..98c9901cf 100644
--- a/apps/host-daemon/src/command-handlers/host-files.ts
+++ b/apps/host-daemon/src/command-handlers/host-files.ts
@@ -21,7 +21,6 @@ import {
   writeRootRelativeFile,
 } from "./file-write.js";
 import { resolveNonSymlinkDirectoryPath } from "./root-path.js";
-import { readHostStatusVersion } from "./status-version.js";
 
 /**
  * Conservative subset of git's ref name grammar. We only need to refuse
@@ -157,8 +156,6 @@ export async function readHostFileMetadata(
   });
 }
 
-export { readHostStatusVersion };
-
 export async function readHostRelativeFile(
   command: CommandOf<"host.read_file_relative">,
 ): Promise<HostDaemonCommandResult<"host.read_file_relative">> {
diff --git a/apps/host-daemon/src/command-handlers/manager-templates.test.ts b/apps/host-daemon/src/command-handlers/manager-templates.test.ts
index 6231f314f..150babca1 100644
--- a/apps/host-daemon/src/command-handlers/manager-templates.test.ts
+++ b/apps/host-daemon/src/command-handlers/manager-templates.test.ts
@@ -32,9 +32,9 @@ async function writeActiveFile(dataDir: string, name: string): Promise<void> {
 
 afterEach(async () => {
   await Promise.all(
-    tempDirs.splice(0).map((dir) =>
-      fs.rm(dir, { recursive: true, force: true }),
-    ),
+    tempDirs
+      .splice(0)
+      .map((dir) => fs.rm(dir, { recursive: true, force: true })),
   );
 });
 
@@ -52,7 +52,7 @@ describe("listManagerTemplates", () => {
     await writeTemplate({
       dataDir,
       name: "default",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     await fs.mkdir(path.join(dataDir, "manager-templates", "empty-set"), {
       recursive: true,
@@ -68,7 +68,7 @@ describe("listManagerTemplates", () => {
     await writeTemplate({
       dataDir,
       name: "default",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     const root = path.join(dataDir, "manager-templates");
     await fs.writeFile(path.join(root, "stray-file"), "ignored", "utf8");
@@ -85,12 +85,12 @@ describe("listManagerTemplates", () => {
     await writeTemplate({
       dataDir,
       name: "default",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     await writeTemplate({
       dataDir,
       name: "sawyer-next",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     await writeActiveFile(dataDir, "sawyer-next");
     expect(await listManagerTemplates({ dataDir })).toEqual({
@@ -104,7 +104,7 @@ describe("listManagerTemplates", () => {
     await writeTemplate({
       dataDir,
       name: "default",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     await fs.writeFile(
       path.join(dataDir, "manager-templates", "active"),
@@ -122,7 +122,7 @@ describe("listManagerTemplates", () => {
     await writeTemplate({
       dataDir,
       name: "default",
-      files: { "STATUS.html": "ok" },
+      files: { "PREFERENCES.md": "ok" },
     });
     await writeActiveFile(dataDir, "ghost-template");
     expect(await listManagerTemplates({ dataDir })).toEqual({
diff --git a/apps/host-daemon/src/command-handlers/status-data.test.ts b/apps/host-daemon/src/command-handlers/status-data.test.ts
deleted file mode 100644
index 3d446a024..000000000
--- a/apps/host-daemon/src/command-handlers/status-data.test.ts
+++ /dev/null
@@ -1,419 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  CommandDispatchError,
-  isExpectedCommandDispatchError,
-  type CommandOf,
-} from "../command-dispatch-support.js";
-import {
-  deleteHostStatusData,
-  listHostStatusData,
-  readHostStatusData,
-  writeHostStatusData,
-} from "./status-data.js";
-import { NON_IMAGE_FILE_SIZE_LIMIT_BYTES } from "./file-read.js";
-
-const tempDirs: string[] = [];
-const THREAD_ID = "thr_status_data";
-
-interface TestThreadStorage {
-  threadStoragePath: string;
-  threadStorageRootPath: string;
-}
-
-async function makeTempDir(prefix: string): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function sha256Text(content: string): string {
-  return createHash("sha256").update(content).digest("hex");
-}
-
-function listCommand(threadId = THREAD_ID): CommandOf<"host.status_data.list"> {
-  return {
-    type: "host.status_data.list",
-    threadId,
-  };
-}
-
-function getCommand(
-  threadId = THREAD_ID,
-  key = "tasks",
-): CommandOf<"host.status_data.get"> {
-  return {
-    type: "host.status_data.get",
-    threadId,
-    key,
-  };
-}
-
-function commandOptions(threadStorageRootPath: string) {
-  return { threadStorageRootPath };
-}
-
-async function makeThreadStorage(prefix: string): Promise<TestThreadStorage> {
-  const threadStorageRootPath = await makeTempDir(prefix);
-  return {
-    threadStoragePath: path.join(threadStorageRootPath, THREAD_ID),
-    threadStorageRootPath,
-  };
-}
-
-async function captureReadStatusDataError(
-  command: CommandOf<"host.status_data.get">,
-  threadStorageRootPath: string,
-): Promise<unknown> {
-  try {
-    await readHostStatusData(command, commandOptions(threadStorageRootPath));
-  } catch (error) {
-    return error;
-  }
-
-  throw new Error("Expected readHostStatusData to fail");
-}
-
-afterEach(async () => {
-  while (tempDirs.length > 0) {
-    const dir = tempDirs.pop();
-    if (dir) {
-      await fs.rm(dir, { recursive: true, force: true });
-    }
-  }
-});
-
-describe("host STATUS-data commands", () => {
-  it("lists and reads valid top-level STATUS-data JSON files", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-list-");
-    const statusDataRootPath = path.join(threadStoragePath, "STATUS-data");
-    const tasksJson = '["one"]\n';
-    const prefsJson = '{"compact":true}\n';
-    await fs.mkdir(path.join(statusDataRootPath, "nested"), {
-      recursive: true,
-    });
-    await fs.writeFile(path.join(statusDataRootPath, "tasks.json"), tasksJson);
-    await fs.writeFile(path.join(statusDataRootPath, "prefs.json"), prefsJson);
-    await fs.writeFile(path.join(statusDataRootPath, "bad.name.json"), "1\n");
-    await fs.writeFile(
-      path.join(statusDataRootPath, "nested", "ignored.json"),
-      "true\n",
-    );
-
-    await expect(
-      listHostStatusData(listCommand(), commandOptions(threadStorageRootPath)),
-    ).resolves.toEqual({
-      values: {
-        tasks: ["one"],
-        prefs: { compact: true },
-      },
-      versions: {
-        tasks: sha256Text(tasksJson),
-        prefs: sha256Text(prefsJson),
-      },
-      hash: sha256Text(
-        `prefs\0${sha256Text(prefsJson)}\n` +
-          `tasks\0${sha256Text(tasksJson)}\n`,
-      ),
-    });
-
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).resolves.toEqual({
-      key: "tasks",
-      value: ["one"],
-      version: sha256Text(tasksJson),
-      sizeBytes: Buffer.byteLength(tasksJson),
-      modifiedAtMs: expect.any(Number),
-    });
-  });
-
-  it("writes canonical JSON and returns previous value metadata", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-write-");
-    const previousValue = [{ id: "task-1", title: "Review" }];
-    const nextValue = { compact: true, selected: null };
-    const previousJson = `${JSON.stringify(previousValue, null, 2)}\n`;
-    const nextJson = `${JSON.stringify(nextValue, null, 2)}\n`;
-
-    await expect(
-      writeHostStatusData(
-        {
-          type: "host.status_data.set",
-          threadId: THREAD_ID,
-          key: "tasks",
-          value: previousValue,
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toMatchObject({
-      key: "tasks",
-      value: previousValue,
-      version: sha256Text(previousJson),
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    });
-
-    await expect(
-      writeHostStatusData(
-        {
-          type: "host.status_data.set",
-          threadId: THREAD_ID,
-          key: "tasks",
-          value: nextValue,
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toMatchObject({
-      key: "tasks",
-      value: nextValue,
-      version: sha256Text(nextJson),
-      previousValue,
-      previousValuePresent: true,
-      previousVersion: sha256Text(previousJson),
-    });
-
-    await expect(
-      fs.readFile(
-        path.join(threadStoragePath, "STATUS-data", "tasks.json"),
-        "utf8",
-      ),
-    ).resolves.toBe(nextJson);
-  });
-
-  it("deletes values idempotently and preserves JSON null as a previous value", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-delete-");
-    const nullJson = "null\n";
-    await writeHostStatusData(
-      {
-        type: "host.status_data.set",
-        threadId: THREAD_ID,
-        key: "tasks",
-        value: null,
-      },
-      commandOptions(threadStorageRootPath),
-    );
-
-    await expect(
-      deleteHostStatusData(
-        {
-          type: "host.status_data.delete",
-          threadId: THREAD_ID,
-          key: "tasks",
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toEqual({
-      key: "tasks",
-      deleted: true,
-      previousValue: null,
-      previousValuePresent: true,
-      previousVersion: sha256Text(nullJson),
-    });
-    await expect(
-      fs.stat(path.join(threadStoragePath, "STATUS-data", "tasks.json")),
-    ).rejects.toMatchObject({ code: "ENOENT" });
-
-    await expect(
-      deleteHostStatusData(
-        {
-          type: "host.status_data.delete",
-          threadId: THREAD_ID,
-          key: "tasks",
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toEqual({
-      key: "tasks",
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    });
-  });
-
-  it("handles missing roots without warning-class errors for expected misses", async () => {
-    const threadStorageRootPath = await makeTempDir(
-      "bb-host-status-data-missing-",
-    );
-    const threadId = "missing-thread-storage";
-
-    await expect(
-      listHostStatusData(
-        listCommand(threadId),
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toEqual({
-      values: {},
-      versions: {},
-      hash: sha256Text(""),
-    });
-    const thrown = await captureReadStatusDataError(
-      getCommand(threadId),
-      threadStorageRootPath,
-    );
-    expect(thrown).toMatchObject({
-      code: "ENOENT",
-      message: "Path does not exist: tasks.json",
-      name: "ExpectedCommandDispatchError",
-    });
-    expect(isExpectedCommandDispatchError(thrown)).toBe(true);
-    await expect(
-      deleteHostStatusData(
-        {
-          type: "host.status_data.delete",
-          threadId,
-          key: "tasks",
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).resolves.toEqual({
-      key: "tasks",
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    });
-  });
-
-  it("rejects malformed JSON and symlink STATUS-data files", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-invalid-");
-    const statusDataRootPath = path.join(threadStoragePath, "STATUS-data");
-    await fs.mkdir(statusDataRootPath, { recursive: true });
-    await fs.writeFile(path.join(statusDataRootPath, "tasks.json"), "{nope");
-
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "invalid_json",
-      message: "STATUS-data/tasks.json does not contain valid JSON",
-    });
-    await expect(
-      listHostStatusData(listCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "invalid_json",
-    });
-
-    await fs.rm(path.join(statusDataRootPath, "tasks.json"));
-    await fs.writeFile(path.join(threadStoragePath, "outside.json"), "[]\n");
-    await fs.symlink(
-      path.join(threadStoragePath, "outside.json"),
-      path.join(statusDataRootPath, "tasks.json"),
-    );
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toBeInstanceOf(CommandDispatchError);
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-  });
-
-  it("rejects oversized STATUS-data files before reading contents", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-large-");
-    const statusDataRootPath = path.join(threadStoragePath, "STATUS-data");
-    const statusDataPath = path.join(statusDataRootPath, "tasks.json");
-    await fs.mkdir(statusDataRootPath, { recursive: true });
-    await fs.writeFile(statusDataPath, "[]\n");
-    await fs.truncate(statusDataPath, NON_IMAGE_FILE_SIZE_LIMIT_BYTES + 1);
-
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "file_too_large",
-      message: expect.stringContaining("25 MB limit"),
-    });
-    await expect(
-      listHostStatusData(listCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "file_too_large",
-      message: expect.stringContaining("25 MB limit"),
-    });
-  });
-
-  it("rejects symlink STATUS-data directories without touching their targets", async () => {
-    const { threadStoragePath, threadStorageRootPath } =
-      await makeThreadStorage("bb-host-status-data-symlink-dir-");
-    const targetRootPath = await makeTempDir(
-      "bb-host-status-data-symlink-dir-target-",
-    );
-    const targetContent = '["target"]\n';
-    await fs.mkdir(threadStoragePath, { recursive: true });
-    await fs.writeFile(path.join(targetRootPath, "tasks.json"), targetContent);
-    await fs.symlink(
-      targetRootPath,
-      path.join(threadStoragePath, "STATUS-data"),
-    );
-
-    await expect(
-      listHostStatusData(listCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-    await expect(
-      readHostStatusData(getCommand(), commandOptions(threadStorageRootPath)),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-    await expect(
-      writeHostStatusData(
-        {
-          type: "host.status_data.set",
-          threadId: THREAD_ID,
-          key: "tasks",
-          value: ["changed"],
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-    await expect(
-      deleteHostStatusData(
-        {
-          type: "host.status_data.delete",
-          threadId: THREAD_ID,
-          key: "tasks",
-        },
-        commandOptions(threadStorageRootPath),
-      ),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-    await expect(
-      fs.readFile(path.join(targetRootPath, "tasks.json"), "utf8"),
-    ).resolves.toBe(targetContent);
-  });
-
-  it("rejects non-absolute roots", async () => {
-    await expect(
-      listHostStatusData(listCommand(), commandOptions("relative")),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-  });
-
-  it("rejects thread IDs that escape the thread storage root", async () => {
-    const threadStorageRootPath = await makeTempDir(
-      "bb-host-status-data-escape-",
-    );
-
-    await expect(
-      listHostStatusData(
-        listCommand("../outside"),
-        commandOptions(threadStorageRootPath),
-      ),
-    ).rejects.toMatchObject({
-      code: "invalid_path",
-    });
-  });
-});
diff --git a/apps/host-daemon/src/command-handlers/status-data.ts b/apps/host-daemon/src/command-handlers/status-data.ts
deleted file mode 100644
index 2683fecf3..000000000
--- a/apps/host-daemon/src/command-handlers/status-data.ts
+++ /dev/null
@@ -1,555 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import type { Stats } from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import type { HostDaemonCommandResult } from "@bb/host-daemon-contract";
-import {
-  jsonValueSchema,
-  type JsonValue,
-  type StatusDataKey,
-} from "@bb/domain";
-import {
-  parseStatusDataFileName,
-  statusDataFileName,
-  STATUS_DATA_DIRECTORY_NAME,
-} from "@bb/host-watcher";
-import {
-  CommandDispatchError,
-  ExpectedCommandDispatchError,
-  type CommandOf,
-} from "../command-dispatch-support.js";
-import { isFsErrorWithCode } from "../fs-errors.js";
-import { NON_IMAGE_FILE_SIZE_LIMIT_BYTES } from "./file-read.js";
-import { resolveNonSymlinkDirectoryPath } from "./root-path.js";
-
-interface StatusDataEntry {
-  key: StatusDataKey;
-  modifiedAtMs: number;
-  sizeBytes: number;
-  value: JsonValue;
-  version: string;
-}
-
-interface StatusDataPreviousValue {
-  previousValue: JsonValue | null;
-  previousValuePresent: boolean;
-  previousVersion: string | null;
-}
-
-interface ResolveThreadStorageRootArgs {
-  rootPath: string;
-}
-
-interface ResolveStatusDataRootArgs {
-  threadStorageRootPath: string;
-}
-
-interface ResolvedStatusDataRoot {
-  fingerprint: StatusDataDirectoryFingerprint;
-  path: string;
-}
-
-export type StatusDataDirectoryFingerprint = string;
-
-export interface ReadStatusDataDirectoryFingerprintFromRootArgs {
-  rootPath: string;
-}
-
-interface HostStatusDataCommandOptions {
-  threadStorageRootPath: string;
-}
-
-type HostStatusDataCommand = CommandOf<
-  | "host.status_data.list"
-  | "host.status_data.get"
-  | "host.status_data.set"
-  | "host.status_data.delete"
->;
-
-interface ReadStatusDataEntryArgs {
-  key: StatusDataKey;
-  statusDataRootPath: string;
-}
-
-interface WriteStatusDataEntryArgs extends ReadStatusDataEntryArgs {
-  value: JsonValue;
-}
-
-interface ParseStatusDataJsonArgs {
-  bytes: Buffer;
-  key: StatusDataKey;
-}
-
-function sha256(bytes: Buffer): string {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-
-function statusDataDirectoryFingerprint(stat: Stats): string {
-  return `${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}`;
-}
-
-function canonicalizeStatusJson(value: JsonValue): string {
-  return `${JSON.stringify(value, null, 2)}\n`;
-}
-
-function statusDataRelativePath(key: StatusDataKey): string {
-  return statusDataFileName(key);
-}
-
-function statusDataFilePath(
-  statusDataRootPath: string,
-  key: StatusDataKey,
-): string {
-  return path.join(statusDataRootPath, statusDataRelativePath(key));
-}
-
-function createMissingStatusDataKeyError(key: StatusDataKey): Error {
-  return new ExpectedCommandDispatchError(
-    "ENOENT",
-    `Path does not exist: ${statusDataRelativePath(key)}`,
-  );
-}
-
-function parseStatusDataJson(args: ParseStatusDataJsonArgs): JsonValue {
-  try {
-    return jsonValueSchema.parse(JSON.parse(args.bytes.toString("utf8")));
-  } catch {
-    throw new CommandDispatchError(
-      "invalid_json",
-      `STATUS-data/${args.key}.json does not contain valid JSON`,
-    );
-  }
-}
-
-function createStatusDataFileTooLargeError(stat: Stats): CommandDispatchError {
-  return new CommandDispatchError(
-    "file_too_large",
-    `File size ${stat.size} bytes exceeds the ${Math.floor(NON_IMAGE_FILE_SIZE_LIMIT_BYTES / (1024 * 1024))} MB limit`,
-  );
-}
-
-function createPreviousValue(
-  entry: StatusDataEntry | null,
-): StatusDataPreviousValue {
-  return {
-    previousValue: entry?.value ?? null,
-    previousValuePresent: entry !== null,
-    previousVersion: entry?.version ?? null,
-  };
-}
-
-function isPathWithinRoot(candidatePath: string, rootPath: string): boolean {
-  const relativePath = path.relative(rootPath, candidatePath);
-  return (
-    relativePath === "" ||
-    (!relativePath.startsWith("..") && !path.isAbsolute(relativePath))
-  );
-}
-
-function resolveCommandThreadStoragePath(
-  command: HostStatusDataCommand,
-  options: HostStatusDataCommandOptions,
-): string {
-  if (!path.isAbsolute(options.threadStorageRootPath)) {
-    throw new CommandDispatchError(
-      "invalid_path",
-      "threadStorageRootPath must be absolute",
-    );
-  }
-  const rootPath = path.resolve(
-    options.threadStorageRootPath,
-    command.threadId,
-  );
-  if (!isPathWithinRoot(rootPath, options.threadStorageRootPath)) {
-    throw new CommandDispatchError(
-      "invalid_path",
-      "threadId resolves outside thread storage root",
-    );
-  }
-  return rootPath;
-}
-
-function isStatusDataKey(key: StatusDataKey | null): key is StatusDataKey {
-  return key !== null;
-}
-
-async function resolveExistingThreadStorageRoot(
-  args: ResolveThreadStorageRootArgs,
-): Promise<string | null> {
-  if (!path.isAbsolute(args.rootPath)) {
-    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
-  }
-  try {
-    return await resolveNonSymlinkDirectoryPath({
-      description: "Thread storage root",
-      path: args.rootPath,
-    });
-  } catch (error) {
-    if (isFsErrorWithCode(error, "ENOENT")) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function ensureThreadStorageRoot(
-  args: ResolveThreadStorageRootArgs,
-): Promise<string> {
-  if (!path.isAbsolute(args.rootPath)) {
-    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
-  }
-  await fs.mkdir(args.rootPath, { recursive: true });
-  return resolveNonSymlinkDirectoryPath({
-    description: "Thread storage root",
-    path: args.rootPath,
-  });
-}
-
-async function resolveExistingStatusDataRoot(
-  args: ResolveStatusDataRootArgs,
-): Promise<ResolvedStatusDataRoot | null> {
-  const statusDataRootPath = path.join(
-    args.threadStorageRootPath,
-    STATUS_DATA_DIRECTORY_NAME,
-  );
-  try {
-    const resolvedPath = await resolveNonSymlinkDirectoryPath({
-      description: "STATUS-data directory",
-      path: statusDataRootPath,
-    });
-    const stat = await fs.stat(resolvedPath);
-    return {
-      fingerprint: statusDataDirectoryFingerprint(stat),
-      path: resolvedPath,
-    };
-  } catch (error) {
-    if (isFsErrorWithCode(error, "ENOENT")) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function ensureStatusDataRoot(
-  args: ResolveStatusDataRootArgs,
-): Promise<ResolvedStatusDataRoot> {
-  const statusDataRootPath = path.join(
-    args.threadStorageRootPath,
-    STATUS_DATA_DIRECTORY_NAME,
-  );
-  try {
-    await fs.mkdir(statusDataRootPath, { recursive: true });
-  } catch (error) {
-    if (!isFsErrorWithCode(error, "EEXIST")) {
-      throw error;
-    }
-  }
-  const resolvedPath = await resolveNonSymlinkDirectoryPath({
-    description: "STATUS-data directory",
-    path: statusDataRootPath,
-  });
-  const stat = await fs.stat(resolvedPath);
-  return {
-    fingerprint: statusDataDirectoryFingerprint(stat),
-    path: resolvedPath,
-  };
-}
-
-async function readStatusDataEntryOrNull(
-  args: ReadStatusDataEntryArgs,
-): Promise<StatusDataEntry | null> {
-  const filePath = statusDataFilePath(args.statusDataRootPath, args.key);
-  let stat;
-  try {
-    stat = await fs.lstat(filePath);
-  } catch (error) {
-    if (isFsErrorWithCode(error, "ENOENT")) {
-      return null;
-    }
-    throw error;
-  }
-
-  if (stat.isSymbolicLink()) {
-    throw new CommandDispatchError(
-      "invalid_path",
-      `STATUS-data/${args.key}.json is a symlink, not a file`,
-    );
-  }
-  if (!stat.isFile()) {
-    throw new CommandDispatchError(
-      "invalid_path",
-      `STATUS-data/${args.key}.json is not a file`,
-    );
-  }
-  if (stat.size > NON_IMAGE_FILE_SIZE_LIMIT_BYTES) {
-    throw createStatusDataFileTooLargeError(stat);
-  }
-
-  const bytes = await fs.readFile(filePath);
-  return {
-    key: args.key,
-    value: parseStatusDataJson({ key: args.key, bytes }),
-    version: sha256(bytes),
-    sizeBytes: stat.size,
-    modifiedAtMs: stat.mtimeMs,
-  };
-}
-
-async function requireStatusDataEntry(
-  args: ReadStatusDataEntryArgs,
-): Promise<StatusDataEntry> {
-  const entry = await readStatusDataEntryOrNull(args);
-  if (!entry) {
-    throw createMissingStatusDataKeyError(args.key);
-  }
-  return entry;
-}
-
-async function writeStatusDataEntry(
-  args: WriteStatusDataEntryArgs,
-): Promise<StatusDataEntry> {
-  await fs.mkdir(args.statusDataRootPath, { recursive: true });
-  const filePath = statusDataFilePath(args.statusDataRootPath, args.key);
-  const content = canonicalizeStatusJson(args.value);
-  const bytes = Buffer.from(content, "utf8");
-  const tempPath = path.join(
-    args.statusDataRootPath,
-    `.${args.key}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`,
-  );
-
-  await fs.writeFile(tempPath, bytes, { flag: "wx" });
-  try {
-    await fs.rename(tempPath, filePath);
-  } catch (error) {
-    await fs.rm(tempPath, { force: true });
-    throw error;
-  }
-
-  const stat = await fs.stat(filePath);
-  return {
-    key: args.key,
-    value: args.value,
-    version: sha256(bytes),
-    sizeBytes: stat.size,
-    modifiedAtMs: stat.mtimeMs,
-  };
-}
-
-async function deleteStatusDataEntry(
-  args: ReadStatusDataEntryArgs,
-): Promise<void> {
-  const filePath = statusDataFilePath(args.statusDataRootPath, args.key);
-  try {
-    await fs.rm(filePath);
-  } catch (error) {
-    if (isFsErrorWithCode(error, "ENOENT")) {
-      return;
-    }
-    throw error;
-  }
-}
-
-export async function listHostStatusData(
-  command: CommandOf<"host.status_data.list">,
-  options: HostStatusDataCommandOptions,
-): Promise<HostDaemonCommandResult<"host.status_data.list">> {
-  return listHostStatusDataFromRoot({
-    rootPath: resolveCommandThreadStoragePath(command, options),
-  });
-}
-
-export async function listHostStatusDataFromRoot(
-  args: ResolveThreadStorageRootArgs,
-): Promise<HostDaemonCommandResult<"host.status_data.list">> {
-  const threadStorageRootPath = await resolveExistingThreadStorageRoot({
-    rootPath: args.rootPath,
-  });
-  if (threadStorageRootPath === null) {
-    return {
-      values: {},
-      versions: {},
-      hash: sha256(Buffer.from("")),
-    };
-  }
-
-  const statusDataRoot = await resolveExistingStatusDataRoot({
-    threadStorageRootPath,
-  });
-  if (statusDataRoot === null) {
-    return {
-      values: {},
-      versions: {},
-      hash: sha256(Buffer.from("")),
-    };
-  }
-  let entries;
-  try {
-    entries = await fs.readdir(statusDataRoot.path, { withFileTypes: true });
-  } catch (error) {
-    if (isFsErrorWithCode(error, "ENOENT")) {
-      return {
-        values: {},
-        versions: {},
-        hash: sha256(Buffer.from("")),
-      };
-    }
-    throw error;
-  }
-
-  const keys = entries
-    .filter((entry) => entry.isFile())
-    .map((entry) => parseStatusDataFileName(entry.name))
-    .filter(isStatusDataKey);
-  const statusEntries = await Promise.all(
-    keys.map((key) =>
-      requireStatusDataEntry({
-        statusDataRootPath: statusDataRoot.path,
-        key,
-      }),
-    ),
-  );
-
-  const values: Record<StatusDataKey, JsonValue> = {};
-  const versions: Record<StatusDataKey, string> = {};
-  for (const statusEntry of statusEntries) {
-    values[statusEntry.key] = statusEntry.value;
-    versions[statusEntry.key] = statusEntry.version;
-  }
-
-  const aggregateHash = createHash("sha256");
-  for (const key of Object.keys(versions).sort()) {
-    aggregateHash.update(`${key}\0${versions[key]}\n`);
-  }
-
-  return {
-    values,
-    versions,
-    hash: aggregateHash.digest("hex"),
-  };
-}
-
-export async function readStatusDataDirectoryFingerprintFromRoot(
-  args: ReadStatusDataDirectoryFingerprintFromRootArgs,
-): Promise<StatusDataDirectoryFingerprint | null> {
-  const threadStorageRootPath = await resolveExistingThreadStorageRoot({
-    rootPath: args.rootPath,
-  });
-  if (threadStorageRootPath === null) {
-    return null;
-  }
-
-  const statusDataRoot = await resolveExistingStatusDataRoot({
-    threadStorageRootPath,
-  });
-  return statusDataRoot?.fingerprint ?? null;
-}
-
-export async function readHostStatusData(
-  command: CommandOf<"host.status_data.get">,
-  options: HostStatusDataCommandOptions,
-): Promise<HostDaemonCommandResult<"host.status_data.get">> {
-  return readHostStatusDataFromRoot({
-    rootPath: resolveCommandThreadStoragePath(command, options),
-    key: command.key,
-  });
-}
-
-export async function readHostStatusDataFromRoot(
-  args: ResolveThreadStorageRootArgs & { key: StatusDataKey },
-): Promise<HostDaemonCommandResult<"host.status_data.get">> {
-  const threadStorageRootPath = await resolveExistingThreadStorageRoot({
-    rootPath: args.rootPath,
-  });
-  if (threadStorageRootPath === null) {
-    throw createMissingStatusDataKeyError(args.key);
-  }
-  const statusDataRoot = await resolveExistingStatusDataRoot({
-    threadStorageRootPath,
-  });
-  if (statusDataRoot === null) {
-    throw createMissingStatusDataKeyError(args.key);
-  }
-  return requireStatusDataEntry({
-    statusDataRootPath: statusDataRoot.path,
-    key: args.key,
-  });
-}
-
-export async function writeHostStatusData(
-  command: CommandOf<"host.status_data.set">,
-  options: HostStatusDataCommandOptions,
-): Promise<HostDaemonCommandResult<"host.status_data.set">> {
-  const threadStorageRootPath = await ensureThreadStorageRoot({
-    rootPath: resolveCommandThreadStoragePath(command, options),
-  });
-  const statusDataRoot = await ensureStatusDataRoot({
-    threadStorageRootPath,
-  });
-  const previous = await readStatusDataEntryOrNull({
-    statusDataRootPath: statusDataRoot.path,
-    key: command.key,
-  });
-  const entry = await writeStatusDataEntry({
-    statusDataRootPath: statusDataRoot.path,
-    key: command.key,
-    value: command.value,
-  });
-  return {
-    ...entry,
-    ...createPreviousValue(previous),
-  };
-}
-
-export async function deleteHostStatusData(
-  command: CommandOf<"host.status_data.delete">,
-  options: HostStatusDataCommandOptions,
-): Promise<HostDaemonCommandResult<"host.status_data.delete">> {
-  const threadStorageRootPath = await resolveExistingThreadStorageRoot({
-    rootPath: resolveCommandThreadStoragePath(command, options),
-  });
-  if (threadStorageRootPath === null) {
-    return {
-      key: command.key,
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    };
-  }
-
-  const statusDataRoot = await resolveExistingStatusDataRoot({
-    threadStorageRootPath,
-  });
-  if (statusDataRoot === null) {
-    return {
-      key: command.key,
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    };
-  }
-  const previous = await readStatusDataEntryOrNull({
-    statusDataRootPath: statusDataRoot.path,
-    key: command.key,
-  });
-  if (previous === null) {
-    return {
-      key: command.key,
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      previousVersion: null,
-    };
-  }
-
-  await deleteStatusDataEntry({
-    statusDataRootPath: statusDataRoot.path,
-    key: command.key,
-  });
-  return {
-    key: command.key,
-    deleted: true,
-    ...createPreviousValue(previous),
-  };
-}
diff --git a/apps/host-daemon/src/command-handlers/status-version.ts b/apps/host-daemon/src/command-handlers/status-version.ts
deleted file mode 100644
index 611b2deaf..000000000
--- a/apps/host-daemon/src/command-handlers/status-version.ts
+++ /dev/null
@@ -1,491 +0,0 @@
-import { createHash } from "node:crypto";
-import type { BigIntStats, Dirent } from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import type {
-  HostDaemonCommandResult,
-  HostReadFileRelativeDotfilePolicy,
-  HostStatusVersionFileSource,
-  HostStatusVersionFolderSource,
-  HostStatusVersionSource,
-} from "@bb/host-daemon-contract";
-import { CommandDispatchError } from "../command-dispatch-support.js";
-import type { CommandOf } from "../command-dispatch-support.js";
-import { isFsErrorWithCode } from "../fs-errors.js";
-import { resolveNonSymlinkDirectoryPath } from "./root-path.js";
-
-type StatusVersionHashEntry =
-  | StatusVersionFileEntry
-  | StatusVersionUnreadableEntry;
-
-interface StatusVersionFileEntry {
-  kind: "file";
-  modifiedAtNs: bigint;
-  path: string;
-  sizeBytes: bigint;
-}
-
-interface StatusVersionUnreadableEntry {
-  kind: "unreadable";
-  path: string;
-}
-
-interface ValidatedRelativePath {
-  resultPath: string;
-  segments: readonly string[];
-}
-
-interface ResolveSourceFileArgs {
-  dotfiles: HostReadFileRelativeDotfilePolicy;
-  path: string;
-  rootPath: string;
-}
-
-interface WalkDirectoryArgs {
-  dotfiles: HostReadFileRelativeDotfilePolicy;
-  physicalDirPath: string;
-  relativeDirPath: string;
-  rootPath: string;
-  seenDirectories: Set<string>;
-}
-
-type WalkEntryResolution =
-  | { kind: "directory"; readablePath: string }
-  | { kind: "file"; entry: StatusVersionFileEntry }
-  | { kind: "skip" };
-
-interface ResolveReadablePathArgs {
-  fullPath: string;
-  resultPath: string;
-  rootPath: string;
-}
-
-interface StatReadableFileArgs {
-  readablePath: string;
-  resultPath: string;
-}
-
-interface ResolveWalkEntryArgs {
-  fullPath: string;
-  relativePath: string;
-  rootPath: string;
-}
-
-const UNREADABLE_DIRECTORY_PATH = ".";
-const UNREADABLE_DIRECTORY_HASH_SENTINEL = "unreadable-directory";
-
-const STATUS_SOURCE_UNUSABLE_ERROR_CODES = new Set([
-  "EACCES",
-  "ELOOP",
-  "ENOENT",
-  "ENOTDIR",
-  "EPERM",
-  "invalid_path",
-]);
-
-function validateRelativePath(
-  relativePath: string,
-  dotfiles: HostReadFileRelativeDotfilePolicy,
-): ValidatedRelativePath {
-  if (
-    relativePath.includes("\0") ||
-    relativePath.includes("\\") ||
-    path.posix.isAbsolute(relativePath)
-  ) {
-    throw new CommandDispatchError("invalid_path", "Path must be relative");
-  }
-
-  const segments = relativePath.split("/");
-  if (
-    segments.some(
-      (segment) => segment.length === 0 || segment === "." || segment === "..",
-    )
-  ) {
-    throw new CommandDispatchError("invalid_path", "Path must be relative");
-  }
-
-  if (
-    dotfiles === "deny" &&
-    segments.some((segment) => segment.startsWith("."))
-  ) {
-    throw new CommandDispatchError(
-      "ENOENT",
-      `Path does not exist: ${relativePath}`,
-    );
-  }
-
-  return {
-    resultPath: segments.join("/"),
-    segments,
-  };
-}
-
-function assertAbsoluteRootPath(rootPath: string): void {
-  if (!path.isAbsolute(rootPath)) {
-    throw new CommandDispatchError("invalid_path", "rootPath must be absolute");
-  }
-}
-
-function isPathWithinRoot(candidatePath: string, rootPath: string): boolean {
-  const relativePath = path.relative(rootPath, candidatePath);
-  return (
-    relativePath === "" ||
-    (!relativePath.startsWith("..") && !path.isAbsolute(relativePath))
-  );
-}
-
-function isUnavailableStatusSourceError(error: Error): boolean {
-  return (
-    error instanceof CommandDispatchError &&
-    STATUS_SOURCE_UNUSABLE_ERROR_CODES.has(error.code)
-  );
-}
-
-function toMappedFsError(error: Error, resultPath: string): Error {
-  if (isFsErrorWithCode(error, "ENOENT")) {
-    return new CommandDispatchError(
-      "ENOENT",
-      `Path does not exist: ${resultPath}`,
-    );
-  }
-  if (isFsErrorWithCode(error, "ENOTDIR")) {
-    return new CommandDispatchError(
-      "ENOTDIR",
-      `Path is not a directory: ${resultPath}`,
-    );
-  }
-  if (isFsErrorWithCode(error, "EACCES")) {
-    return new CommandDispatchError(
-      "EACCES",
-      `Permission denied: ${resultPath}`,
-    );
-  }
-  if (isFsErrorWithCode(error, "EPERM")) {
-    return new CommandDispatchError(
-      "EPERM",
-      `Operation not permitted: ${resultPath}`,
-    );
-  }
-  if (isFsErrorWithCode(error, "ELOOP")) {
-    return new CommandDispatchError(
-      "ELOOP",
-      `Too many symbolic links: ${resultPath}`,
-    );
-  }
-  return error;
-}
-
-function throwMappedFsError(error: Error, resultPath: string): never {
-  throw toMappedFsError(error, resultPath);
-}
-
-async function resolveStatusRootPath(rootPath: string): Promise<string> {
-  assertAbsoluteRootPath(rootPath);
-  try {
-    return await resolveNonSymlinkDirectoryPath({
-      description: "Root path",
-      path: rootPath,
-    });
-  } catch (error) {
-    if (error instanceof Error) {
-      throwMappedFsError(error, rootPath);
-    }
-    throw error;
-  }
-}
-
-async function resolveReadablePath(
-  args: ResolveReadablePathArgs,
-): Promise<string> {
-  try {
-    const readablePath = await fs.realpath(args.fullPath);
-    if (!isPathWithinRoot(readablePath, args.rootPath)) {
-      throw new CommandDispatchError(
-        "invalid_path",
-        `Path "${args.resultPath}" escapes read root`,
-      );
-    }
-    return readablePath;
-  } catch (error) {
-    if (error instanceof Error) {
-      throwMappedFsError(error, args.resultPath);
-    }
-    throw error;
-  }
-}
-
-async function statReadableFile(
-  args: StatReadableFileArgs,
-): Promise<StatusVersionFileEntry> {
-  try {
-    const stat = await fs.stat(args.readablePath, { bigint: true });
-    if (stat.isDirectory()) {
-      throw new CommandDispatchError(
-        "invalid_path",
-        "Path is a directory, not a file",
-      );
-    }
-    return {
-      kind: "file",
-      modifiedAtNs: stat.mtimeNs,
-      path: args.resultPath,
-      sizeBytes: stat.size,
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throwMappedFsError(error, args.resultPath);
-    }
-    throw error;
-  }
-}
-
-async function resolveWalkEntry(
-  args: ResolveWalkEntryArgs,
-): Promise<WalkEntryResolution> {
-  let readablePath: string;
-  try {
-    readablePath = await resolveReadablePath({
-      fullPath: args.fullPath,
-      resultPath: args.relativePath,
-      rootPath: args.rootPath,
-    });
-  } catch (error) {
-    if (error instanceof Error && isUnavailableStatusSourceError(error)) {
-      return { kind: "skip" };
-    }
-    throw error;
-  }
-
-  let stat: BigIntStats;
-  try {
-    stat = await fs.stat(readablePath, { bigint: true });
-  } catch (error) {
-    if (error instanceof Error) {
-      try {
-        throwMappedFsError(error, args.relativePath);
-      } catch (mappedError) {
-        if (
-          mappedError instanceof Error &&
-          isUnavailableStatusSourceError(mappedError)
-        ) {
-          return { kind: "skip" };
-        }
-        throw mappedError;
-      }
-    }
-    throw error;
-  }
-
-  if (stat.isDirectory()) {
-    return { kind: "directory", readablePath };
-  }
-  if (stat.isFile()) {
-    return {
-      kind: "file",
-      entry: {
-        kind: "file",
-        modifiedAtNs: stat.mtimeNs,
-        path: args.relativePath,
-        sizeBytes: stat.size,
-      },
-    };
-  }
-  return { kind: "skip" };
-}
-
-async function statRelativeFile(
-  args: ResolveSourceFileArgs,
-): Promise<StatusVersionFileEntry> {
-  const rootPath = await resolveStatusRootPath(args.rootPath);
-  const relativePath = validateRelativePath(args.path, args.dotfiles);
-  const readablePath = await resolveReadablePath({
-    fullPath: path.join(rootPath, ...relativePath.segments),
-    resultPath: relativePath.resultPath,
-    rootPath,
-  });
-  return statReadableFile({
-    readablePath,
-    resultPath: relativePath.resultPath,
-  });
-}
-
-function toChildRelativePath(
-  relativeDirPath: string,
-  childName: string,
-): string {
-  return relativeDirPath.length === 0
-    ? childName
-    : `${relativeDirPath}/${childName}`;
-}
-
-async function walkDirectory(
-  args: WalkDirectoryArgs,
-): Promise<StatusVersionHashEntry[]> {
-  let entries: Dirent[];
-  try {
-    entries = await fs.readdir(args.physicalDirPath, { withFileTypes: true });
-  } catch (error) {
-    if (error instanceof Error) {
-      const mappedError = toMappedFsError(
-        error,
-        args.relativeDirPath || args.rootPath,
-      );
-      if (
-        mappedError instanceof Error &&
-        isUnavailableStatusSourceError(mappedError)
-      ) {
-        return [
-          {
-            kind: "unreadable",
-            path: args.relativeDirPath || UNREADABLE_DIRECTORY_PATH,
-          },
-        ];
-      }
-      throw mappedError;
-    }
-    throw error;
-  }
-
-  const fileEntries: StatusVersionHashEntry[] = [];
-  for (const entry of entries) {
-    if (args.dotfiles === "deny" && entry.name.startsWith(".")) {
-      continue;
-    }
-
-    const relativePath = toChildRelativePath(args.relativeDirPath, entry.name);
-    try {
-      validateRelativePath(relativePath, args.dotfiles);
-    } catch (error) {
-      if (error instanceof Error && isUnavailableStatusSourceError(error)) {
-        continue;
-      }
-      throw error;
-    }
-    const resolvedEntry = await resolveWalkEntry({
-      fullPath: path.join(args.physicalDirPath, entry.name),
-      relativePath,
-      rootPath: args.rootPath,
-    });
-    if (resolvedEntry.kind === "skip") {
-      continue;
-    }
-
-    if (resolvedEntry.kind === "directory") {
-      if (args.seenDirectories.has(resolvedEntry.readablePath)) {
-        continue;
-      }
-      args.seenDirectories.add(resolvedEntry.readablePath);
-      fileEntries.push(
-        ...(await walkDirectory({
-          ...args,
-          physicalDirPath: resolvedEntry.readablePath,
-          relativeDirPath: relativePath,
-        })),
-      );
-      continue;
-    }
-
-    fileEntries.push(resolvedEntry.entry);
-  }
-
-  return fileEntries;
-}
-
-function hashStatusVersion(
-  source: HostStatusVersionSource,
-  entries: readonly StatusVersionHashEntry[],
-): string {
-  const hash = createHash("sha256");
-  hash.update(`source:${source}\n`);
-  for (const entry of [...entries].sort((left, right) =>
-    left.path.localeCompare(right.path),
-  )) {
-    if (entry.kind === "unreadable") {
-      // Keep unreadable child directories in the tuple so STATUS folder mode
-      // stays aligned with /status/ when index.html is still valid.
-      hash.update(`${entry.path}\0${UNREADABLE_DIRECTORY_HASH_SENTINEL}\n`);
-      continue;
-    }
-    hash.update(
-      `${entry.path}\0${entry.sizeBytes.toString()}\0${entry.modifiedAtNs.toString()}\n`,
-    );
-  }
-  return hash.digest("hex");
-}
-
-async function resolveFolderSource(
-  source: HostStatusVersionFolderSource,
-): Promise<HostDaemonCommandResult<"host.status_version">> {
-  await statRelativeFile({
-    rootPath: source.rootPath,
-    path: source.indexPath,
-    dotfiles: source.dotfiles,
-  });
-
-  const rootPath = await resolveStatusRootPath(source.rootPath);
-  const entries = await walkDirectory({
-    rootPath,
-    physicalDirPath: rootPath,
-    relativeDirPath: "",
-    dotfiles: source.dotfiles,
-    seenDirectories: new Set([rootPath]),
-  });
-  return {
-    source: source.source,
-    hash: hashStatusVersion(source.source, entries),
-  };
-}
-
-async function resolveFileSource(
-  source: HostStatusVersionFileSource,
-): Promise<HostDaemonCommandResult<"host.status_version">> {
-  const entry = await statRelativeFile({
-    rootPath: source.rootPath,
-    path: source.path,
-    dotfiles: source.dotfiles,
-  });
-  return {
-    source: source.source,
-    hash: hashStatusVersion(source.source, [entry]),
-  };
-}
-
-async function tryResolveFolderSource(
-  source: HostStatusVersionFolderSource,
-): Promise<HostDaemonCommandResult<"host.status_version"> | null> {
-  try {
-    return await resolveFolderSource(source);
-  } catch (error) {
-    if (error instanceof Error && isUnavailableStatusSourceError(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-async function tryResolveFileSource(
-  source: HostStatusVersionFileSource,
-): Promise<HostDaemonCommandResult<"host.status_version"> | null> {
-  try {
-    return await resolveFileSource(source);
-  } catch (error) {
-    if (error instanceof Error && isUnavailableStatusSourceError(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-export async function readHostStatusVersion(
-  command: CommandOf<"host.status_version">,
-): Promise<HostDaemonCommandResult<"host.status_version">> {
-  const [folderSource, htmlSource, markdownSource] = command.sources;
-  return (
-    (await tryResolveFolderSource(folderSource)) ??
-    (await tryResolveFileSource(htmlSource)) ??
-    (await tryResolveFileSource(markdownSource)) ?? {
-      source: "empty",
-      hash: hashStatusVersion("empty", []),
-    }
-  );
-}
diff --git a/apps/host-daemon/src/command-router.ts b/apps/host-daemon/src/command-router.ts
index c5c7fe678..32cdcd91a 100644
--- a/apps/host-daemon/src/command-router.ts
+++ b/apps/host-daemon/src/command-router.ts
@@ -46,35 +46,6 @@ type FileWriteLaneCommand = Extract<
       | "host.delete_path_relative";
   }
 >;
-type StatusDataSetCommand = Extract<
-  HostDaemonCommand,
-  { type: "host.status_data.set" }
->;
-type StatusDataDeleteCommand = Extract<
-  HostDaemonCommand,
-  { type: "host.status_data.delete" }
->;
-
-export interface StatusDataSetCommandResultNotification {
-  command: StatusDataSetCommand;
-  result: HostDaemonCommandResult<"host.status_data.set">;
-}
-
-export interface StatusDataDeleteCommandResultNotification {
-  command: StatusDataDeleteCommand;
-  result: HostDaemonCommandResult<"host.status_data.delete">;
-}
-
-export type StatusDataCommandResultNotification =
-  | StatusDataSetCommandResultNotification
-  | StatusDataDeleteCommandResultNotification;
-
-export function isStatusDataSetCommandResultNotification(
-  notification: StatusDataCommandResultNotification,
-): notification is StatusDataSetCommandResultNotification {
-  return notification.command.type === "host.status_data.set";
-}
-
 interface EnvironmentLaneWorkMetrics {
   startedAtMs: number | null;
 }
@@ -131,9 +102,6 @@ export interface CommandRouterOptions {
   threadStorageRootPath: string;
   logger: CommandRouterLogger;
   readFetchedAt?: ReadCommandFetchedAt;
-  onStatusDataCommandResult?: (
-    notification: StatusDataCommandResultNotification,
-  ) => void;
   now?: () => number;
 }
 
@@ -348,24 +316,6 @@ export class CommandRouter {
     };
 
     try {
-      if (command.type === "host.status_data.set") {
-        const result = await dispatchCommand(command, dispatchOptions);
-        this.options.onStatusDataCommandResult?.({ command, result });
-        return this.createSuccessfulCommandResult({
-          baseReport,
-          handlerStartedAtMs,
-          result,
-        });
-      }
-      if (command.type === "host.status_data.delete") {
-        const result = await dispatchCommand(command, dispatchOptions);
-        this.options.onStatusDataCommandResult?.({ command, result });
-        return this.createSuccessfulCommandResult({
-          baseReport,
-          handlerStartedAtMs,
-          result,
-        });
-      }
       const result = await dispatchCommand(command, dispatchOptions);
       return this.createSuccessfulCommandResult({
         baseReport,
diff --git a/apps/host-daemon/src/runtime-manager.test.ts b/apps/host-daemon/src/runtime-manager.test.ts
index 4ec5af8e0..8d3de2092 100644
--- a/apps/host-daemon/src/runtime-manager.test.ts
+++ b/apps/host-daemon/src/runtime-manager.test.ts
@@ -1024,13 +1024,13 @@ describe("RuntimeManager", () => {
       },
     });
     const onThreadStorageChanged = vi.fn();
-    const onThreadStatusDataChanged = vi.fn();
+    const onThreadAppDataChanged = vi.fn();
     const manager = new RuntimeManager({
       hostWatcher,
       provisionWorkspace: createProvisionWorkspaceMock("/tmp/env-storage"),
       createRuntime: vi.fn(() => createFakeRuntime()),
       onThreadStorageChanged,
-      onThreadStatusDataChanged,
+      onThreadAppDataChanged,
       threadStorageRootPath: "/tmp/bb-data/thread-storage",
     });
 
@@ -1052,10 +1052,11 @@ describe("RuntimeManager", () => {
       threadId: "thread-2",
     });
     watchThreadStorageRootArgs?.onChange({
-      kind: "thread-status-data-changed",
+      kind: "thread-app-data-changed",
+      appId: "status",
       environmentId: "env-storage",
+      path: "state.json",
       threadId: "thread-1",
-      key: "state",
     });
 
     expect(watchThreadStorageRoot).toHaveBeenCalledTimes(1);
@@ -1073,10 +1074,11 @@ describe("RuntimeManager", () => {
       threadId: "thread-2",
     });
     expect(onThreadStorageChanged).toHaveBeenCalledTimes(2);
-    expect(onThreadStatusDataChanged).toHaveBeenCalledWith({
+    expect(onThreadAppDataChanged).toHaveBeenCalledWith({
+      appId: "status",
       environmentId: "env-storage",
+      path: "state.json",
       threadId: "thread-1",
-      key: "state",
       threadStoragePath: "/tmp/bb-data/thread-storage/thread-1",
     });
     expect(stopWatchingPathChanges).not.toHaveBeenCalled();
diff --git a/apps/host-daemon/src/runtime-manager.ts b/apps/host-daemon/src/runtime-manager.ts
index 5cbf76498..d5ce9d0a7 100644
--- a/apps/host-daemon/src/runtime-manager.ts
+++ b/apps/host-daemon/src/runtime-manager.ts
@@ -11,7 +11,6 @@ import type {
   AppId,
   PendingInteractionCreate,
   PendingInteractionResolution,
-  StatusDataKey,
   ThreadEvent,
   WorkspaceProvisionType,
 } from "@bb/domain";
@@ -154,13 +153,6 @@ export interface RuntimeEntry {
   threads: Map<string, RuntimeThreadState>;
 }
 
-export interface ThreadStatusDataChangedNotification {
-  environmentId: string;
-  key: StatusDataKey;
-  threadId: string;
-  threadStoragePath: string;
-}
-
 export interface ThreadAppDataChangedNotification {
   appId: AppId;
   environmentId: string;
@@ -197,9 +189,6 @@ export interface RuntimeManagerOptions {
     environmentId: string;
     threadId: string;
   }) => void;
-  onThreadStatusDataChanged?: (
-    args: ThreadStatusDataChangedNotification,
-  ) => void;
   onThreadAppDataChanged?: (args: ThreadAppDataChangedNotification) => void;
   onThreadStorageWatchError?: (args: {
     error: ThreadStorageWatchError;
@@ -926,17 +915,6 @@ export class RuntimeManager {
               threadId: event.threadId,
             });
           }
-          if (event.kind === "thread-status-data-changed") {
-            this.options.onThreadStatusDataChanged?.({
-              environmentId: event.environmentId,
-              key: event.key,
-              threadId: event.threadId,
-              threadStoragePath: path.join(
-                threadStorageRootPath,
-                event.threadId,
-              ),
-            });
-          }
           if (event.kind === "thread-app-data-changed") {
             this.options.onThreadAppDataChanged?.({
               appId: event.appId,
diff --git a/apps/host-daemon/src/server-client.test.ts b/apps/host-daemon/src/server-client.test.ts
index 17f22bf81..de62102bb 100644
--- a/apps/host-daemon/src/server-client.test.ts
+++ b/apps/host-daemon/src/server-client.test.ts
@@ -1,7 +1,6 @@
 import { AbortError } from "p-retry";
 import { describe, expect, it, vi } from "vitest";
 import type { PendingInteractionCreate } from "@bb/domain";
-import { hostDaemonStatusDataChangeRequestSchema } from "@bb/host-daemon-contract";
 import { createServerClient, ServerResponseError } from "./server-client.js";
 
 function createLogger() {
@@ -227,51 +226,6 @@ describe("createServerClient", () => {
     });
   });
 
-  it("posts STATUS-data changes with the current session id", async () => {
-    const fetchFn = vi.fn<typeof fetch>(async (input, init) => {
-      const url = new URL(String(input));
-      expect(url.pathname).toBe("/internal/session/status-data-change");
-      const body = init?.body;
-      if (typeof body !== "string") {
-        throw new Error("Expected string request body");
-      }
-      expect(
-        hostDaemonStatusDataChangeRequestSchema.parse(JSON.parse(body)),
-      ).toEqual({
-        sessionId: "session-1",
-        threadId: "thr_123",
-        key: "state",
-        deleted: false,
-        value: { status: "running" },
-        version: "version-next",
-        previousValue: { status: "queued" },
-        previousValuePresent: true,
-        previousVersion: "version-prev",
-      });
-      return new Response(null, { status: 204 });
-    });
-    const client = createServerClient({
-      fetchFn,
-      getSessionId: () => "session-1",
-      hostKey: "host-key",
-      logger: createLogger(),
-      serverUrl: "https://bb.example.test",
-    });
-
-    await client.postStatusDataChange({
-      threadId: "thr_123",
-      key: "state",
-      deleted: false,
-      value: { status: "running" },
-      version: "version-next",
-      previousValue: { status: "queued" },
-      previousValuePresent: true,
-      previousVersion: "version-prev",
-    });
-
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-  });
-
   it("retries retryable interactive request registration responses after the attempt hook", async () => {
     let calls = 0;
     const fetchFn = vi.fn<typeof fetch>(async () => {
diff --git a/apps/host-daemon/src/server-client.ts b/apps/host-daemon/src/server-client.ts
index eefa04231..e68b4a4c4 100644
--- a/apps/host-daemon/src/server-client.ts
+++ b/apps/host-daemon/src/server-client.ts
@@ -12,7 +12,6 @@ import {
   hostDaemonEventBatchRequestSchema,
   hostDaemonEventBatchResponseSchema,
   hostDaemonProjectAttachmentContentQuerySchema,
-  hostDaemonStatusDataChangeRequestSchema,
   hostDaemonInteractiveInterruptRequestSchema,
   hostDaemonInteractiveInterruptResponseSchema,
   hostDaemonInteractiveRequestResponseSchema,
@@ -33,7 +32,6 @@ import {
   type HostDaemonEnvironmentChangePayload,
   type HostDaemonSessionOpenRequest,
   type HostDaemonSessionOpenResponse,
-  type HostDaemonStatusDataChangePayload,
   type HostDaemonToolCallResponse,
 } from "@bb/host-daemon-contract";
 import type { PendingInteractionCreate, ToolCallRequest } from "@bb/domain";
@@ -230,9 +228,6 @@ export interface ServerClient {
   postEnvironmentChange(
     args: HostDaemonEnvironmentChangePayload,
   ): Promise<void>;
-  postStatusDataChange(
-    args: HostDaemonStatusDataChangePayload,
-  ): Promise<void>;
   postAppDataChange(args: HostDaemonAppDataChangePayload): Promise<void>;
   postAppDataResync(args: HostDaemonAppDataResyncPayload): Promise<void>;
   postEvents(events: HostDaemonEventEnvelope[]): Promise<EventPostResult>;
@@ -662,25 +657,6 @@ export function createServerClient(
       }
     },
 
-    async postStatusDataChange(args): Promise<void> {
-      const payload = hostDaemonStatusDataChangeRequestSchema.parse({
-        sessionId: requireSessionId(),
-        ...args,
-      });
-      const response = await fetchFn(
-        buildInternalUrl("/session/status-data-change"),
-        {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify(payload),
-        },
-      );
-
-      if (!response.ok) {
-        throw await createResponseError("post STATUS-data change", response);
-      }
-    },
-
     async postAppDataChange(args): Promise<void> {
       const payload = hostDaemonAppDataChangeRequestSchema.parse({
         sessionId: requireSessionId(),
diff --git a/apps/host-daemon/src/status-data-change-reporter.test.ts b/apps/host-daemon/src/status-data-change-reporter.test.ts
deleted file mode 100644
index 30d5bb7b8..000000000
--- a/apps/host-daemon/src/status-data-change-reporter.test.ts
+++ /dev/null
@@ -1,792 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import type { HostDaemonStatusDataChangePayload } from "@bb/host-daemon-contract";
-import type { JsonValue, StatusDataKey } from "@bb/domain";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { HostDaemonLogger } from "./logger.js";
-import { NON_IMAGE_FILE_SIZE_LIMIT_BYTES } from "./command-handlers/file-read.js";
-import { StatusDataChangeReporter } from "./status-data-change-reporter.js";
-
-interface WriteStatusDataFileArgs {
-  key: StatusDataKey;
-  threadStoragePath: string;
-  value: JsonValue;
-}
-
-interface WriteRawStatusDataFileArgs {
-  content: string;
-  key: StatusDataKey;
-  threadStoragePath: string;
-}
-
-interface DeferredVoid {
-  promise: Promise<void>;
-  resolve(): void;
-}
-
-const tempDirs: string[] = [];
-
-function createLogger() {
-  return {
-    debug: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-  } satisfies HostDaemonLogger;
-}
-
-async function makeTempDir(prefix: string): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function sha256(content: string): string {
-  return createHash("sha256")
-    .update(Buffer.from(content, "utf8"))
-    .digest("hex");
-}
-
-function canonicalStatusDataJson(value: JsonValue): string {
-  return `${JSON.stringify(value, null, 2)}\n`;
-}
-
-function createDeferredVoid(): DeferredVoid {
-  let resolvePromise: () => void = () => {};
-  const promise = new Promise<void>((resolve) => {
-    resolvePromise = resolve;
-  });
-  return {
-    promise,
-    resolve: resolvePromise,
-  };
-}
-
-async function writeRawStatusDataFile(
-  args: WriteRawStatusDataFileArgs,
-): Promise<string> {
-  const rootPath = path.join(args.threadStoragePath, "STATUS-data");
-  await fs.mkdir(rootPath, { recursive: true });
-  await fs.writeFile(path.join(rootPath, `${args.key}.json`), args.content);
-  return args.content;
-}
-
-async function writeStatusDataFile(
-  args: WriteStatusDataFileArgs,
-): Promise<string> {
-  return writeRawStatusDataFile({
-    key: args.key,
-    threadStoragePath: args.threadStoragePath,
-    content: canonicalStatusDataJson(args.value),
-  });
-}
-
-afterEach(async () => {
-  vi.restoreAllMocks();
-  await Promise.all(
-    tempDirs
-      .splice(0)
-      .map((dir) => fs.rm(dir, { recursive: true, force: true })),
-  );
-});
-
-describe("StatusDataChangeReporter", () => {
-  it("primes current files without posting and reports later updates with previous metadata", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-update-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_update", threadStoragePath }],
-    });
-    expect(posted).toEqual([]);
-
-    const nextContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "new" },
-    });
-    await reporter.observe({
-      threadId: "thr_update",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_update",
-        key: "state",
-        deleted: false,
-        value: { status: "new" },
-        version: sha256(nextContent),
-        previousValue: { status: "old" },
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-    ]);
-  });
-
-  it("reports newly-created files without previous metadata", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-create-",
-    );
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_create", threadStoragePath }],
-    });
-
-    const content = await writeStatusDataFile({
-      threadStoragePath,
-      key: "progress",
-      value: 1,
-    });
-    await reporter.observe({
-      threadId: "thr_create",
-      threadStoragePath,
-      key: "progress",
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_create",
-        key: "progress",
-        deleted: false,
-        value: 1,
-        version: sha256(content),
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      },
-    ]);
-  });
-
-  it("reconciles files for a thread first observed after session open", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-late-track-",
-    );
-    const content = await writeStatusDataFile({
-      threadStoragePath,
-      key: "progress",
-      value: { step: 1 },
-    });
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-
-    await reporter.reconcileThread({
-      threadId: "thr_late_track",
-      threadStoragePath,
-    });
-    reporter.trackThread({ threadId: "thr_late_track" });
-    await reporter.reconcileThread({
-      threadId: "thr_late_track",
-      threadStoragePath,
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_late_track",
-        key: "progress",
-        deleted: false,
-        value: { step: 1 },
-        version: sha256(content),
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      },
-    ]);
-  });
-
-  it("retries observed updates after a failed post", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-retry-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const logger = createLogger();
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    let attempts = 0;
-    const reporter = new StatusDataChangeReporter({
-      logger,
-      postStatusDataChange: async (payload) => {
-        attempts += 1;
-        if (attempts === 1) {
-          throw new Error("offline");
-        }
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_retry", threadStoragePath }],
-    });
-
-    const nextContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "new" },
-    });
-    await reporter.observe({
-      threadId: "thr_retry",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(posted).toEqual([]);
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        key: "state",
-        threadId: "thr_retry",
-      }),
-      "Failed to report observed STATUS-data change",
-    );
-
-    await reporter.observe({
-      threadId: "thr_retry",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(attempts).toBe(2);
-    expect(posted).toEqual([
-      {
-        threadId: "thr_retry",
-        key: "state",
-        deleted: false,
-        value: { status: "new" },
-        version: sha256(nextContent),
-        previousValue: { status: "old" },
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-    ]);
-  });
-
-  it("reports deleted files only when a previous cached value exists", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-delete-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "summary",
-      value: null,
-    });
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_delete", threadStoragePath }],
-    });
-
-    await fs.rm(path.join(threadStoragePath, "STATUS-data", "summary.json"));
-    await reporter.observe({
-      threadId: "thr_delete",
-      threadStoragePath,
-      key: "summary",
-    });
-    await reporter.observe({
-      threadId: "thr_delete",
-      threadStoragePath,
-      key: "summary",
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_delete",
-        key: "summary",
-        deleted: true,
-        value: null,
-        version: null,
-        previousValue: null,
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-    ]);
-  });
-
-  it("does not post when an observed file still has the cached version", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-same-",
-    );
-    await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "same" },
-    });
-    const postStatusDataChange = vi.fn(async () => undefined);
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_same", threadStoragePath }],
-    });
-
-    await reporter.observe({
-      threadId: "thr_same",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(postStatusDataChange).not.toHaveBeenCalled();
-  });
-
-  it("serializes concurrent observations for the same key and reports the final value", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-same-key-race-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const firstPostStarted = createDeferredVoid();
-    const releaseFirstPost = createDeferredVoid();
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    let postCount = 0;
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        postCount += 1;
-        posted.push(payload);
-        if (postCount === 1) {
-          firstPostStarted.resolve();
-          await releaseFirstPost.promise;
-        }
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_same_key_race", threadStoragePath }],
-    });
-
-    const intermediateContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "intermediate" },
-    });
-    const firstObserve = reporter.observe({
-      threadId: "thr_same_key_race",
-      threadStoragePath,
-      key: "state",
-    });
-    await firstPostStarted.promise;
-    const finalContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "final" },
-    });
-    const secondObserve = reporter.observe({
-      threadId: "thr_same_key_race",
-      threadStoragePath,
-      key: "state",
-    });
-    releaseFirstPost.resolve();
-    await Promise.all([firstObserve, secondObserve]);
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_same_key_race",
-        key: "state",
-        deleted: false,
-        value: { status: "intermediate" },
-        version: sha256(intermediateContent),
-        previousValue: { status: "old" },
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-      {
-        threadId: "thr_same_key_race",
-        key: "state",
-        deleted: false,
-        value: { status: "final" },
-        version: sha256(finalContent),
-        previousValue: { status: "intermediate" },
-        previousValuePresent: true,
-        previousVersion: sha256(intermediateContent),
-      },
-    ]);
-  });
-
-  it("suppresses observed changes already applied by daemon commands", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-command-",
-    );
-    await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const postStatusDataChange = vi.fn(async () => undefined);
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_command", threadStoragePath }],
-    });
-
-    const nextContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "new" },
-    });
-    reporter.recordCommandSet({
-      threadId: "thr_command",
-      key: "state",
-      value: { status: "new" },
-      version: sha256(nextContent),
-    });
-    await reporter.observe({
-      threadId: "thr_command",
-      threadStoragePath,
-      key: "state",
-    });
-
-    await fs.rm(path.join(threadStoragePath, "STATUS-data", "state.json"));
-    reporter.recordCommandDelete({
-      threadId: "thr_command",
-      key: "state",
-    });
-    await reporter.observe({
-      threadId: "thr_command",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(postStatusDataChange).not.toHaveBeenCalled();
-  });
-
-  it("logs command results for untracked threads without seeding the cache", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-untracked-command-",
-    );
-    const logger = createLogger();
-    const postStatusDataChange = vi.fn(async () => undefined);
-    const reporter = new StatusDataChangeReporter({
-      logger,
-      postStatusDataChange,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_tracked", threadStoragePath }],
-    });
-
-    reporter.recordCommandSet({
-      threadId: "thr_untracked",
-      key: "state",
-      value: { status: "new" },
-      version: "command-version",
-    });
-    reporter.recordCommandDelete({
-      threadId: "thr_untracked",
-      key: "state",
-    });
-
-    expect(logger.warn).toHaveBeenCalledTimes(2);
-    expect(logger.warn).toHaveBeenCalledWith(
-      {
-        key: "state",
-        threadId: "thr_untracked",
-      },
-      "Ignoring STATUS-data command result for untracked thread",
-    );
-    expect(postStatusDataChange).not.toHaveBeenCalled();
-  });
-
-  it("reconciles missed file watcher events from a thread snapshot", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-reconcile-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const goneContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "gone",
-      value: true,
-    });
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_reconcile", threadStoragePath }],
-    });
-
-    const nextContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "new" },
-    });
-    const addedContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "added",
-      value: 2,
-    });
-    await fs.rm(path.join(threadStoragePath, "STATUS-data", "gone.json"));
-    await reporter.reconcileThread({
-      threadId: "thr_reconcile",
-      threadStoragePath,
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_reconcile",
-        key: "added",
-        deleted: false,
-        value: 2,
-        version: sha256(addedContent),
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      },
-      {
-        threadId: "thr_reconcile",
-        key: "state",
-        deleted: false,
-        value: { status: "new" },
-        version: sha256(nextContent),
-        previousValue: { status: "old" },
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-      {
-        threadId: "thr_reconcile",
-        key: "gone",
-        deleted: true,
-        value: null,
-        version: null,
-        previousValue: true,
-        previousValuePresent: true,
-        previousVersion: sha256(goneContent),
-      },
-    ]);
-  });
-
-  it("reconciles previously tracked thread changes when tracked threads are replaced", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-reconnect-",
-    );
-    const previousContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const goneContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "gone",
-      value: true,
-    });
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_reconnect", threadStoragePath }],
-    });
-
-    const nextContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "new" },
-    });
-    const addedContent = await writeStatusDataFile({
-      threadStoragePath,
-      key: "added",
-      value: 2,
-    });
-    await fs.rm(path.join(threadStoragePath, "STATUS-data", "gone.json"));
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_reconnect", threadStoragePath }],
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_reconnect",
-        key: "added",
-        deleted: false,
-        value: 2,
-        version: sha256(addedContent),
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      },
-      {
-        threadId: "thr_reconnect",
-        key: "state",
-        deleted: false,
-        value: { status: "new" },
-        version: sha256(nextContent),
-        previousValue: { status: "old" },
-        previousValuePresent: true,
-        previousVersion: sha256(previousContent),
-      },
-      {
-        threadId: "thr_reconnect",
-        key: "gone",
-        deleted: true,
-        value: null,
-        version: null,
-        previousValue: true,
-        previousValuePresent: true,
-        previousVersion: sha256(goneContent),
-      },
-    ]);
-  });
-
-  it("reconciles reconnect-created files for previously empty tracked threads", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-empty-reconnect-",
-    );
-    const posted: HostDaemonStatusDataChangePayload[] = [];
-    const reporter = new StatusDataChangeReporter({
-      logger: createLogger(),
-      postStatusDataChange: async (payload) => {
-        posted.push(payload);
-      },
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_empty_reconnect", threadStoragePath }],
-    });
-
-    const content = await writeStatusDataFile({
-      threadStoragePath,
-      key: "progress",
-      value: 1,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_empty_reconnect", threadStoragePath }],
-    });
-
-    expect(posted).toEqual([
-      {
-        threadId: "thr_empty_reconnect",
-        key: "progress",
-        deleted: false,
-        value: 1,
-        version: sha256(content),
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      },
-    ]);
-  });
-
-  it("logs and skips unreadable observed STATUS-data files", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-invalid-",
-    );
-    await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const logger = createLogger();
-    const postStatusDataChange = vi.fn(async () => undefined);
-    const reporter = new StatusDataChangeReporter({
-      logger,
-      postStatusDataChange,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_invalid", threadStoragePath }],
-    });
-
-    await writeRawStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      content: "{",
-    });
-    await reporter.observe({
-      threadId: "thr_invalid",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(postStatusDataChange).not.toHaveBeenCalled();
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        key: "state",
-        threadId: "thr_invalid",
-      }),
-      "Ignoring unreadable observed STATUS-data file",
-    );
-  });
-
-  it("logs and skips oversized observed STATUS-data files", async () => {
-    const threadStoragePath = await makeTempDir(
-      "bb-status-data-reporter-large-",
-    );
-    await writeStatusDataFile({
-      threadStoragePath,
-      key: "state",
-      value: { status: "old" },
-    });
-    const logger = createLogger();
-    const postStatusDataChange = vi.fn(async () => undefined);
-    const reporter = new StatusDataChangeReporter({
-      logger,
-      postStatusDataChange,
-    });
-    await reporter.replaceTrackedThreads({
-      targets: [{ threadId: "thr_large", threadStoragePath }],
-    });
-
-    const statusDataPath = path.join(
-      threadStoragePath,
-      "STATUS-data",
-      "state.json",
-    );
-    await fs.truncate(statusDataPath, NON_IMAGE_FILE_SIZE_LIMIT_BYTES + 1);
-    await reporter.observe({
-      threadId: "thr_large",
-      threadStoragePath,
-      key: "state",
-    });
-
-    expect(postStatusDataChange).not.toHaveBeenCalled();
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        key: "state",
-        threadId: "thr_large",
-      }),
-      "Ignoring unreadable observed STATUS-data file",
-    );
-  });
-});
diff --git a/apps/host-daemon/src/status-data-change-reporter.ts b/apps/host-daemon/src/status-data-change-reporter.ts
deleted file mode 100644
index 30c61a9af..000000000
--- a/apps/host-daemon/src/status-data-change-reporter.ts
+++ /dev/null
@@ -1,437 +0,0 @@
-import path from "node:path";
-import type { HostDaemonStatusDataChangePayload } from "@bb/host-daemon-contract";
-import type { JsonValue, StatusDataKey } from "@bb/domain";
-import { STATUS_DATA_DIRECTORY_NAME } from "@bb/host-watcher";
-import {
-  readStatusDataDirectoryFingerprintFromRoot,
-  readHostStatusDataFromRoot,
-} from "./command-handlers/status-data.js";
-import { CommandDispatchError } from "./command-dispatch-support.js";
-import { runtimeErrorLogFields } from "./error-utils.js";
-import type { HostDaemonLogger } from "./logger.js";
-import {
-  readPreviousValue,
-  statusDataCacheKey,
-  StatusDataCache,
-  type CachedStatusDataValue,
-} from "./status-data-reporter-cache.js";
-import {
-  applyStatusDataSnapshotDiff,
-  shouldSkipUnchangedStatusDataSnapshot,
-} from "./status-data-snapshot-diff.js";
-
-interface CreateStatusDataChangeReporterOptions {
-  logger: HostDaemonLogger;
-  postStatusDataChange: (
-    payload: HostDaemonStatusDataChangePayload,
-  ) => Promise<void>;
-}
-
-interface StatusDataCacheKeyArgs {
-  key: StatusDataKey;
-  threadId: string;
-}
-
-interface ReportObservedDeleteArgs extends StatusDataCacheKeyArgs {
-  generation: number;
-  previous: CachedStatusDataValue | undefined;
-  threadStoragePath: string;
-}
-
-interface ReportObservedChangeArgs {
-  change: ObserveStatusDataChangeArgs;
-  generation: number;
-}
-
-interface PrimeThreadArgs {
-  generation: number;
-  target: TrackedStatusDataThread;
-}
-
-interface ReportThreadSnapshotDiffArgs extends ReconcileThreadStatusDataArgs {
-  generation: number;
-}
-
-interface ApplyThreadSnapshotArgs extends ReconcileThreadStatusDataArgs {
-  generation: number;
-  postChanges: boolean;
-  skipUnchangedFingerprint: boolean;
-}
-
-interface RefreshThreadFingerprintArgs extends ReconcileThreadStatusDataArgs {
-  generation: number;
-}
-
-interface StatusDataReporterGenerationArgs {
-  generation: number;
-}
-
-export interface ObserveStatusDataChangeArgs {
-  key: StatusDataKey;
-  threadId: string;
-  threadStoragePath: string;
-}
-
-export interface TrackedStatusDataThread {
-  threadId: string;
-  threadStoragePath: string;
-}
-
-export interface TrackStatusDataThreadArgs {
-  threadId: string;
-}
-
-export interface ReplaceTrackedStatusDataThreadsArgs {
-  targets: readonly TrackedStatusDataThread[];
-}
-
-export interface ReconcileThreadStatusDataArgs {
-  threadId: string;
-  threadStoragePath: string;
-}
-
-export interface RecordStatusDataCommandSetArgs {
-  key: StatusDataKey;
-  threadId: string;
-  value: JsonValue;
-  version: string;
-}
-
-export interface RecordStatusDataCommandDeleteArgs {
-  key: StatusDataKey;
-  threadId: string;
-}
-
-function isMissingStatusDataEntryError(error: Error): boolean {
-  return error instanceof CommandDispatchError && error.code === "ENOENT";
-}
-
-function isNonReportableStatusDataReadError(error: Error): boolean {
-  return (
-    error instanceof CommandDispatchError &&
-    (error.code === "invalid_json" ||
-      error.code === "invalid_path" ||
-      error.code === "file_too_large")
-  );
-}
-
-export class StatusDataChangeReporter {
-  // This cache tracks values known by the server, not merely values seen on disk.
-  private readonly cache = new StatusDataCache();
-  private readonly pendingByCacheKey = new Map<string, Promise<void>>();
-  private generation = 0;
-
-  constructor(
-    private readonly options: CreateStatusDataChangeReporterOptions,
-  ) {}
-
-  private isCurrentGeneration(args: StatusDataReporterGenerationArgs): boolean {
-    return args.generation === this.generation;
-  }
-
-  async replaceTrackedThreads(
-    args: ReplaceTrackedStatusDataThreadsArgs,
-  ): Promise<void> {
-    this.generation += 1;
-    const generation = this.generation;
-    const nextThreadIds = new Set(
-      args.targets.map((target) => target.threadId),
-    );
-    this.pendingByCacheKey.clear();
-    const previouslyTrackedThreadIds = this.cache.replaceTrackedThreadIds({
-      threadIds: nextThreadIds,
-    });
-    await Promise.all(
-      args.targets.map((target) =>
-        previouslyTrackedThreadIds.has(target.threadId)
-          ? this.reconcileThread(target)
-          : this.primeThread({ generation, target }),
-      ),
-    );
-  }
-
-  trackThread(args: TrackStatusDataThreadArgs): void {
-    this.cache.trackThread({ threadId: args.threadId });
-  }
-
-  recordCommandSet(args: RecordStatusDataCommandSetArgs): void {
-    if (!this.cache.isTracked({ threadId: args.threadId })) {
-      this.options.logger.warn(
-        {
-          key: args.key,
-          threadId: args.threadId,
-        },
-        "Ignoring STATUS-data command result for untracked thread",
-      );
-      return;
-    }
-    this.cache.setValue({
-      key: args.key,
-      threadId: args.threadId,
-      value: args.value,
-      version: args.version,
-    });
-  }
-
-  recordCommandDelete(args: RecordStatusDataCommandDeleteArgs): void {
-    if (!this.cache.isTracked({ threadId: args.threadId })) {
-      this.options.logger.warn(
-        {
-          key: args.key,
-          threadId: args.threadId,
-        },
-        "Ignoring STATUS-data command result for untracked thread",
-      );
-      return;
-    }
-    this.cache.deleteValue({ key: args.key, threadId: args.threadId });
-  }
-
-  async reconcileThread(args: ReconcileThreadStatusDataArgs): Promise<void> {
-    if (!this.cache.isTracked({ threadId: args.threadId })) {
-      return;
-    }
-    const generation = this.generation;
-    try {
-      await this.reportThreadSnapshotDiff({
-        ...args,
-        generation,
-      });
-    } catch (error) {
-      this.options.logger.warn(
-        {
-          threadId: args.threadId,
-          threadStoragePath: args.threadStoragePath,
-          ...runtimeErrorLogFields(error),
-        },
-        "Failed to reconcile STATUS-data changes",
-      );
-    }
-  }
-
-  observe(args: ObserveStatusDataChangeArgs): Promise<void> {
-    const cacheKey = statusDataCacheKey(args);
-    const generation = this.generation;
-    const previous = this.pendingByCacheKey.get(cacheKey) ?? Promise.resolve();
-    const pending = previous
-      .catch(() => undefined)
-      .then(() =>
-        this.reportObservedChange({
-          change: args,
-          generation,
-        }),
-      )
-      .catch((error) => {
-        this.options.logger.warn(
-          {
-            key: args.key,
-            threadId: args.threadId,
-            ...runtimeErrorLogFields(error),
-          },
-          "Failed to report observed STATUS-data change",
-        );
-      })
-      .finally(() => {
-        if (this.pendingByCacheKey.get(cacheKey) === pending) {
-          this.pendingByCacheKey.delete(cacheKey);
-        }
-      });
-    this.pendingByCacheKey.set(cacheKey, pending);
-    return pending;
-  }
-
-  private async primeThread(args: PrimeThreadArgs): Promise<void> {
-    try {
-      await this.applyThreadSnapshot({
-        generation: args.generation,
-        postChanges: false,
-        skipUnchangedFingerprint: false,
-        threadId: args.target.threadId,
-        threadStoragePath: args.target.threadStoragePath,
-      });
-    } catch (error) {
-      this.options.logger.warn(
-        {
-          threadId: args.target.threadId,
-          threadStoragePath: args.target.threadStoragePath,
-          ...runtimeErrorLogFields(error),
-        },
-        "Failed to prime STATUS-data change cache",
-      );
-    }
-  }
-
-  private async reportObservedChange(
-    args: ReportObservedChangeArgs,
-  ): Promise<void> {
-    if (args.generation !== this.generation) {
-      return;
-    }
-    const previous = this.cache.getValue({
-      key: args.change.key,
-      threadId: args.change.threadId,
-    });
-
-    try {
-      const entry = await readHostStatusDataFromRoot({
-        rootPath: args.change.threadStoragePath,
-        key: args.change.key,
-      });
-      if (args.generation !== this.generation) {
-        return;
-      }
-      if (previous?.version === entry.version) {
-        return;
-      }
-      await this.options.postStatusDataChange({
-        threadId: args.change.threadId,
-        key: args.change.key,
-        deleted: false,
-        value: entry.value,
-        version: entry.version,
-        ...readPreviousValue(previous),
-      });
-      if (args.generation !== this.generation) {
-        return;
-      }
-      this.cache.setValue({
-        key: args.change.key,
-        threadId: args.change.threadId,
-        value: entry.value,
-        version: entry.version,
-      });
-      await this.refreshThreadFingerprint({
-        generation: args.generation,
-        threadId: args.change.threadId,
-        threadStoragePath: args.change.threadStoragePath,
-      });
-      return;
-    } catch (error) {
-      if (error instanceof Error && isMissingStatusDataEntryError(error)) {
-        await this.reportObservedDelete({
-          generation: args.generation,
-          key: args.change.key,
-          previous,
-          threadId: args.change.threadId,
-          threadStoragePath: args.change.threadStoragePath,
-        });
-        return;
-      }
-      if (error instanceof Error && isNonReportableStatusDataReadError(error)) {
-        this.options.logger.warn(
-          {
-            key: args.change.key,
-            statusDataPath: path.join(
-              args.change.threadStoragePath,
-              STATUS_DATA_DIRECTORY_NAME,
-              `${args.change.key}.json`,
-            ),
-            threadId: args.change.threadId,
-            ...runtimeErrorLogFields(error),
-          },
-          "Ignoring unreadable observed STATUS-data file",
-        );
-        return;
-      }
-      throw error;
-    }
-  }
-
-  private async reportObservedDelete(
-    args: ReportObservedDeleteArgs,
-  ): Promise<void> {
-    if (args.generation !== this.generation || args.previous === undefined) {
-      return;
-    }
-    await this.options.postStatusDataChange({
-      threadId: args.threadId,
-      key: args.key,
-      deleted: true,
-      value: null,
-      version: null,
-      ...readPreviousValue(args.previous),
-    });
-    if (args.generation !== this.generation) {
-      return;
-    }
-    this.cache.deleteValue({ key: args.key, threadId: args.threadId });
-    await this.refreshThreadFingerprint({
-      generation: args.generation,
-      threadId: args.threadId,
-      threadStoragePath: args.threadStoragePath,
-    });
-  }
-
-  private async refreshThreadFingerprint(
-    args: RefreshThreadFingerprintArgs,
-  ): Promise<void> {
-    try {
-      const fingerprint = await readStatusDataDirectoryFingerprintFromRoot({
-        rootPath: args.threadStoragePath,
-      });
-      if (args.generation !== this.generation) {
-        return;
-      }
-      this.cache.setFingerprint({
-        fingerprint,
-        threadId: args.threadId,
-      });
-    } catch (error) {
-      this.options.logger.warn(
-        {
-          threadId: args.threadId,
-          threadStoragePath: args.threadStoragePath,
-          ...runtimeErrorLogFields(error),
-        },
-        "Failed to refresh STATUS-data directory fingerprint",
-      );
-    }
-  }
-
-  private async reportThreadSnapshotDiff(
-    args: ReportThreadSnapshotDiffArgs,
-  ): Promise<void> {
-    await this.applyThreadSnapshot({
-      ...args,
-      postChanges: true,
-      skipUnchangedFingerprint: true,
-    });
-  }
-
-  private async applyThreadSnapshot(
-    args: ApplyThreadSnapshotArgs,
-  ): Promise<void> {
-    if (!this.isCurrentGeneration({ generation: args.generation })) {
-      return;
-    }
-    if (
-      args.skipUnchangedFingerprint &&
-      (await shouldSkipUnchangedStatusDataSnapshot({
-        cache: this.cache,
-        generation: args.generation,
-        isCurrentGeneration: (generationArgs) =>
-          this.isCurrentGeneration(generationArgs),
-        threadId: args.threadId,
-        threadStoragePath: args.threadStoragePath,
-      }))
-    ) {
-      return;
-    }
-
-    await applyStatusDataSnapshotDiff({
-      cache: this.cache,
-      generation: args.generation,
-      isCurrentGeneration: (generationArgs) =>
-        this.isCurrentGeneration(generationArgs),
-      postChanges: args.postChanges,
-      postStatusDataChange: (payload) =>
-        this.options.postStatusDataChange(payload),
-      threadId: args.threadId,
-      threadStoragePath: args.threadStoragePath,
-    });
-    if (!this.isCurrentGeneration({ generation: args.generation })) {
-      return;
-    }
-    await this.refreshThreadFingerprint(args);
-  }
-}
diff --git a/apps/host-daemon/src/status-data-reporter-cache.ts b/apps/host-daemon/src/status-data-reporter-cache.ts
deleted file mode 100644
index 7d2c1dfb0..000000000
--- a/apps/host-daemon/src/status-data-reporter-cache.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import type { JsonValue, StatusDataKey } from "@bb/domain";
-import type { StatusDataDirectoryFingerprint } from "./command-handlers/status-data.js";
-
-export interface CachedStatusDataValue {
-  value: JsonValue;
-  version: string;
-}
-
-export interface StatusDataCacheKeyArgs {
-  key: StatusDataKey;
-  threadId: string;
-}
-
-export interface CachedStatusDataKey {
-  cacheKey: string;
-  key: StatusDataKey;
-}
-
-export interface SetCachedStatusDataValueArgs
-  extends StatusDataCacheKeyArgs,
-    CachedStatusDataValue {}
-
-export interface ThreadIdArgs {
-  threadId: string;
-}
-
-export interface ReplaceTrackedThreadIdsArgs {
-  threadIds: ReadonlySet<string>;
-}
-
-export interface SetThreadFingerprintArgs extends ThreadIdArgs {
-  fingerprint: StatusDataDirectoryFingerprint | null;
-}
-
-export interface StatusDataPreviousMetadata {
-  previousValue: JsonValue | null;
-  previousValuePresent: boolean;
-  previousVersion: string | null;
-}
-
-export function statusDataCacheKey(args: StatusDataCacheKeyArgs): string {
-  return `${args.threadId}\0${args.key}`;
-}
-
-export function readPreviousValue(
-  cached: CachedStatusDataValue | undefined,
-): StatusDataPreviousMetadata {
-  return {
-    previousValue: cached?.value ?? null,
-    previousValuePresent: cached !== undefined,
-    previousVersion: cached?.version ?? null,
-  };
-}
-
-export class StatusDataCache {
-  private readonly values = new Map<string, CachedStatusDataValue>();
-  private readonly fingerprintsByThreadId = new Map<
-    string,
-    StatusDataDirectoryFingerprint | null
-  >();
-  private readonly keysByThreadId = new Map<string, Set<StatusDataKey>>();
-  // Threads remain tracked even when they have no STATUS-data keys yet.
-  private readonly trackedThreadIds = new Set<string>();
-
-  replaceTrackedThreadIds(args: ReplaceTrackedThreadIdsArgs): Set<string> {
-    const previouslyTrackedThreadIds = new Set(this.trackedThreadIds);
-    this.pruneUntrackedThreadState(args);
-    this.trackedThreadIds.clear();
-    for (const threadId of args.threadIds) {
-      this.trackedThreadIds.add(threadId);
-    }
-    return previouslyTrackedThreadIds;
-  }
-
-  trackThread(args: ThreadIdArgs): void {
-    this.trackedThreadIds.add(args.threadId);
-  }
-
-  isTracked(args: ThreadIdArgs): boolean {
-    return this.trackedThreadIds.has(args.threadId);
-  }
-
-  getValue(args: StatusDataCacheKeyArgs): CachedStatusDataValue | undefined {
-    return this.values.get(statusDataCacheKey(args));
-  }
-
-  setValue(args: SetCachedStatusDataValueArgs): void {
-    this.values.set(statusDataCacheKey(args), {
-      value: args.value,
-      version: args.version,
-    });
-    let keys = this.keysByThreadId.get(args.threadId);
-    if (!keys) {
-      keys = new Set<StatusDataKey>();
-      this.keysByThreadId.set(args.threadId, keys);
-    }
-    keys.add(args.key);
-  }
-
-  deleteValue(args: StatusDataCacheKeyArgs): void {
-    this.values.delete(statusDataCacheKey(args));
-    const keys = this.keysByThreadId.get(args.threadId);
-    if (!keys) {
-      return;
-    }
-    keys.delete(args.key);
-    if (keys.size === 0) {
-      this.keysByThreadId.delete(args.threadId);
-    }
-  }
-
-  cachedKeysForThread(args: ThreadIdArgs): CachedStatusDataKey[] {
-    return Array.from(this.keysByThreadId.get(args.threadId) ?? [])
-      .sort()
-      .map((key) => ({
-        key,
-        cacheKey: statusDataCacheKey({ key, threadId: args.threadId }),
-      }));
-  }
-
-  hasFingerprint(args: ThreadIdArgs): boolean {
-    return this.fingerprintsByThreadId.has(args.threadId);
-  }
-
-  getFingerprint(
-    args: ThreadIdArgs,
-  ): StatusDataDirectoryFingerprint | null | undefined {
-    return this.fingerprintsByThreadId.get(args.threadId);
-  }
-
-  setFingerprint(args: SetThreadFingerprintArgs): void {
-    this.fingerprintsByThreadId.set(args.threadId, args.fingerprint);
-  }
-
-  private pruneUntrackedThreadState(args: ReplaceTrackedThreadIdsArgs): void {
-    for (const threadId of Array.from(this.trackedThreadIds)) {
-      if (args.threadIds.has(threadId)) {
-        continue;
-      }
-      for (const cached of this.cachedKeysForThread({ threadId })) {
-        this.values.delete(cached.cacheKey);
-      }
-      this.fingerprintsByThreadId.delete(threadId);
-      this.keysByThreadId.delete(threadId);
-      this.trackedThreadIds.delete(threadId);
-    }
-  }
-}
diff --git a/apps/host-daemon/src/status-data-snapshot-diff.ts b/apps/host-daemon/src/status-data-snapshot-diff.ts
deleted file mode 100644
index 52ad1f7fd..000000000
--- a/apps/host-daemon/src/status-data-snapshot-diff.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import type { HostDaemonStatusDataChangePayload } from "@bb/host-daemon-contract";
-import { statusDataKeySchema, type StatusDataKey } from "@bb/domain";
-import {
-  listHostStatusDataFromRoot,
-  readStatusDataDirectoryFingerprintFromRoot,
-} from "./command-handlers/status-data.js";
-import {
-  readPreviousValue,
-  type StatusDataCache,
-} from "./status-data-reporter-cache.js";
-
-export interface StatusDataSnapshotGenerationArgs {
-  generation: number;
-}
-
-export type StatusDataSnapshotGenerationGuard = (
-  args: StatusDataSnapshotGenerationArgs,
-) => boolean;
-
-export type PostStatusDataChange = (
-  payload: HostDaemonStatusDataChangePayload,
-) => Promise<void>;
-
-export interface ShouldSkipUnchangedStatusDataSnapshotArgs {
-  cache: StatusDataCache;
-  generation: number;
-  isCurrentGeneration: StatusDataSnapshotGenerationGuard;
-  threadId: string;
-  threadStoragePath: string;
-}
-
-export interface ApplyStatusDataSnapshotDiffArgs {
-  cache: StatusDataCache;
-  generation: number;
-  isCurrentGeneration: StatusDataSnapshotGenerationGuard;
-  postChanges: boolean;
-  postStatusDataChange: PostStatusDataChange;
-  threadId: string;
-  threadStoragePath: string;
-}
-
-export async function shouldSkipUnchangedStatusDataSnapshot(
-  args: ShouldSkipUnchangedStatusDataSnapshotArgs,
-): Promise<boolean> {
-  const currentFingerprint = await readStatusDataDirectoryFingerprintFromRoot({
-    rootPath: args.threadStoragePath,
-  });
-  if (!args.isCurrentGeneration({ generation: args.generation })) {
-    return true;
-  }
-  return (
-    args.cache.hasFingerprint({ threadId: args.threadId }) &&
-    args.cache.getFingerprint({ threadId: args.threadId }) ===
-      currentFingerprint
-  );
-}
-
-export async function applyStatusDataSnapshotDiff(
-  args: ApplyStatusDataSnapshotDiffArgs,
-): Promise<void> {
-  const result = await listHostStatusDataFromRoot({
-    rootPath: args.threadStoragePath,
-  });
-  if (!args.isCurrentGeneration({ generation: args.generation })) {
-    return;
-  }
-  const seenKeys = new Set<StatusDataKey>();
-
-  for (const rawKey of Object.keys(result.versions).sort()) {
-    if (!args.isCurrentGeneration({ generation: args.generation })) {
-      return;
-    }
-    const key = statusDataKeySchema.parse(rawKey);
-    const value = result.values[key];
-    const version = result.versions[key];
-    if (value === undefined || version === undefined) {
-      continue;
-    }
-    seenKeys.add(key);
-    const previous = args.cache.getValue({ key, threadId: args.threadId });
-    if (previous?.version === version) {
-      continue;
-    }
-    if (args.postChanges) {
-      await args.postStatusDataChange({
-        threadId: args.threadId,
-        key,
-        deleted: false,
-        value,
-        version,
-        ...readPreviousValue(previous),
-      });
-      if (!args.isCurrentGeneration({ generation: args.generation })) {
-        return;
-      }
-    }
-    args.cache.setValue({
-      key,
-      threadId: args.threadId,
-      value,
-      version,
-    });
-  }
-
-  for (const cached of args.cache.cachedKeysForThread({
-    threadId: args.threadId,
-  })) {
-    if (!args.isCurrentGeneration({ generation: args.generation })) {
-      return;
-    }
-    if (seenKeys.has(cached.key)) {
-      continue;
-    }
-    const previous = args.cache.getValue({
-      key: cached.key,
-      threadId: args.threadId,
-    });
-    if (previous === undefined) {
-      continue;
-    }
-    if (args.postChanges) {
-      await args.postStatusDataChange({
-        threadId: args.threadId,
-        key: cached.key,
-        deleted: true,
-        value: null,
-        version: null,
-        ...readPreviousValue(previous),
-      });
-      if (!args.isCurrentGeneration({ generation: args.generation })) {
-        return;
-      }
-    }
-    args.cache.deleteValue({ key: cached.key, threadId: args.threadId });
-  }
-}
diff --git a/apps/host-daemon/test/command/command-router.test.ts b/apps/host-daemon/test/command/command-router.test.ts
index 2e529c469..8e9944784 100644
--- a/apps/host-daemon/test/command/command-router.test.ts
+++ b/apps/host-daemon/test/command/command-router.test.ts
@@ -333,7 +333,7 @@ describe("CommandRouter", () => {
 
   it("reports missing host file reads without warning", async () => {
     const rootPath = await makeTempDir("bb-command-router-read-file-");
-    const missingPath = path.join(rootPath, "STATUS.md");
+    const missingPath = path.join(rootPath, "notes.md");
     const reportResult = vi.fn(async () => undefined);
     const logger = createLogger();
     const router = new CommandRouter({
@@ -350,7 +350,7 @@ describe("CommandRouter", () => {
 
     await router.handleCommands([
       {
-        id: "read-missing-status",
+        id: "read-missing-file",
         cursor: 1,
         command: {
           type: "host.read_file",
@@ -362,7 +362,7 @@ describe("CommandRouter", () => {
 
     expect(reportResult).toHaveBeenCalledWith(
       expect.objectContaining({
-        commandId: "read-missing-status",
+        commandId: "read-missing-file",
         errorCode: "ENOENT",
         errorMessage: `Path does not exist: ${missingPath}`,
         ok: false,
@@ -375,7 +375,7 @@ describe("CommandRouter", () => {
   it("reports missing host file roots without warning", async () => {
     const parentPath = await makeTempDir("bb-command-router-read-file-root-");
     const rootPath = path.join(parentPath, "missing-root");
-    const missingPath = path.join(rootPath, "STATUS.md");
+    const missingPath = path.join(rootPath, "notes.md");
     const reportResult = vi.fn(async () => undefined);
     const logger = createLogger();
     const router = new CommandRouter({
@@ -392,7 +392,7 @@ describe("CommandRouter", () => {
 
     await router.handleCommands([
       {
-        id: "read-missing-root-status",
+        id: "read-missing-root-file",
         cursor: 1,
         command: {
           type: "host.read_file",
@@ -404,7 +404,7 @@ describe("CommandRouter", () => {
 
     expect(reportResult).toHaveBeenCalledWith(
       expect.objectContaining({
-        commandId: "read-missing-root-status",
+        commandId: "read-missing-root-file",
         errorCode: "ENOENT",
         errorMessage: `Path does not exist: ${missingPath}`,
         ok: false,
@@ -416,7 +416,7 @@ describe("CommandRouter", () => {
 
   it("reports missing host relative file reads without warning", async () => {
     const parentPath = await makeTempDir("bb-command-router-relative-file-");
-    const rootPath = path.join(parentPath, "STATUS");
+    const rootPath = path.join(parentPath, "assets");
     const reportResult = vi.fn(async () => undefined);
     const logger = createLogger();
     const router = new CommandRouter({
@@ -703,8 +703,8 @@ describe("CommandRouter", () => {
   });
 
   it("serializes relative host file writes with last-write-wins behavior", async () => {
-    const rootPath = await makeTempDir("bb-command-router-status-data-");
-    const initialContent = "[\"seed\"]\n";
+    const rootPath = await makeTempDir("bb-command-router-app-data-");
+    const initialContent = '["seed"]\n';
     await fs.writeFile(path.join(rootPath, "todos.json"), initialContent);
     const reports: HostDaemonCommandResultReportWithoutSession[] = [];
     const router = new CommandRouter({
@@ -730,7 +730,7 @@ describe("CommandRouter", () => {
           rootPath,
           path: "todos.json",
           dotfiles: "deny",
-          content: "[\"a\"]\n",
+          content: '["a"]\n',
           contentEncoding: "utf8",
         },
       },
@@ -742,7 +742,7 @@ describe("CommandRouter", () => {
           rootPath,
           path: "todos.json",
           dotfiles: "deny",
-          content: "[\"b\"]\n",
+          content: '["b"]\n',
           contentEncoding: "utf8",
         },
       },
@@ -753,7 +753,7 @@ describe("CommandRouter", () => {
     const finalContent = await fs.readFile(path.join(rootPath, "todos.json"), {
       encoding: "utf8",
     });
-    expect(finalContent).toBe("[\"b\"]\n");
+    expect(finalContent).toBe('["b"]\n');
   });
 
   it("flushes buffered provider events before reporting thread command results", async () => {
diff --git a/apps/server/src/internal/command-result-owners.ts b/apps/server/src/internal/command-result-owners.ts
index d398f3c44..03929c1e4 100644
--- a/apps/server/src/internal/command-result-owners.ts
+++ b/apps/server/src/internal/command-result-owners.ts
@@ -748,11 +748,6 @@ const commandResultOwners: CommandResultOwnerRegistry = {
   "host.write_file_relative": null,
   "host.delete_file_relative": null,
   "host.delete_path_relative": null,
-  "host.status_version": null,
-  "host.status_data.list": null,
-  "host.status_data.get": null,
-  "host.status_data.set": null,
-  "host.status_data.delete": null,
   "codex.inference.complete": null,
   "interactive.resolve": defineCommandResultOwner({
     applySideEffects: handleInteractiveResolveResult,
diff --git a/apps/server/src/internal/status-data-changes.ts b/apps/server/src/internal/status-data-changes.ts
deleted file mode 100644
index 188f8e415..000000000
--- a/apps/server/src/internal/status-data-changes.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import {
-  hostDaemonStatusDataChangeRequestSchema,
-  typedRoutes,
-  type HostDaemonInternalSchema,
-} from "@bb/host-daemon-contract";
-import type { Hono } from "hono";
-import type { AppDeps } from "../types.js";
-import { ApiError } from "../errors.js";
-import {
-  requireEnvironment,
-  requirePublicThread,
-} from "../services/lib/entity-lookup.js";
-import { runWithDaemonCommandWaitForbidden } from "../services/hosts/command-wait-context.js";
-import { requireAuthenticatedDaemonSession } from "./session-state.js";
-
-export function registerInternalStatusDataChangeRoutes(
-  app: Hono,
-  deps: AppDeps,
-): void {
-  const { post } = typedRoutes<HostDaemonInternalSchema>(app, {
-    onValidationError: (msg) => new ApiError(400, "invalid_request", msg),
-  });
-
-  post(
-    "/session/status-data-change",
-    hostDaemonStatusDataChangeRequestSchema,
-    (context, payload) =>
-      runWithDaemonCommandWaitForbidden({
-        reason: "/session/status-data-change",
-        work: async () => {
-          const session = requireAuthenticatedDaemonSession({
-            context,
-            db: deps.db,
-            sessionId: payload.sessionId,
-          });
-          const thread = requirePublicThread(deps.db, payload.threadId);
-          if (!thread.environmentId) {
-            throw new ApiError(
-              403,
-              "invalid_request",
-              "Thread does not belong to an environment",
-            );
-          }
-          const environment = requireEnvironment(deps.db, thread.environmentId);
-          if (environment.hostId !== session.hostId) {
-            throw new ApiError(
-              403,
-              "invalid_request",
-              "Thread does not belong to the session host",
-            );
-          }
-
-          deps.hub.notifyThreadStatusData({
-            type: "status-data.changed",
-            threadId: payload.threadId,
-            key: payload.key,
-            value: payload.value,
-            deleted: payload.deleted,
-            previousValue: payload.previousValue,
-            previousValuePresent: payload.previousValuePresent,
-            version: payload.version,
-            writerClientId: null,
-            operationId: null,
-          });
-          return context.json({ ok: true });
-        },
-      }),
-  );
-}
diff --git a/apps/server/src/routes/threads/data.ts b/apps/server/src/routes/threads/data.ts
index 508769e74..755b2298b 100644
--- a/apps/server/src/routes/threads/data.ts
+++ b/apps/server/src/routes/threads/data.ts
@@ -1,11 +1,6 @@
-import { Buffer } from "node:buffer";
 import path from "node:path";
 import { listQueuedThreadMessages } from "@bb/db";
-import {
-  FILE_LIST_LIMIT_MAX,
-  type HostDaemonCommand,
-  type HostReadFileRelativeDotfilePolicy,
-} from "@bb/host-daemon-contract";
+import { FILE_LIST_LIMIT_MAX } from "@bb/host-daemon-contract";
 import type { Hono } from "hono";
 import { PROMPT_HISTORY_ENTRY_LIMIT, threadEventTypeSchema } from "@bb/domain";
 import {
@@ -21,7 +16,6 @@ import {
   typedRoutes,
   type PublicApiSchema,
   type ThreadComposerBootstrapResponse,
-  type ThreadStatusVersionResponse,
   type ThreadTimelineQuery,
 } from "@bb/server-contract";
 import type {
@@ -43,7 +37,6 @@ import {
 import { queueCommandAndWait } from "../../services/hosts/command-wait.js";
 import {
   createDaemonFileContentResponse,
-  decodeDaemonFileContent,
   type DaemonFileReadResult,
   remapDaemonFileRouteError,
 } from "../../services/hosts/daemon-file-response.js";
@@ -66,10 +59,6 @@ import {
 import { getLastExecutionOptions } from "../../services/threads/thread-events.js";
 import { resolveSystemExecutionOptions } from "../../services/system/execution-options.js";
 import { listThreadPromptHistory } from "../../services/prompt-history.js";
-import {
-  injectStatusStateClientScript,
-  type StatusStateBootstrap,
-} from "../../services/threads/status-state-client-script.js";
 import {
   parseInteger,
   parseOptionalInteger,
@@ -152,41 +141,15 @@ interface RequireThreadStorageTargetArgs {
   threadId: string;
 }
 
-interface ReadThreadStorageStatusFileArgs {
-  target: ThreadStorageTarget;
-  rootPath: string;
-  relativePath: string;
-  dotfiles: HostReadFileRelativeDotfilePolicy;
-}
-
-type HostStatusVersionCommand = Extract<
-  HostDaemonCommand,
-  { type: "host.status_version" }
->;
-
-type StatusAssetPath = SafeRelativeRoutePath;
 type RawFileRoutePath = SafeRelativeRoutePath;
 
-const STATUS_DIRECTORY_NAME = "STATUS";
-const STATUS_INDEX_FILE_PATH = "index.html";
-const STATUS_HTML_FILE_PATH = "STATUS.html";
-const STATUS_MARKDOWN_FILE_PATH = "STATUS.md";
-const STATUS_ROUTE_SEGMENT = "/status/";
 const THREAD_STORAGE_FILE_ROUTE_SEGMENT = "/thread-storage/files/";
 const THREAD_WORKTREE_FILE_ROUTE_SEGMENT = "/worktree/files/";
-const STATUS_NO_STORE_CACHE_CONTROL = "no-store";
-const STATUS_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
-const STATUS_CONTENT_TYPE_OPTIONS = "nosniff";
+const RAW_FILE_NO_STORE_CACHE_CONTROL = "no-store";
+const RAW_FILE_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
+const RAW_FILE_CONTENT_TYPE_OPTIONS = "nosniff";
 const HTML_PREVIEW_MAX_BYTES = 5 * 1024 * 1024;
 const GENERIC_HTML_PREVIEW_CSP = "sandbox allow-scripts";
-const UNUSABLE_STATUS_SOURCE_ERROR_CODES = new Set([
-  "EACCES",
-  "ELOOP",
-  "ENOENT",
-  "ENOTDIR",
-  "EPERM",
-  "invalid_path",
-]);
 
 function parseThreadStorageFileListLimit(rawLimit: string | undefined): number {
   const limit = Math.min(
@@ -283,15 +246,6 @@ export async function requireThreadStorageTarget(
   };
 }
 
-function parseStatusAssetPath(rawPath: string): StatusAssetPath {
-  return parseSafeRelativeRoutePath({
-    rawPath,
-    directoryIndexPath: STATUS_INDEX_FILE_PATH,
-    dotfileSegmentPolicy: "not-found",
-    invalidPathMessage: "Invalid status asset path",
-  });
-}
-
 function parseRawFileRoutePath(rawPath: string): RawFileRoutePath {
   return parseSafeRelativeRoutePath({
     rawPath,
@@ -300,13 +254,6 @@ function parseRawFileRoutePath(rawPath: string): RawFileRoutePath {
   });
 }
 
-function extractThreadStatusPath(requestUrl: string): string {
-  return extractRoutePath({
-    requestUrl,
-    routeSegment: STATUS_ROUTE_SEGMENT,
-  });
-}
-
 function extractRawFileRoutePath(
   requestUrl: string,
   routeSegment: string,
@@ -317,180 +264,6 @@ function extractRawFileRoutePath(
   });
 }
 
-function shouldFallbackStatusRead(error: unknown): boolean {
-  return (
-    error instanceof ApiError &&
-    UNUSABLE_STATUS_SOURCE_ERROR_CODES.has(error.body.code)
-  );
-}
-
-function remapStatusAssetReadError(error: unknown): never {
-  if (!(error instanceof ApiError)) {
-    throw error;
-  }
-
-  if (error.body.code === "ENOENT") {
-    throw new ApiError(
-      404,
-      error.body.code,
-      error.body.message,
-      error.body.retryable,
-    );
-  }
-  if (error.body.code === "invalid_path") {
-    throw new ApiError(
-      400,
-      error.body.code,
-      error.body.message,
-      error.body.retryable,
-    );
-  }
-  throw error;
-}
-
-async function readThreadStorageStatusFile(
-  deps: LoggedWorkSessionDeps,
-  args: ReadThreadStorageStatusFileArgs,
-): Promise<DaemonFileReadResult> {
-  return queueCommandAndWait(deps, {
-    hostId: args.target.hostId,
-    timeoutMs: COMMAND_TIMEOUT_MS,
-    command: {
-      type: "host.read_file_relative",
-      rootPath: args.rootPath,
-      path: args.relativePath,
-      dotfiles: args.dotfiles,
-    },
-  });
-}
-
-async function tryReadThreadStorageStatusFile(
-  deps: LoggedWorkSessionDeps,
-  args: ReadThreadStorageStatusFileArgs,
-): Promise<DaemonFileReadResult | null> {
-  try {
-    return await readThreadStorageStatusFile(deps, args);
-  } catch (error) {
-    if (shouldFallbackStatusRead(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-function buildStatusVersionCommand(
-  target: ThreadStorageTarget,
-): HostStatusVersionCommand {
-  return {
-    type: "host.status_version",
-    sources: [
-      {
-        source: "folder",
-        rootPath: path.join(target.storagePath, STATUS_DIRECTORY_NAME),
-        indexPath: STATUS_INDEX_FILE_PATH,
-        dotfiles: "deny",
-      },
-      {
-        source: "html",
-        rootPath: target.storagePath,
-        path: STATUS_HTML_FILE_PATH,
-        dotfiles: "allow",
-      },
-      {
-        source: "md",
-        rootPath: target.storagePath,
-        path: STATUS_MARKDOWN_FILE_PATH,
-        dotfiles: "allow",
-      },
-    ],
-  };
-}
-
-async function readThreadStatusVersion(
-  deps: LoggedWorkSessionDeps,
-  threadId: string,
-): Promise<ThreadStatusVersionResponse> {
-  const target = await requireThreadStorageTarget(deps, { threadId });
-  return queueCommandAndWait(deps, {
-    hostId: target.hostId,
-    timeoutMs: COMMAND_TIMEOUT_MS,
-    command: buildStatusVersionCommand(target),
-  });
-}
-
-function createStatusHtmlResponse(html: string): Response {
-  return new Response(html, {
-    status: 200,
-    headers: {
-      "cache-control": STATUS_NO_STORE_CACHE_CONTROL,
-      "content-type": STATUS_HTML_CONTENT_TYPE,
-      "x-content-type-options": STATUS_CONTENT_TYPE_OPTIONS,
-    },
-  });
-}
-
-function buildStatusStateWebSocketUrl(
-  deps: LoggedWorkSessionDeps,
-  requestUrl: string,
-): string {
-  if (deps.config.isDevelopment) {
-    return `ws://localhost:${deps.config.serverPort}/ws`;
-  }
-  const url = new URL(requestUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.pathname = "/ws";
-  url.search = "";
-  url.hash = "";
-  return url.toString();
-}
-
-function buildStatusStateBootstrap(
-  deps: LoggedWorkSessionDeps,
-  args: {
-    requestUrl: string;
-    threadId: string;
-  },
-): StatusStateBootstrap {
-  return {
-    threadId: args.threadId,
-    listUrl: `/api/v1/threads/${encodeURIComponent(args.threadId)}/status-data`,
-    mutationUrl: `/api/v1/threads/${encodeURIComponent(args.threadId)}/status-state`,
-    sendMessageUrl: `/api/v1/threads/${encodeURIComponent(args.threadId)}/send`,
-    wsUrl: buildStatusStateWebSocketUrl(deps, args.requestUrl),
-  };
-}
-
-function createInjectedStatusHtmlResponse(
-  deps: LoggedWorkSessionDeps,
-  args: {
-    html: string;
-    requestUrl: string;
-    threadId: string;
-  },
-): Response {
-  return createStatusHtmlResponse(
-    injectStatusStateClientScript(
-      args.html,
-      buildStatusStateBootstrap(deps, {
-        requestUrl: args.requestUrl,
-        threadId: args.threadId,
-      }),
-    ),
-  );
-}
-
-function createStatusFileResponse(
-  result: DaemonFileReadResult,
-  cacheControl: string,
-): Response {
-  return createDaemonFileContentResponse(result, {
-    headers: {
-      "cache-control": cacheControl,
-      "x-content-type-options": STATUS_CONTENT_TYPE_OPTIONS,
-    },
-  });
-}
-
 function isHtmlPreviewPath(relativePath: string): boolean {
   return relativePath.toLowerCase().endsWith(".html");
 }
@@ -512,87 +285,16 @@ function createRawFilePreviewResponse(
 ): Response {
   assertHtmlPreviewSize(relativePath, result.sizeBytes);
   const headers = new Headers({
-    "cache-control": STATUS_NO_STORE_CACHE_CONTROL,
-    "x-content-type-options": STATUS_CONTENT_TYPE_OPTIONS,
+    "cache-control": RAW_FILE_NO_STORE_CACHE_CONTROL,
+    "x-content-type-options": RAW_FILE_CONTENT_TYPE_OPTIONS,
   });
   if (isHtmlPreviewPath(relativePath)) {
     headers.set("content-security-policy", GENERIC_HTML_PREVIEW_CSP);
-    headers.set("content-type", STATUS_HTML_CONTENT_TYPE);
+    headers.set("content-type", RAW_FILE_HTML_CONTENT_TYPE);
   }
   return createDaemonFileContentResponse(result, { headers });
 }
 
-function decodeDaemonTextFile(result: DaemonFileReadResult): string {
-  return Buffer.from(decodeDaemonFileContent(result)).toString("utf8");
-}
-
-function createStatusNoRawHtmlError(): ApiError {
-  return new ApiError(
-    404,
-    "ENOENT",
-    "No raw manager status HTML source exists",
-  );
-}
-
-async function serveThreadStatusRoot(
-  deps: LoggedWorkSessionDeps,
-  threadId: string,
-  requestUrl: string,
-): Promise<Response> {
-  const target = await requireThreadStorageTarget(deps, { threadId });
-  const statusRootPath = path.join(target.storagePath, STATUS_DIRECTORY_NAME);
-  const statusIndex = await tryReadThreadStorageStatusFile(deps, {
-    target,
-    rootPath: statusRootPath,
-    relativePath: STATUS_INDEX_FILE_PATH,
-    dotfiles: "deny",
-  });
-  if (statusIndex) {
-    return createInjectedStatusHtmlResponse(deps, {
-      requestUrl,
-      threadId,
-      html: decodeDaemonTextFile(statusIndex),
-    });
-  }
-
-  const statusHtml = await tryReadThreadStorageStatusFile(deps, {
-    target,
-    rootPath: target.storagePath,
-    relativePath: STATUS_HTML_FILE_PATH,
-    dotfiles: "allow",
-  });
-  if (statusHtml) {
-    return createInjectedStatusHtmlResponse(deps, {
-      requestUrl,
-      threadId,
-      html: decodeDaemonTextFile(statusHtml),
-    });
-  }
-
-  throw createStatusNoRawHtmlError();
-}
-
-async function serveThreadStatusAsset(
-  deps: LoggedWorkSessionDeps,
-  threadId: string,
-  rawPath: string,
-): Promise<Response> {
-  const assetPath = parseStatusAssetPath(rawPath);
-  const target = await requireThreadStorageTarget(deps, { threadId });
-
-  try {
-    const result = await readThreadStorageStatusFile(deps, {
-      target,
-      rootPath: path.join(target.storagePath, STATUS_DIRECTORY_NAME),
-      relativePath: assetPath.relativePath,
-      dotfiles: "deny",
-    });
-    return createStatusFileResponse(result, STATUS_NO_STORE_CACHE_CONTROL);
-  } catch (error) {
-    return remapStatusAssetReadError(error);
-  }
-}
-
 async function serveThreadStorageRawFile(
   deps: LoggedWorkSessionDeps,
   threadId: string,
@@ -795,39 +497,8 @@ export function registerThreadDataRoutes(app: Hono, deps: AppDeps): void {
     return context.json(getLastExecutionOptions(deps, context.req.param("id")));
   });
 
-  get("/threads/:id/status-version", async (context) => {
-    context.header("cache-control", STATUS_NO_STORE_CACHE_CONTROL);
-    return context.json(
-      await readThreadStatusVersion(deps, context.req.param("id")),
-    );
-  });
-
-  app.get("/threads/:id/status", (context) => {
-    const requestPath = new URL(context.req.url).pathname;
-    return context.redirect(`${requestPath}/`, 308);
-  });
-
-  // This route intentionally sits outside @bb/server-contract: it returns
-  // arbitrary manager-authored HTML/static bytes, including wildcard asset
-  // paths, rather than a typed JSON API response.
-  app.get("/threads/:id/status/", async (context) =>
-    serveThreadStatusRoot(deps, context.req.param("id"), context.req.url),
-  );
-
-  app.get("/threads/:id/status/*", async (context) => {
-    const rawStatusPath = extractThreadStatusPath(context.req.url);
-    if (rawStatusPath.length === 0) {
-      return serveThreadStatusRoot(
-        deps,
-        context.req.param("id"),
-        context.req.url,
-      );
-    }
-    return serveThreadStatusAsset(deps, context.req.param("id"), rawStatusPath);
-  });
-
   // Generic iframe previews use path-shaped raw URLs so relative links resolve
-  // beside the HTML file. Unlike STATUS, these routes never inject bb globals.
+  // beside the HTML file. These routes never inject app bridge globals.
   app.get("/threads/:id/worktree/files/*", async (context) =>
     serveThreadWorktreeRawFile(
       deps,
diff --git a/apps/server/src/routes/threads/index.ts b/apps/server/src/routes/threads/index.ts
index 854b6fd3f..73f8159de 100644
--- a/apps/server/src/routes/threads/index.ts
+++ b/apps/server/src/routes/threads/index.ts
@@ -5,7 +5,6 @@ import { registerThreadAppRoutes } from "./apps.js";
 import { registerThreadBaseRoutes } from "./base.js";
 import { registerThreadDataRoutes } from "./data.js";
 import { registerThreadInteractionRoutes } from "./interactions.js";
-import { registerThreadStatusDataRoutes } from "./status-data.js";
 import { registerThreadTerminalRoutes } from "./terminals.js";
 
 export function registerThreadRoutes(app: Hono, deps: AppDeps): void {
@@ -14,7 +13,6 @@ export function registerThreadRoutes(app: Hono, deps: AppDeps): void {
   if (deps.config.featureFlags.terminals) {
     registerThreadTerminalRoutes(app, deps);
   }
-  registerThreadStatusDataRoutes(app, deps);
   registerThreadAppRoutes(app, deps);
   registerThreadDataRoutes(app, deps);
   registerThreadInteractionRoutes(app, deps);
diff --git a/apps/server/src/routes/threads/status-data.ts b/apps/server/src/routes/threads/status-data.ts
deleted file mode 100644
index fc8f7ea51..000000000
--- a/apps/server/src/routes/threads/status-data.ts
+++ /dev/null
@@ -1,300 +0,0 @@
-import type { Hono } from "hono";
-import { z } from "zod";
-import type {
-  HostDaemonCommand,
-  HostDaemonCommandResult,
-} from "@bb/host-daemon-contract";
-import { jsonValueSchema, type JsonValue } from "@bb/domain";
-import {
-  typedRoutes,
-  type PublicApiSchema,
-  type StatusStateBroadcastMessage,
-} from "@bb/server-contract";
-import type { AppDeps } from "../../types.js";
-import { COMMAND_TIMEOUT_MS } from "../../constants.js";
-import { ApiError } from "../../errors.js";
-import { queueCommandAndWait } from "../../services/hosts/command-wait.js";
-import {
-  requireEnvironment,
-  requirePublicThread,
-} from "../../services/lib/entity-lookup.js";
-import {
-  threadEnvironmentUnavailableDetails,
-  throwThreadEnvironmentUnavailable,
-} from "../../services/lib/lifecycle-api-errors.js";
-import {
-  STATUS_DATA_NO_STORE_CACHE_CONTROL,
-  STATUS_STATE_CLIENT_HEADER,
-  STATUS_STATE_OPERATION_HEADER,
-  createStatusDataEtag,
-  createStatusDataGetResponse,
-  parseStatusDataKey,
-} from "../../services/threads/status-data-files.js";
-
-interface BrowserStatusStateSetPayload {
-  value: JsonValue;
-}
-
-interface RequireThreadStatusDataTargetArgs {
-  threadId: string;
-}
-
-interface PutBrowserStatusStateArgs {
-  headers: Headers;
-  key: string;
-  payload: BrowserStatusStateSetPayload;
-  threadId: string;
-}
-
-interface DeleteBrowserStatusStateArgs {
-  headers: Headers;
-  key: string;
-  threadId: string;
-}
-
-interface ThreadStatusDataTarget {
-  hostId: string;
-  threadId: string;
-}
-
-type StatusDataCommandType =
-  | "host.status_data.list"
-  | "host.status_data.get"
-  | "host.status_data.set"
-  | "host.status_data.delete";
-
-interface QueueStatusDataCommandArgs<TType extends StatusDataCommandType> {
-  command: Extract<HostDaemonCommand, { type: TType }>;
-  hostId: string;
-}
-
-const browserStatusStateSetPayloadSchema = z
-  .object({
-    value: jsonValueSchema,
-  })
-  .strict();
-
-async function requireThreadStatusDataTarget(
-  deps: AppDeps,
-  args: RequireThreadStatusDataTargetArgs,
-): Promise<ThreadStatusDataTarget> {
-  const thread = requirePublicThread(deps.db, args.threadId);
-  if (!thread.environmentId) {
-    throwThreadEnvironmentUnavailable(
-      threadEnvironmentUnavailableDetails("never_attached", null),
-    );
-  }
-  const environment = requireEnvironment(deps.db, thread.environmentId);
-  return {
-    hostId: environment.hostId,
-    threadId: thread.id,
-  };
-}
-
-async function parseBrowserStatusStateSetPayload(
-  request: Request,
-): Promise<BrowserStatusStateSetPayload> {
-  let rawPayload: unknown;
-  try {
-    rawPayload = await request.json();
-  } catch {
-    throw new ApiError(400, "invalid_request", "Request body must be JSON");
-  }
-  const parsed = browserStatusStateSetPayloadSchema.safeParse(rawPayload);
-  if (!parsed.success) {
-    throw new ApiError(400, "invalid_request", "Invalid status state payload");
-  }
-  return parsed.data;
-}
-
-function remapStatusDataCommandError(error: unknown): never {
-  if (!(error instanceof ApiError)) {
-    throw error;
-  }
-
-  if (error.body.code === "ENOENT") {
-    throw new ApiError(
-      404,
-      error.body.code,
-      error.body.message,
-      error.body.retryable,
-    );
-  }
-  if (error.body.code === "invalid_path") {
-    throw new ApiError(
-      400,
-      error.body.code,
-      error.body.message,
-      error.body.retryable,
-    );
-  }
-  if (error.body.code === "invalid_json") {
-    throw new ApiError(
-      422,
-      error.body.code,
-      error.body.message,
-      error.body.retryable,
-    );
-  }
-  throw error;
-}
-
-async function queueStatusDataCommand<TType extends StatusDataCommandType>(
-  deps: AppDeps,
-  args: QueueStatusDataCommandArgs<TType>,
-): Promise<HostDaemonCommandResult<TType>> {
-  try {
-    return await queueCommandAndWait(deps, {
-      hostId: args.hostId,
-      timeoutMs: COMMAND_TIMEOUT_MS,
-      command: args.command,
-    });
-  } catch (error) {
-    remapStatusDataCommandError(error);
-  }
-}
-
-async function putBrowserStatusState(
-  deps: AppDeps,
-  args: PutBrowserStatusStateArgs,
-): Promise<Response> {
-  const key = parseStatusDataKey(args.key);
-  const target = await requireThreadStatusDataTarget(deps, {
-    threadId: args.threadId,
-  });
-  const writeResult = await queueStatusDataCommand(deps, {
-    hostId: target.hostId,
-    command: {
-      type: "host.status_data.set",
-      threadId: target.threadId,
-      key,
-      value: args.payload.value,
-    },
-  });
-
-  const message: StatusStateBroadcastMessage = {
-    type: "status-data.changed",
-    threadId: args.threadId,
-    key,
-    value: writeResult.value,
-    deleted: false,
-    previousValue: writeResult.previousValue,
-    previousValuePresent: writeResult.previousValuePresent,
-    version: writeResult.version,
-    writerClientId: args.headers.get(STATUS_STATE_CLIENT_HEADER),
-    operationId: args.headers.get(STATUS_STATE_OPERATION_HEADER),
-  };
-  deps.hub.notifyThreadStatusData(message);
-
-  return new Response(
-    JSON.stringify(createStatusDataGetResponse(writeResult)),
-    {
-      status: 200,
-      headers: {
-        "cache-control": STATUS_DATA_NO_STORE_CACHE_CONTROL,
-        "content-type": "application/json",
-        etag: createStatusDataEtag(writeResult.version),
-      },
-    },
-  );
-}
-
-async function deleteBrowserStatusState(
-  deps: AppDeps,
-  args: DeleteBrowserStatusStateArgs,
-): Promise<Response> {
-  const key = parseStatusDataKey(args.key);
-  const target = await requireThreadStatusDataTarget(deps, {
-    threadId: args.threadId,
-  });
-  const deleteResult = await queueStatusDataCommand(deps, {
-    hostId: target.hostId,
-    command: {
-      type: "host.status_data.delete",
-      threadId: target.threadId,
-      key,
-    },
-  });
-  if (deleteResult.deleted) {
-    const message: StatusStateBroadcastMessage = {
-      type: "status-data.changed",
-      threadId: args.threadId,
-      key,
-      value: null,
-      deleted: true,
-      previousValue: deleteResult.previousValue,
-      previousValuePresent: deleteResult.previousValuePresent,
-      version: null,
-      writerClientId: args.headers.get(STATUS_STATE_CLIENT_HEADER),
-      operationId: args.headers.get(STATUS_STATE_OPERATION_HEADER),
-    };
-    deps.hub.notifyThreadStatusData(message);
-  }
-
-  return new Response(JSON.stringify({ ok: true }), {
-    status: 200,
-    headers: {
-      "cache-control": STATUS_DATA_NO_STORE_CACHE_CONTROL,
-      "content-type": "application/json",
-    },
-  });
-}
-
-export function registerThreadStatusDataRoutes(app: Hono, deps: AppDeps): void {
-  const { get } = typedRoutes<PublicApiSchema>(app, {
-    onValidationError: (msg) => new ApiError(400, "invalid_request", msg),
-  });
-
-  get("/threads/:id/status-data", async (context) => {
-    const target = await requireThreadStatusDataTarget(deps, {
-      threadId: context.req.param("id"),
-    });
-    context.header("cache-control", STATUS_DATA_NO_STORE_CACHE_CONTROL);
-    return context.json(
-      await queueStatusDataCommand(deps, {
-        hostId: target.hostId,
-        command: {
-          type: "host.status_data.list",
-          threadId: target.threadId,
-        },
-      }),
-    );
-  });
-
-  get("/threads/:id/status-data/:key", async (context) => {
-    const target = await requireThreadStatusDataTarget(deps, {
-      threadId: context.req.param("id"),
-    });
-    const key = parseStatusDataKey(context.req.param("key"));
-    const entry = await queueStatusDataCommand(deps, {
-      hostId: target.hostId,
-      command: {
-        type: "host.status_data.get",
-        threadId: target.threadId,
-        key,
-      },
-    });
-    context.header("cache-control", STATUS_DATA_NO_STORE_CACHE_CONTROL);
-    context.header("etag", createStatusDataEtag(entry.version));
-    return context.json(createStatusDataGetResponse(entry));
-  });
-
-  // Contract-private, not network-private: the injected same-origin
-  // window.bbStatusState client uses this endpoint for browser mutations.
-  app.put("/threads/:id/status-state/:key", async (context) => {
-    return putBrowserStatusState(deps, {
-      threadId: context.req.param("id"),
-      key: context.req.param("key"),
-      headers: context.req.raw.headers,
-      payload: await parseBrowserStatusStateSetPayload(context.req.raw),
-    });
-  });
-
-  app.delete("/threads/:id/status-state/:key", async (context) => {
-    return deleteBrowserStatusState(deps, {
-      threadId: context.req.param("id"),
-      key: context.req.param("key"),
-      headers: context.req.raw.headers,
-    });
-  });
-}
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 077e969b3..cd3f4dbe2 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -27,7 +27,6 @@ import { registerInternalEventRoutes } from "./internal/events.js";
 import { registerInternalHostRoutes } from "./internal/hosts.js";
 import { registerInternalInteractiveRequestRoutes } from "./internal/interactive-requests.js";
 import { registerInternalSessionRoutes } from "./internal/session.js";
-import { registerInternalStatusDataChangeRoutes } from "./internal/status-data-changes.js";
 import { registerInternalToolCallRoutes } from "./internal/tool-calls.js";
 import {
   setAuthenticatedDaemon,
@@ -117,9 +116,7 @@ function shouldLogSlowApiRequest(args: ShouldLogSlowApiRequestArgs): boolean {
   return !THREAD_EVENT_WAIT_PATH_PATTERN.test(args.path);
 }
 
-function createStaticResponseHeaders(
-  args: StaticResponseHeadersArgs,
-): Headers {
+function createStaticResponseHeaders(args: StaticResponseHeadersArgs): Headers {
   const headers = new Headers();
   headers.set("content-type", args.contentType);
   headers.set(
@@ -265,7 +262,6 @@ export function createApp(
   registerInternalCommandRoutes(internalApi, deps);
   registerInternalCommandResultRoutes(internalApi, deps);
   registerInternalEnvironmentChangeRoutes(internalApi, deps);
-  registerInternalStatusDataChangeRoutes(internalApi, deps);
   registerInternalAppDataChangeRoutes(internalApi, deps);
   registerInternalEventRoutes(internalApi, deps);
   registerInternalToolCallRoutes(internalApi, deps);
diff --git a/apps/server/src/services/threads/default-template/STATUS.html b/apps/server/src/services/threads/default-template/STATUS.html
deleted file mode 100644
index 2cf56fdf1..000000000
--- a/apps/server/src/services/threads/default-template/STATUS.html
+++ /dev/null
@@ -1,380 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Manager Status</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link
-      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap"
-      rel="stylesheet"
-    />
-    <style>
-      /* bb design tokens, mirrored from apps/app/src/components/ui/theme.css.
-         See also: `bb guide styling`. */
-      :root {
-        color-scheme: light;
-        --background: oklch(0.9551 0 0);
-        --foreground: oklch(0.3211 0 0);
-        --card: oklch(0.9702 0 0);
-        --muted-foreground: oklch(0.5103 0 0);
-        --secondary: oklch(0.9067 0 0);
-        --border: oklch(0.8576 0 0);
-        --success: oklch(0.7 0.15 155);
-        --attention: oklch(0.74 0.15 80);
-        --destructive: oklch(0.5594 0.19 25.8625);
-        --primary: oklch(0.4891 0 0);
-        --font-sans: "Inter", -apple-system, BlinkMacSystemFont, sans-serif;
-        --font-mono: "Fira Code", ui-monospace, Menlo, monospace;
-        --radius: 0.35rem;
-        --radius-sm: calc(var(--radius) - 4px);
-        --shadow-sm:
-          0px 2px 0px 0px hsl(0 0% 20% / 0.12),
-          0px 1px 2px -1px hsl(0 0% 20% / 0.12);
-        --text-xs: 0.75rem;
-        --text-sm: 0.8125rem;
-        --text-base: 0.9375rem;
-      }
-      @media (prefers-color-scheme: dark) {
-        :root {
-          color-scheme: dark;
-          --background: oklch(0.195 0 0);
-          --foreground: oklch(0.8853 0 0);
-          --card: oklch(0.2435 0 0);
-          --muted-foreground: oklch(0.66 0 0);
-          --secondary: oklch(0.3092 0 0);
-          --border: oklch(0.329 0 0);
-          --success: oklch(0.74 0.15 155);
-          --attention: oklch(0.8 0.15 80);
-          --destructive: oklch(0.56 0.19 22.1703);
-          --primary: oklch(0.7058 0 0);
-        }
-      }
-
-      *,
-      *::before,
-      *::after {
-        box-sizing: border-box;
-      }
-
-      html {
-        height: 100%;
-        overflow-y: auto;
-        overflow-x: hidden;
-        scrollbar-width: thin;
-        scrollbar-color: var(--border) transparent;
-      }
-      html::-webkit-scrollbar {
-        width: 10px;
-      }
-      html::-webkit-scrollbar-thumb {
-        background: var(--border);
-        border-radius: 999px;
-        border: 2px solid var(--background);
-      }
-      html::-webkit-scrollbar-thumb:hover {
-        background: var(--muted-foreground);
-      }
-
-      body {
-        margin: 0;
-        padding: 16px 16px 20px;
-        background: var(--background);
-        color: var(--foreground);
-        font-family: var(--font-sans);
-        font-size: var(--text-base);
-        line-height: 1.45;
-        -webkit-font-smoothing: antialiased;
-        text-rendering: optimizeLegibility;
-      }
-
-      a {
-        color: inherit;
-        text-decoration: none;
-      }
-      a:hover {
-        text-decoration: underline;
-        text-decoration-thickness: 1px;
-        text-underline-offset: 2px;
-      }
-
-      code,
-      .mono {
-        font-family: var(--font-mono);
-        font-size: var(--text-xs);
-        color: var(--muted-foreground);
-      }
-
-      /* header */
-      .header {
-        display: flex;
-        align-items: center;
-        gap: 8px;
-        padding-bottom: 10px;
-        border-bottom: 1px solid var(--border);
-      }
-      .brand {
-        width: 20px;
-        height: 20px;
-        border: 1px solid var(--border);
-        background: var(--card);
-        border-radius: var(--radius-sm);
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        font-family: var(--font-mono);
-        font-weight: 500;
-        font-size: 10px;
-      }
-      .title {
-        font-size: var(--text-sm);
-        font-weight: 600;
-        letter-spacing: -0.005em;
-        flex: 1;
-        min-width: 0;
-      }
-      .ts {
-        font-family: var(--font-mono);
-        font-size: 10px;
-        color: var(--muted-foreground);
-      }
-
-      /* sections */
-      section {
-        margin-top: 16px;
-      }
-      .sect-title {
-        font-size: 10.5px;
-        font-weight: 600;
-        letter-spacing: 0.06em;
-        text-transform: uppercase;
-        color: var(--muted-foreground);
-        margin-bottom: 8px;
-      }
-
-      /* row */
-      .row {
-        display: flex;
-        align-items: flex-start;
-        justify-content: space-between;
-        gap: 10px;
-        padding: 10px 12px;
-        background: var(--card);
-        border: 1px solid var(--border);
-        border-radius: var(--radius);
-      }
-      .row + .row {
-        margin-top: 6px;
-      }
-      .row .main {
-        min-width: 0;
-        flex: 1;
-      }
-      .row .label {
-        font-family: var(--font-mono);
-        font-size: 10.5px;
-        color: var(--muted-foreground);
-        margin-bottom: 3px;
-      }
-      .row .name {
-        font-size: var(--text-sm);
-        font-weight: 500;
-        line-height: 1.35;
-        color: var(--foreground);
-        word-break: break-word;
-      }
-
-      /* pill */
-      .pill {
-        display: inline-flex;
-        align-items: center;
-        gap: 5px;
-        font-family: var(--font-mono);
-        font-size: 9.5px;
-        font-weight: 500;
-        line-height: 1;
-        padding: 3px 7px;
-        border-radius: 999px;
-        border: 1px solid var(--border);
-        background: var(--secondary);
-        color: var(--muted-foreground);
-        text-transform: uppercase;
-        letter-spacing: 0.05em;
-        white-space: nowrap;
-        flex-shrink: 0;
-      }
-      .pill .dot {
-        width: 5px;
-        height: 5px;
-        border-radius: 999px;
-        background: currentColor;
-      }
-      .pill.open {
-        color: var(--success);
-        background: color-mix(in srgb, var(--success) 12%, var(--background));
-        border-color: color-mix(in srgb, var(--success) 32%, var(--border));
-      }
-      .pill.running {
-        color: var(--attention);
-        background: color-mix(in srgb, var(--attention) 14%, var(--background));
-        border-color: color-mix(in srgb, var(--attention) 32%, var(--border));
-      }
-      .pill.failed {
-        color: var(--destructive);
-        background: color-mix(in srgb, var(--destructive) 12%, var(--background));
-        border-color: color-mix(in srgb, var(--destructive) 32%, var(--border));
-      }
-
-      .empty {
-        padding: 10px 12px;
-        font-size: var(--text-sm);
-        color: var(--muted-foreground);
-        font-style: italic;
-        border: 1px dashed var(--border);
-        border-radius: var(--radius);
-      }
-    </style>
-  </head>
-  <body>
-    <header class="header">
-      <span class="brand">bb</span>
-      <span class="title">Manager status</span>
-      <span class="ts">—</span>
-    </header>
-
-    <section>
-      <div class="sect-title">Open PRs · 0</div>
-      <div class="empty">No open PRs.</div>
-    </section>
-
-    <section>
-      <div class="sect-title">Active workers · 0</div>
-      <div class="empty">No active workers.</div>
-    </section>
-
-    <!--
-      =====================================================================
-      SNIPPET LIBRARY — copy/paste from these patterns when populating
-      STATUS.html. Keep them in sync if you change the styles above. For the
-      design tokens themselves, run `bb guide styling`.
-      =====================================================================
-
-      ---- Refresh timestamp (header right) ----
-      Update <span class="ts"> on every refresh:
-        <span class="ts">YYYY-MM-DD · HH:MM TZ</span>
-
-      ---- Section: open PRs (with count) ----
-      <section>
-        <div class="sect-title">Open PRs · 2</div>
-        <div class="row"> ...PR row... </div>
-        <div class="row"> ...PR row... </div>
-      </section>
-
-      ---- PR row ----
-      <div class="row">
-        <div class="main">
-          <div class="label">#42</div>
-          <div class="name">
-            <a href="https://github.com/OWNER/REPO/pull/42" target="_blank" rel="noopener">PR title goes here</a>
-          </div>
-        </div>
-        <span class="pill open"><span class="dot"></span>Open</span>
-      </div>
-
-      ---- Active worker row ----
-      <div class="row">
-        <div class="main">
-          <div class="label">thr_xxxxxxxxxx</div>
-          <div class="name">One-line description of what the worker is doing</div>
-        </div>
-        <span class="pill running"><span class="dot"></span>Running</span>
-      </div>
-
-      ---- Empty state ----
-      <div class="empty">No open PRs.</div>
-      <div class="empty">No active workers.</div>
-
-      ---- Pill variants ----
-      <span class="pill open"><span class="dot"></span>Open</span>            (success / green)
-      <span class="pill running"><span class="dot"></span>Running</span>      (attention / amber)
-      <span class="pill failed"><span class="dot"></span>Failed</span>        (destructive / red)
-      <span class="pill"><span class="dot"></span>Neutral</span>              (muted)
-
-      ---- Inline status annotation on a name (e.g. "Superseded by #99") ----
-      <span class="pill" style="margin-left:6px; color:var(--destructive); border-color:color-mix(in srgb,var(--destructive) 32%,var(--border)); background:color-mix(in srgb,var(--destructive) 12%,var(--background))">Superseded by #99</span>
-
-      =====================================================================
-      No-PR landing mode — use these two sections in place of "Open PRs"
-      when the user has opted out of PRs. "In progress" tracks worker
-      branches in flight; "Ready for review" tracks validated branches
-      waiting for the user to push or merge.
-      =====================================================================
-
-      ---- Section: in-progress work (no-PR mode) ----
-      <section>
-        <div class="sect-title">In progress · N</div>
-        <div class="row">
-          <div class="main">
-            <div class="label">branch-name</div>
-            <div class="name">One-line description of the work in flight</div>
-          </div>
-          <span class="pill running"><span class="dot"></span>WIP</span>
-        </div>
-      </section>
-
-      ---- Section: ready for review (no-PR mode) ----
-      <section>
-        <div class="sect-title">Ready for review · N</div>
-        <div class="row">
-          <div class="main">
-            <div class="label">branch-name</div>
-            <div class="name">One-line description · validated and waiting for user OK</div>
-          </div>
-          <span class="pill open"><span class="dot"></span>Ready</span>
-        </div>
-      </section>
-
-      ---- Optional sections you may want later ----
-
-      Active workers entry with provider/base meta (use a card-style row with extra meta block):
-      <article class="row" style="flex-direction:column; align-items:stretch; gap:6px">
-        <div style="display:flex; justify-content:space-between; gap:10px; align-items:flex-start">
-          <span class="label">thr_xxxxxxxxxx</span>
-          <span class="pill running"><span class="dot"></span>Running</span>
-        </div>
-        <div class="name">Description</div>
-        <div style="display:flex; flex-direction:column; gap:3px; font-family:var(--font-mono); font-size:10.5px; color:var(--muted-foreground)">
-          <span>provider · codex · xhigh · full perms</span>
-          <span>base · origin/main</span>
-        </div>
-      </article>
-
-      Dev-instance callout:
-      <section>
-        <div class="sect-title">Dev instance</div>
-        <div class="row">
-          <div class="main">
-            <div class="label">~/.bb-dev/</div>
-            <div class="name">Running PR #NN worktree.</div>
-          </div>
-          <span class="pill running"><span class="dot"></span>Up</span>
-        </div>
-      </section>
-
-      Recently completed feed (compact list — keep short, e.g. last 3):
-      <section>
-        <div class="sect-title">Recently completed · 2</div>
-        <div class="row">
-          <div class="main">
-            <div class="label">thr_xxxxxxxxxx</div>
-            <div class="name">
-              One-line outcome — <a href="https://github.com/OWNER/REPO/pull/41" target="_blank" rel="noopener">PR #41</a>
-              <span class="pill" style="margin-left:6px">Merged</span>
-            </div>
-          </div>
-        </div>
-      </section>
-    -->
-  </body>
-</html>
diff --git a/apps/server/src/services/threads/manager-storage-templates.ts b/apps/server/src/services/threads/manager-storage-templates.ts
index 6041ebb0e..628c917c0 100644
--- a/apps/server/src/services/threads/manager-storage-templates.ts
+++ b/apps/server/src/services/threads/manager-storage-templates.ts
@@ -93,10 +93,6 @@ type CopyTemplateFilesResult = "copied" | "missing";
 const BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET: BuiltInManagerTemplateSet = {
   name: DEFAULT_MANAGER_TEMPLATE_NAME,
   files: [
-    {
-      fileName: "STATUS.html",
-      content: loadDefaultTemplateAsset("STATUS.html"),
-    },
     {
       fileName: "apps/status/manifest.json",
       content: loadDefaultTemplateAsset("apps/status/manifest.json"),
@@ -197,7 +193,10 @@ async function copyTemplateFiles(
   await mkdir(args.threadStoragePath, { recursive: true });
 
   for (const file of files) {
-    const destinationPath = path.join(args.threadStoragePath, file.relativePath);
+    const destinationPath = path.join(
+      args.threadStoragePath,
+      file.relativePath,
+    );
     try {
       await mkdir(path.dirname(destinationPath), { recursive: true });
       await copyFile(
diff --git a/apps/server/src/services/threads/status-data-files.ts b/apps/server/src/services/threads/status-data-files.ts
deleted file mode 100644
index 2635ba43d..000000000
--- a/apps/server/src/services/threads/status-data-files.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import {
-  statusDataKeySchema,
-  type JsonValue,
-  type StatusDataKey,
-} from "@bb/domain";
-import type { ThreadStatusDataGetResponse } from "@bb/server-contract";
-import { ApiError } from "../../errors.js";
-
-export const STATUS_DATA_NO_STORE_CACHE_CONTROL = "no-store";
-export const STATUS_STATE_CLIENT_HEADER = "x-bb-status-state-client";
-export const STATUS_STATE_OPERATION_HEADER = "x-bb-status-state-operation";
-
-interface StatusDataEntry {
-  key: StatusDataKey;
-  value: JsonValue;
-  version: string;
-  sizeBytes: number;
-  modifiedAtMs: number;
-}
-
-export function parseStatusDataKey(rawKey: string): StatusDataKey {
-  const parsed = statusDataKeySchema.safeParse(rawKey);
-  if (!parsed.success) {
-    throw new ApiError(400, "invalid_request", "Invalid status-data key");
-  }
-  return parsed.data;
-}
-
-export function createStatusDataGetResponse(
-  entry: StatusDataEntry,
-): ThreadStatusDataGetResponse {
-  return {
-    key: entry.key,
-    value: entry.value,
-    version: entry.version,
-    sizeBytes: entry.sizeBytes,
-    modifiedAtMs: entry.modifiedAtMs,
-  };
-}
-
-export function createStatusDataEtag(version: string): string {
-  return `"${version}"`;
-}
diff --git a/apps/server/src/services/threads/status-state-client-script.ts b/apps/server/src/services/threads/status-state-client-script.ts
deleted file mode 100644
index 7ed891126..000000000
--- a/apps/server/src/services/threads/status-state-client-script.ts
+++ /dev/null
@@ -1,533 +0,0 @@
-export interface StatusStateBootstrap {
-  listUrl: string;
-  mutationUrl: string;
-  sendMessageUrl: string;
-  threadId: string;
-  wsUrl: string;
-}
-
-interface CreateStatusStateClientScriptArgs {
-  bootstrap: StatusStateBootstrap;
-}
-
-const STATUS_STATE_SCRIPT_MARKER = "data-bb-status-state-client";
-
-function escapedJsonForInlineScript(value: StatusStateBootstrap): string {
-  return JSON.stringify(value).replace(/</gu, "\\u003c");
-}
-
-export function createStatusStateClientScript(
-  args: CreateStatusStateClientScriptArgs,
-): string {
-  const bootstrapJson = escapedJsonForInlineScript(args.bootstrap);
-  return `<script ${STATUS_STATE_SCRIPT_MARKER}>${buildStatusStateClientJavascript(
-    bootstrapJson,
-  )}</script>`;
-}
-
-export function injectStatusStateClientScript(
-  html: string,
-  bootstrap: StatusStateBootstrap,
-): string {
-  if (html.includes(STATUS_STATE_SCRIPT_MARKER)) {
-    return html;
-  }
-
-  const script = createStatusStateClientScript({ bootstrap });
-  const firstScriptIndex = html.search(/<script\b/iu);
-  const headCloseIndex = html.search(/<\/head>/iu);
-  if (firstScriptIndex !== -1) {
-    return `${html.slice(0, firstScriptIndex)}${script}${html.slice(
-      firstScriptIndex,
-    )}`;
-  }
-  if (headCloseIndex !== -1) {
-    return `${html.slice(0, headCloseIndex)}${script}${html.slice(
-      headCloseIndex,
-    )}`;
-  }
-
-  const htmlOpenMatch = /<html\b[^>]*>/iu.exec(html);
-  if (htmlOpenMatch?.index !== undefined) {
-    const insertIndex = htmlOpenMatch.index + htmlOpenMatch[0].length;
-    return `${html.slice(0, insertIndex)}${script}${html.slice(insertIndex)}`;
-  }
-
-  return `${script}${html}`;
-}
-
-function buildStatusStateClientJavascript(bootstrapJson: string): string {
-  return `
-(function () {
-  var bootstrap = ${bootstrapJson};
-
-  function createBbThreadTellError(message, status, code, retryable) {
-    var error = new Error(message);
-    error.status = status;
-    if (code) error.code = code;
-    if (typeof retryable === "boolean") error.retryable = retryable;
-    return error;
-  }
-
-  function buildBbThreadTellClientError(response, text) {
-    var message = response.statusText || ("HTTP " + response.status);
-    var code = null;
-    var retryable = null;
-    if (text) {
-      try {
-        var body = JSON.parse(text);
-        if (body && typeof body === "object") {
-          if (typeof body.message === "string") message = body.message;
-          if (typeof body.code === "string") code = body.code;
-          if (typeof body.retryable === "boolean") retryable = body.retryable;
-        } else {
-          message = text;
-        }
-      } catch (error) {
-        message = text;
-      }
-    }
-    return createBbThreadTellError(message, response.status, code, retryable);
-  }
-
-  function buildBbThreadTellError(response) {
-    if (response.status >= 500) {
-      return Promise.resolve(
-        createBbThreadTellError(
-          "bbThreadTell failed: server error (" + response.status + ")",
-          response.status,
-          null,
-          null
-        )
-      );
-    }
-    return response.text().then(function (text) {
-      return buildBbThreadTellClientError(response, text);
-    });
-  }
-
-  function createBbThreadTellRequestBody(text) {
-    return {
-      input: [{ type: "text", text: text }],
-      mode: "auto"
-    };
-  }
-
-  function bbThreadTell(text) {
-    if (typeof text !== "string") {
-      throw new TypeError("window.bbThreadTell(text) requires a string");
-    }
-    return fetch(bootstrap.sendMessageUrl, {
-      method: "POST",
-      headers: {
-        "Accept": "application/json",
-        "Content-Type": "application/json"
-      },
-      credentials: "same-origin",
-      body: JSON.stringify(createBbThreadTellRequestBody(text))
-    }).then(function (response) {
-      if (response.ok) return undefined;
-      return buildBbThreadTellError(response).then(function (error) {
-        throw error;
-      });
-    });
-  }
-
-  function installBbThreadTell() {
-    try {
-      Object.defineProperty(window, "bbThreadTell", {
-        value: bbThreadTell,
-        configurable: true,
-        writable: false
-      });
-    } catch (error) {
-      window.bbThreadTell = bbThreadTell;
-    }
-  }
-
-  installBbThreadTell();
-  if (window.bbStatusState) return;
-
-  var keyPattern = /^[A-Za-z0-9_-]{1,80}$/;
-  var clientId = "bbss_" + Math.random().toString(36).slice(2) + Date.now().toString(36);
-  var cache = Object.create(null);
-  var versions = Object.create(null);
-  var hydrated = false;
-  var hydrating = false;
-  var hydratePromise = null;
-  var listeners = [];
-  var pendingOperations = Object.create(null);
-  var bufferedBroadcasts = [];
-  var socket = null;
-  var reconnectTimer = null;
-  var reconnectDelay = 1000;
-
-  function makeErrorMessage(error) {
-    if (error && typeof error.message === "string") return error.message;
-    return String(error || "Unknown status state error");
-  }
-
-  function validateKey(key) {
-    if (typeof key !== "string" || !keyPattern.test(key)) {
-      throw new Error("Invalid status-data key: " + String(key));
-    }
-  }
-
-  function isJsonValue(value) {
-    if (value === null) return true;
-    var type = typeof value;
-    if (type === "string" || type === "boolean") return true;
-    if (type === "number") return Number.isFinite(value);
-    if (Array.isArray(value)) return value.every(isJsonValue);
-    if (type !== "object") return false;
-    var proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null) return false;
-    return Object.keys(value).every(function (key) {
-      return isJsonValue(value[key]);
-    });
-  }
-
-  function cloneValue(value) {
-    if (value === undefined) return undefined;
-    return JSON.parse(JSON.stringify(value));
-  }
-
-  function valuesEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-  }
-
-  function copyCache() {
-    var out = Object.create(null);
-    Object.keys(cache).forEach(function (key) {
-      out[key] = cloneValue(cache[key]);
-    });
-    return out;
-  }
-
-  function callListener(listener, key, nextValue, previousValue, event) {
-    try {
-      listener.callback(cloneValue(nextValue), cloneValue(previousValue), key, event);
-    } catch (error) {
-      setTimeout(function () { throw error; }, 0);
-    }
-  }
-
-  function emit(key, nextValue, previousValue, event) {
-    listeners.slice().forEach(function (listener) {
-      if (listener.selector !== "*" && listener.selector !== key) return;
-      callListener(listener, key, nextValue, previousValue, event);
-    });
-  }
-
-  function applyValue(key, nextValue, version, event) {
-    var hadPrevious = Object.prototype.hasOwnProperty.call(cache, key);
-    var previousValue = hadPrevious ? cache[key] : undefined;
-    var changed = !hadPrevious || !valuesEqual(previousValue, nextValue);
-    cache[key] = cloneValue(nextValue);
-    versions[key] = version;
-    if (changed) emit(key, nextValue, previousValue, event);
-  }
-
-  function applyDelete(key, event) {
-    var hadPrevious = Object.prototype.hasOwnProperty.call(cache, key);
-    var previousValue = hadPrevious ? cache[key] : undefined;
-    delete cache[key];
-    delete versions[key];
-    if (hadPrevious) emit(key, undefined, previousValue, event);
-  }
-
-  function applySnapshot(snapshot, operation) {
-    var incomingKeys = Object.keys(snapshot.values);
-    incomingKeys.forEach(function (key) {
-      applyValue(key, snapshot.values[key], snapshot.versions[key] || null, {
-        source: "remote",
-        operation: operation,
-        optimistic: false,
-        version: snapshot.versions[key] || null,
-        error: null
-      });
-    });
-
-    Object.keys(cache).forEach(function (key) {
-      if (Object.prototype.hasOwnProperty.call(snapshot.values, key)) return;
-      applyDelete(key, {
-        source: "remote",
-        operation: operation,
-        optimistic: false,
-        version: null,
-        error: null
-      });
-    });
-  }
-
-  function replayBufferedBroadcasts() {
-    var buffered = bufferedBroadcasts;
-    bufferedBroadcasts = [];
-    buffered.forEach(applyBroadcast);
-  }
-
-  function fetchJson(url, options) {
-    return fetch(url, Object.assign({ credentials: "same-origin" }, options || {})).then(function (response) {
-      if (!response.ok) {
-        return response.text().then(function (text) {
-          throw new Error(text || response.statusText || ("HTTP " + response.status));
-        });
-      }
-      return response.json();
-    });
-  }
-
-  function hydrate(operation) {
-    hydrating = true;
-    hydratePromise = fetchJson(bootstrap.listUrl).then(function (snapshot) {
-      applySnapshot(snapshot, operation);
-      hydrating = false;
-      replayBufferedBroadcasts();
-      hydrated = true;
-      return copyCache();
-    }).catch(function (error) {
-      hydrating = false;
-      replayBufferedBroadcasts();
-      console.error("bbStatusState hydration failed", error);
-      throw error;
-    });
-    return hydratePromise;
-  }
-
-  function ensureHydrated() {
-    return hydratePromise || hydrate("hydrate");
-  }
-
-  function makeOperationId() {
-    if (window.crypto && typeof window.crypto.randomUUID === "function") {
-      return window.crypto.randomUUID();
-    }
-    return "op_" + Math.random().toString(36).slice(2) + Date.now().toString(36);
-  }
-
-  function keyUrl(key) {
-    return bootstrap.mutationUrl.replace(/\\/$/, "") + "/" + encodeURIComponent(key);
-  }
-
-  function rememberPending(operationId, key, value, deleted) {
-    pendingOperations[operationId] = {
-      key: key,
-      value: cloneValue(value),
-      deleted: deleted
-    };
-  }
-
-  function clearPending(operationId) {
-    if (operationId) delete pendingOperations[operationId];
-  }
-
-  function applyBroadcast(message) {
-    var key = message.key;
-    var pending = message.operationId ? pendingOperations[message.operationId] : null;
-    if (pending && pending.key === key) {
-      clearPending(message.operationId);
-      if (message.deleted) {
-        if (!Object.prototype.hasOwnProperty.call(cache, key)) return;
-      } else if (Object.prototype.hasOwnProperty.call(cache, key) && valuesEqual(cache[key], message.value)) {
-        versions[key] = message.version;
-        return;
-      }
-    }
-
-    if (message.deleted) {
-      applyDelete(key, {
-        source: "remote",
-        operation: "delete",
-        optimistic: false,
-        version: null,
-        error: null
-      });
-      return;
-    }
-
-    applyValue(key, message.value, message.version, {
-      source: "remote",
-      operation: "set",
-      optimistic: false,
-      version: message.version,
-      error: null
-    });
-  }
-
-  function handleBroadcast(message) {
-    if (!message || message.type !== "status-data.changed" || message.threadId !== bootstrap.threadId) {
-      return;
-    }
-    if (hydrating) {
-      bufferedBroadcasts.push(message);
-      return;
-    }
-    applyBroadcast(message);
-  }
-
-  function connectSocket() {
-    if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return;
-    socket = new WebSocket(bootstrap.wsUrl);
-    socket.onopen = function () {
-      reconnectDelay = 1000;
-      socket.send(JSON.stringify({
-        type: "subscribe",
-        entity: "thread",
-        id: bootstrap.threadId + ":status-data"
-      }));
-      if (hydrated) {
-        hydrate("resync").catch(function () {});
-      }
-    };
-    socket.onmessage = function (event) {
-      if (typeof event.data !== "string") return;
-      try {
-        handleBroadcast(JSON.parse(event.data));
-      } catch (error) {
-        console.error("bbStatusState ignored invalid realtime message", error);
-      }
-    };
-    socket.onclose = function () {
-      if (reconnectTimer) return;
-      reconnectTimer = setTimeout(function () {
-        reconnectTimer = null;
-        reconnectDelay = Math.min(reconnectDelay * 1.5, 30000);
-        connectSocket();
-      }, reconnectDelay);
-    };
-    socket.onerror = function () {
-      if (socket) socket.close();
-    };
-  }
-
-  window.bbStatusState = {
-    list: function () {
-      return ensureHydrated().then(copyCache);
-    },
-    get: function (key) {
-      validateKey(key);
-      return ensureHydrated().then(function () {
-        return cloneValue(cache[key]);
-      });
-    },
-    set: function (key, value) {
-      validateKey(key);
-      if (value === undefined || !isJsonValue(value)) {
-        return Promise.reject(new Error("bbStatusState.set requires a JSON value"));
-      }
-      return ensureHydrated().then(function () {
-        var operationId = makeOperationId();
-        var hadPrevious = Object.prototype.hasOwnProperty.call(cache, key);
-        var previousValue = hadPrevious ? cloneValue(cache[key]) : undefined;
-        var previousVersion = Object.prototype.hasOwnProperty.call(versions, key) ? versions[key] : null;
-        rememberPending(operationId, key, value, false);
-        applyValue(key, value, null, {
-          source: "local",
-          operation: "set",
-          optimistic: true,
-          version: null,
-          error: null
-        });
-        return fetchJson(keyUrl(key), {
-          method: "PUT",
-          headers: {
-            "content-type": "application/json",
-            "x-bb-status-state-client": clientId,
-            "x-bb-status-state-operation": operationId
-          },
-          body: JSON.stringify({ value: value })
-        }).then(function (response) {
-          clearPending(operationId);
-          versions[key] = response.version;
-        }).catch(function (error) {
-          clearPending(operationId);
-          if (hadPrevious) {
-            cache[key] = previousValue;
-            versions[key] = previousVersion;
-          } else {
-            delete cache[key];
-            delete versions[key];
-          }
-          emit(key, hadPrevious ? previousValue : undefined, value, {
-            source: "local",
-            operation: "revert",
-            optimistic: false,
-            version: previousVersion,
-            error: makeErrorMessage(error)
-          });
-          throw error;
-        });
-      });
-    },
-    delete: function (key) {
-      validateKey(key);
-      return ensureHydrated().then(function () {
-        var operationId = makeOperationId();
-        var hadPrevious = Object.prototype.hasOwnProperty.call(cache, key);
-        var previousValue = hadPrevious ? cloneValue(cache[key]) : undefined;
-        var previousVersion = Object.prototype.hasOwnProperty.call(versions, key) ? versions[key] : null;
-        rememberPending(operationId, key, undefined, true);
-        applyDelete(key, {
-          source: "local",
-          operation: "delete",
-          optimistic: true,
-          version: null,
-          error: null
-        });
-        return fetchJson(keyUrl(key), {
-          method: "DELETE",
-          headers: {
-            "x-bb-status-state-client": clientId,
-            "x-bb-status-state-operation": operationId
-          }
-        }).then(function () {
-          clearPending(operationId);
-        }).catch(function (error) {
-          clearPending(operationId);
-          if (hadPrevious) {
-            cache[key] = previousValue;
-            versions[key] = previousVersion;
-          }
-          emit(key, previousValue, undefined, {
-            source: "local",
-            operation: "revert",
-            optimistic: false,
-            version: previousVersion,
-            error: makeErrorMessage(error)
-          });
-          throw error;
-        });
-      });
-    },
-    on: function (selector, callback) {
-      if (selector !== "*") validateKey(selector);
-      if (typeof callback !== "function") {
-        throw new Error("bbStatusState.on requires a callback");
-      }
-      var listener = { selector: selector, callback: callback };
-      listeners.push(listener);
-      if (hydrated) {
-        Object.keys(cache).forEach(function (key) {
-          if (selector !== "*" && selector !== key) return;
-          callListener(listener, key, cache[key], undefined, {
-            source: "remote",
-            operation: "hydrate",
-            optimistic: false,
-            version: versions[key] || null,
-            error: null
-          });
-        });
-      }
-      var unsubscribed = false;
-      return function () {
-        if (unsubscribed) return;
-        unsubscribed = true;
-        listeners = listeners.filter(function (entry) { return entry !== listener; });
-      };
-    }
-  };
-
-  connectSocket();
-  hydrate("hydrate").catch(function () {});
-})();`;
-}
diff --git a/apps/server/src/ws/hub.ts b/apps/server/src/ws/hub.ts
index 3a66442e6..129b55230 100644
--- a/apps/server/src/ws/hub.ts
+++ b/apps/server/src/ws/hub.ts
@@ -14,10 +14,8 @@ import type {
 } from "@bb/host-daemon-contract";
 import {
   appDataBroadcastMessageSchema,
-  statusStateBroadcastMessageSchema,
   terminalServerMessageSchema,
   type AppDataBroadcastMessage,
-  type StatusStateBroadcastMessage,
   type TerminalServerMessage,
 } from "@bb/server-contract";
 import { COMMAND_RESULT_CACHE_TTL_MS } from "../constants.js";
@@ -410,13 +408,6 @@ export class NotificationHub implements DbNotifier {
     }
   }
 
-  notifyThreadStatusData(message: StatusStateBroadcastMessage): void {
-    this.notifyClientsByKey(
-      subKey("thread", `${message.threadId}:status-data`),
-      JSON.stringify(statusStateBroadcastMessageSchema.parse(message)),
-    );
-  }
-
   notifyThreadAppData(message: AppDataBroadcastMessage): void {
     this.notifyClientsByKey(
       subKey("thread", `${message.threadId}:app:${message.appId}:data`),
diff --git a/apps/server/test/app/hub.test.ts b/apps/server/test/app/hub.test.ts
index 3554b158c..91c59bceb 100644
--- a/apps/server/test/app/hub.test.ts
+++ b/apps/server/test/app/hub.test.ts
@@ -220,39 +220,6 @@ describe("NotificationHub", () => {
     expect(socket3.messages).toHaveLength(0);
   });
 
-  it("delivers status-data broadcasts on the thread-scoped status-data channel", () => {
-    const hub = new NotificationHub();
-    const socket = createMockSocket();
-
-    hub.subscribe(socket, "thread", "thread-1:status-data");
-    hub.notifyThreadStatusData({
-      type: "status-data.changed",
-      threadId: "thread-1",
-      key: "tasks",
-      value: [{ id: "task-1", title: "Review" }],
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      version: "hash-1",
-      writerClientId: "client-1",
-      operationId: "op-1",
-    });
-
-    expect(socket.messages).toHaveLength(1);
-    expect(JSON.parse(socket.messages[0])).toEqual({
-      type: "status-data.changed",
-      threadId: "thread-1",
-      key: "tasks",
-      value: [{ id: "task-1", title: "Review" }],
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      version: "hash-1",
-      writerClientId: "client-1",
-      operationId: "op-1",
-    });
-  });
-
   it("cancels the replaced daemon session's pending disconnect timer", async () => {
     vi.useFakeTimers();
     try {
diff --git a/apps/server/test/internal/internal-status-data-change.test.ts b/apps/server/test/internal/internal-status-data-change.test.ts
deleted file mode 100644
index dfaafa664..000000000
--- a/apps/server/test/internal/internal-status-data-change.test.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { internalAuthHeaders } from "../helpers/commands.js";
-import { readJson } from "../helpers/json.js";
-import {
-  seedEnvironment,
-  seedHostSession,
-  seedProjectWithSource,
-  seedThread,
-} from "../helpers/seed.js";
-import { createTestAppHarness } from "../helpers/test-app.js";
-
-describe("internal STATUS-data change route", () => {
-  it("broadcasts daemon-reported STATUS-data changes for session-owned threads", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const { host, session } = seedHostSession(harness.deps, {
-        id: "host-status-data-change",
-      });
-      const { project } = seedProjectWithSource(harness.deps, {
-        hostId: host.id,
-      });
-      const environment = seedEnvironment(harness.deps, {
-        hostId: host.id,
-        projectId: project.id,
-        path: "/tmp/status-data-change",
-        status: "ready",
-      });
-      const thread = seedThread(harness.deps, {
-        projectId: project.id,
-        environmentId: environment.id,
-        type: "manager",
-      });
-      const notifyThreadStatusDataSpy = vi.spyOn(
-        harness.hub,
-        "notifyThreadStatusData",
-      );
-
-      const response = await harness.app.request(
-        "/internal/session/status-data-change",
-        {
-          method: "POST",
-          headers: internalAuthHeaders(harness),
-          body: JSON.stringify({
-            sessionId: session.id,
-            threadId: thread.id,
-            key: "state",
-            value: { status: "running" },
-            deleted: false,
-            previousValue: { status: "queued" },
-            previousValuePresent: true,
-            version: "version-next",
-            previousVersion: "version-prev",
-          }),
-        },
-      );
-
-      expect(response.status).toBe(200);
-      expect(notifyThreadStatusDataSpy).toHaveBeenCalledWith({
-        type: "status-data.changed",
-        threadId: thread.id,
-        key: "state",
-        value: { status: "running" },
-        deleted: false,
-        previousValue: { status: "queued" },
-        previousValuePresent: true,
-        version: "version-next",
-        writerClientId: null,
-        operationId: null,
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("rejects daemon-reported STATUS-data changes for threads owned by another host", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const hostA = seedHostSession(harness.deps, {
-        id: "host-status-data-change-a",
-      });
-      const hostB = seedHostSession(harness.deps, {
-        id: "host-status-data-change-b",
-      });
-      const { project } = seedProjectWithSource(harness.deps, {
-        hostId: hostB.host.id,
-      });
-      const environment = seedEnvironment(harness.deps, {
-        hostId: hostB.host.id,
-        projectId: project.id,
-        path: "/tmp/status-data-change-other",
-        status: "ready",
-      });
-      const thread = seedThread(harness.deps, {
-        projectId: project.id,
-        environmentId: environment.id,
-        type: "manager",
-      });
-      const notifyThreadStatusDataSpy = vi.spyOn(
-        harness.hub,
-        "notifyThreadStatusData",
-      );
-
-      const response = await harness.app.request(
-        "/internal/session/status-data-change",
-        {
-          method: "POST",
-          headers: internalAuthHeaders(harness),
-          body: JSON.stringify({
-            sessionId: hostA.session.id,
-            threadId: thread.id,
-            key: "state",
-            value: null,
-            deleted: true,
-            previousValue: { status: "running" },
-            previousValuePresent: true,
-            version: null,
-            previousVersion: "version-prev",
-          }),
-        },
-      );
-
-      expect(response.status).toBe(403);
-      await expect(readJson(response)).resolves.toMatchObject({
-        code: "invalid_request",
-      });
-      expect(notifyThreadStatusDataSpy).not.toHaveBeenCalled();
-    } finally {
-      await harness.cleanup();
-    }
-  });
-});
diff --git a/apps/server/test/public/public-thread-data.test.ts b/apps/server/test/public/public-thread-data.test.ts
index 8790c26b7..0f6ad15aa 100644
--- a/apps/server/test/public/public-thread-data.test.ts
+++ b/apps/server/test/public/public-thread-data.test.ts
@@ -1,5 +1,4 @@
-import { and, desc, eq } from "drizzle-orm";
-import { createHash } from "node:crypto";
+import { and, eq } from "drizzle-orm";
 import {
   archiveThread,
   claimQueuedThreadMessage,
@@ -12,7 +11,6 @@ import {
   getQueuedThreadMessage,
   listQueuedThreadMessages,
   getThread,
-  hostDaemonCommands,
   queuedThreadMessages,
 } from "@bb/db";
 import {
@@ -20,21 +18,12 @@ import {
   threadQueuedMessageSchema,
   threadScope,
   threadSchema,
-  turnRequestEventDataSchema,
-  type TurnRequestEventData,
   turnScope,
 } from "@bb/domain";
 import {
-  type BbStatusState,
-  type BbThreadTell,
-  statusIframeThreadTellRequestSchema,
-  type ThreadStatusVersionResponse,
-  threadStatusDataGetResponseSchema,
-  threadStatusDataListResponseSchema,
   type TimelineRow,
   threadComposerBootstrapResponseSchema,
   threadQueuedMessageListResponseSchema,
-  threadStatusVersionResponseSchema,
   threadTimelineResponseSchema,
   threadWithIncludesResponseSchema,
   timelineTurnSummaryDetailsResponseSchema,
@@ -42,14 +31,12 @@ import {
 import { z } from "zod";
 import { describe, expect, it, vi } from "vitest";
 import {
-  type QueuedCommand,
   reportQueuedCommandError,
   reportQueuedCommandSuccess,
   waitForQueuedCommand,
   waitForQueuedCommandAfter,
 } from "../helpers/commands.js";
 import { readJson } from "../helpers/json.js";
-import type { TestAppHarness } from "../helpers/test-app.js";
 import {
   seedQueuedMessage,
   seedEnvironment,
@@ -78,183 +65,6 @@ const threadEventWaitResponseSchema = z.object({
 
 type TimelineTurnRow = Extract<TimelineRow, { kind: "turn" }>;
 
-interface ManagerThreadStorageFixture {
-  environmentId: string;
-  hostId: string;
-  threadId: string;
-  storageRootPath: string;
-}
-
-interface StatusTellScriptWindow {
-  bbStatusState?: BbStatusState;
-  bbThreadTell?: BbThreadTell;
-  crypto: {
-    randomUUID(): string;
-  };
-}
-
-interface ExecuteInjectedStatusClientScriptArgs {
-  fetch: typeof fetch;
-  html: string;
-  window: StatusTellScriptWindow;
-}
-
-interface StatusTellFetchCall {
-  init: RequestInit | undefined;
-  input: string;
-}
-
-interface MockSocket {
-  messages: string[];
-  close(code?: number, reason?: string): void;
-  send(data: string): void;
-}
-
-class StatusTellNoopWebSocket {
-  constructor(readonly url: string) {}
-}
-
-function createMockSocket(): MockSocket {
-  const messages: string[] = [];
-  return {
-    messages,
-    close() {},
-    send(data: string) {
-      messages.push(data);
-    },
-  };
-}
-
-function seedManagerThreadStorage(
-  harness: TestAppHarness,
-): ManagerThreadStorageFixture {
-  const { host } = seedHostSession(harness.deps);
-  const { project } = seedProjectWithSource(harness.deps, {
-    hostId: host.id,
-    path: "/tmp/project-source",
-  });
-  const environment = seedEnvironment(harness.deps, {
-    hostId: host.id,
-    projectId: project.id,
-    path: "/tmp/project-source",
-  });
-  const thread = seedThread(harness.deps, {
-    projectId: project.id,
-    environmentId: environment.id,
-    type: "manager",
-  });
-  return {
-    environmentId: environment.id,
-    hostId: host.id,
-    threadId: thread.id,
-    storageRootPath: `/tmp/bb-host-data/${host.id}/thread-storage/${thread.id}`,
-  };
-}
-
-function sha256Text(content: string): string {
-  return createHash("sha256").update(content).digest("hex");
-}
-
-function extractInjectedStatusClientScript(html: string): string {
-  const match =
-    /<script[^>]*data-bb-status-state-client[^>]*>([\s\S]*)<\/script>/u.exec(
-      html,
-    );
-  if (!match) {
-    throw new Error("Injected status client script not found");
-  }
-  return match[1];
-}
-
-function existingStatusState(): BbStatusState {
-  return {
-    async list() {
-      return {};
-    },
-    async get() {
-      return undefined;
-    },
-    async set() {},
-    async delete() {},
-    on() {
-      return () => {};
-    },
-  };
-}
-
-function executeInjectedStatusClientScript(
-  args: ExecuteInjectedStatusClientScriptArgs,
-): void {
-  const run = new Function(
-    "window",
-    "WebSocket",
-    "fetch",
-    "console",
-    "setTimeout",
-    "clearTimeout",
-    extractInjectedStatusClientScript(args.html),
-  );
-  run(
-    args.window,
-    StatusTellNoopWebSocket,
-    args.fetch,
-    console,
-    setTimeout,
-    clearTimeout,
-  );
-}
-
-function requireBbThreadTell(
-  windowObject: StatusTellScriptWindow,
-): BbThreadTell {
-  if (!windowObject.bbThreadTell) {
-    throw new Error("bbThreadTell was not installed");
-  }
-  return windowObject.bbThreadTell;
-}
-
-function createAppBackedFetch(
-  harness: TestAppHarness,
-  calls: StatusTellFetchCall[],
-): typeof fetch {
-  return async (input, init) => {
-    if (typeof input !== "string") {
-      throw new Error("Expected string URL");
-    }
-    calls.push({ input, init });
-    return harness.app.request(input, init);
-  };
-}
-
-function requireStringRequestBody(init: RequestInit | undefined): string {
-  if (typeof init?.body !== "string") {
-    throw new Error("Expected string request body");
-  }
-  return init.body;
-}
-
-function latestTurnRequestData(
-  harness: TestAppHarness,
-  threadId: string,
-): TurnRequestEventData {
-  const row = harness.db
-    .select()
-    .from(events)
-    .where(
-      and(
-        eq(events.threadId, threadId),
-        eq(events.type, "client/turn/requested"),
-      ),
-    )
-    .orderBy(desc(events.sequence))
-    .limit(1)
-    .get();
-  if (!row) {
-    throw new Error("Expected client/turn/requested event");
-  }
-  return turnRequestEventDataSchema.parse(JSON.parse(row.data));
-}
-
 describe("public thread data routes", () => {
   it("embeds thread environment and host snapshots when requested", async () => {
     const harness = await createTestAppHarness();
@@ -2315,93 +2125,7 @@ describe("public thread data routes", () => {
     }
   });
 
-  it("serves STATUS/index.html and sibling assets from the unified status route", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const statusRootPath = `${fixture.storageRootPath}/STATUS`;
-      const statusHtml = `<img src="logo.png"><link rel="stylesheet" href="style.css">`;
-
-      const statusPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/`,
-      );
-      const statusCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === statusRootPath &&
-          command.path === "index.html",
-      );
-      expect(statusCommand.command).toMatchObject({
-        type: "host.read_file_relative",
-        rootPath: statusRootPath,
-        path: "index.html",
-        dotfiles: "deny",
-      });
-      await reportQueuedCommandSuccess(harness, statusCommand, {
-        path: "index.html",
-        content: statusHtml,
-        contentEncoding: "utf8",
-        mimeType: "text/html",
-        sizeBytes: Buffer.byteLength(statusHtml),
-      });
-
-      const statusResponse = await statusPromise;
-      expect(statusResponse.status).toBe(200);
-      expect(statusResponse.headers.get("content-type")).toBe(
-        "text/html; charset=utf-8",
-      );
-      expect(statusResponse.headers.get("cache-control")).toBe("no-store");
-      expect(statusResponse.headers.get("x-content-type-options")).toBe(
-        "nosniff",
-      );
-      const statusBody = await statusResponse.text();
-      expect(statusBody).toContain("window.bbStatusState");
-      expect(statusBody).toContain("window.bbThreadTell");
-      expect(statusBody).toContain(statusHtml);
-
-      const assetBytes = Uint8Array.from([137, 80, 78, 71]);
-      const assetPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/logo.png`,
-      );
-      const assetCommand = await waitForQueuedCommandAfter(
-        harness,
-        statusCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === statusRootPath &&
-          command.path === "logo.png",
-      );
-      expect(assetCommand.command).toMatchObject({
-        type: "host.read_file_relative",
-        rootPath: statusRootPath,
-        path: "logo.png",
-        dotfiles: "deny",
-      });
-      await reportQueuedCommandSuccess(harness, assetCommand, {
-        path: "logo.png",
-        content: Buffer.from(assetBytes).toString("base64"),
-        contentEncoding: "base64",
-        mimeType: "image/png",
-        sizeBytes: assetBytes.byteLength,
-      });
-
-      const assetResponse = await assetPromise;
-      expect(assetResponse.status).toBe(200);
-      expect(assetResponse.headers.get("content-type")).toBe("image/png");
-      expect(assetResponse.headers.get("cache-control")).toBe("no-store");
-      expect(assetResponse.headers.get("x-content-type-options")).toBe(
-        "nosniff",
-      );
-      expect(new Uint8Array(await assetResponse.arrayBuffer())).toEqual(
-        assetBytes,
-      );
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("serves worktree HTML preview content as raw text/html without STATUS injection", async () => {
+  it("serves worktree HTML preview content as raw text/html without app bridge injection", async () => {
     const harness = await createTestAppHarness();
     try {
       const { host } = seedHostSession(harness.deps);
@@ -2453,14 +2177,13 @@ describe("public thread data routes", () => {
       expect(fileResponse.headers.get("cache-control")).toBe("no-store");
       const body = await fileResponse.text();
       expect(body).toBe(html);
-      expect(body).not.toContain("window.bbStatusState");
-      expect(body).not.toContain("window.bbThreadTell");
+      expect(body).not.toContain("window.bb");
     } finally {
       await harness.cleanup();
     }
   });
 
-  it("serves thread storage HTML preview content as raw text/html without STATUS injection", async () => {
+  it("serves thread storage HTML preview content as raw text/html without app bridge injection", async () => {
     const harness = await createTestAppHarness();
     try {
       const { host } = seedHostSession(harness.deps);
@@ -2564,741 +2287,6 @@ describe("public thread data routes", () => {
     }
   });
 
-  it("routes injected bbThreadTell sends to the owning manager thread", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      seedThreadRuntimeState(harness.deps, {
-        environmentId: fixture.environmentId,
-        providerThreadId: "provider-manager",
-        sequenceStart: 1,
-        threadId: fixture.threadId,
-      });
-      const statusRootPath = `${fixture.storageRootPath}/STATUS`;
-      const statusHtml =
-        "<!doctype html><html><head></head><body>manager status</body></html>";
-
-      const statusPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/`,
-      );
-      const statusCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === statusRootPath &&
-          command.path === "index.html",
-      );
-      await reportQueuedCommandSuccess(harness, statusCommand, {
-        path: "index.html",
-        content: statusHtml,
-        contentEncoding: "utf8",
-        mimeType: "text/html",
-        sizeBytes: Buffer.byteLength(statusHtml),
-      });
-      const statusResponse = await statusPromise;
-      expect(statusResponse.status).toBe(200);
-
-      const fetchCalls: StatusTellFetchCall[] = [];
-      const windowObject: StatusTellScriptWindow = {
-        bbStatusState: existingStatusState(),
-        crypto: { randomUUID: () => "op-from-crypto" },
-      };
-      executeInjectedStatusClientScript({
-        html: await statusResponse.text(),
-        window: windowObject,
-        fetch: createAppBackedFetch(harness, fetchCalls),
-      });
-
-      const tellPromise =
-        requireBbThreadTell(windowObject)("hello from iframe");
-      const preferencesReadCommand = await waitForQueuedCommandAfter(
-        harness,
-        statusCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.read_file" &&
-          command.path === `${fixture.storageRootPath}/PREFERENCES.md`,
-      );
-      await reportQueuedCommandError(harness, preferencesReadCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: PREFERENCES.md",
-      });
-      const submitCommand = await waitForQueuedCommandAfter(
-        harness,
-        preferencesReadCommand.row.cursor,
-        ({ command }) =>
-          command.type === "turn.submit" &&
-          command.threadId === fixture.threadId,
-      );
-      await expect(tellPromise).resolves.toBeUndefined();
-
-      expect(fetchCalls).toHaveLength(1);
-      expect(fetchCalls[0].input).toBe(
-        `/api/v1/threads/${fixture.threadId}/send`,
-      );
-      expect(
-        statusIframeThreadTellRequestSchema.parse(
-          JSON.parse(requireStringRequestBody(fetchCalls[0].init)),
-        ),
-      ).toEqual({
-        input: [{ type: "text", text: "hello from iframe" }],
-        mode: "auto",
-      });
-      expect(submitCommand.command).toMatchObject({
-        type: "turn.submit",
-        threadId: fixture.threadId,
-        target: { mode: "start" },
-      });
-      expect(latestTurnRequestData(harness, fixture.threadId)).toMatchObject({
-        input: [{ type: "text", text: "hello from iframe" }],
-        initiator: "user",
-        senderThreadId: null,
-        source: "tell",
-        target: { kind: "new-turn" },
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("returns the resolved STATUS version across all source modes", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const expectedVersions: ThreadStatusVersionResponse[] = [
-        { source: "folder", hash: "folder-hash-1" },
-        { source: "folder", hash: "folder-hash-2" },
-        { source: "html", hash: "html-hash" },
-        { source: "md", hash: "md-hash" },
-        { source: "empty", hash: "empty-hash" },
-      ];
-
-      let previousCursor: number | null = null;
-      for (const expectedVersion of expectedVersions) {
-        const versionPromise = harness.app.request(
-          `/api/v1/threads/${fixture.threadId}/status-version`,
-        );
-        const versionCommand: QueuedCommand =
-          previousCursor === null
-            ? await waitForQueuedCommand(
-                harness,
-                ({ command }) => command.type === "host.status_version",
-              )
-            : await waitForQueuedCommandAfter(
-                harness,
-                previousCursor,
-                ({ command }) => command.type === "host.status_version",
-              );
-
-        expect(versionCommand.command).toMatchObject({
-          type: "host.status_version",
-          sources: [
-            {
-              source: "folder",
-              rootPath: `${fixture.storageRootPath}/STATUS`,
-              indexPath: "index.html",
-              dotfiles: "deny",
-            },
-            {
-              source: "html",
-              rootPath: fixture.storageRootPath,
-              path: "STATUS.html",
-              dotfiles: "allow",
-            },
-            {
-              source: "md",
-              rootPath: fixture.storageRootPath,
-              path: "STATUS.md",
-              dotfiles: "allow",
-            },
-          ],
-        });
-        await reportQueuedCommandSuccess(
-          harness,
-          versionCommand,
-          expectedVersion,
-        );
-
-        const versionResponse = await versionPromise;
-        expect(versionResponse.status).toBe(200);
-        expect(versionResponse.headers.get("cache-control")).toBe("no-store");
-        expect(
-          threadStatusVersionResponseSchema.parse(
-            await readJson(versionResponse),
-          ),
-        ).toEqual(expectedVersion);
-        previousCursor = versionCommand.row.cursor;
-      }
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("lists and reads STATUS-data JSON values with versions", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const tasksJson = '["one"]\n';
-      const prefsJson = '{"compact":true}\n';
-
-      const responsePromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-data`,
-      );
-      const listCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.status_data.list" &&
-          command.threadId === fixture.threadId,
-      );
-      expect(listCommand.command).toEqual({
-        type: "host.status_data.list",
-        threadId: fixture.threadId,
-      });
-      await reportQueuedCommandSuccess(harness, listCommand, {
-        values: {
-          tasks: ["one"],
-          prefs: { compact: true },
-        },
-        versions: {
-          tasks: sha256Text(tasksJson),
-          prefs: sha256Text(prefsJson),
-        },
-        hash: sha256Text(
-          `prefs\0${sha256Text(prefsJson)}\n` +
-            `tasks\0${sha256Text(tasksJson)}\n`,
-        ),
-      });
-      const response = await responsePromise;
-      expect(response.status).toBe(200);
-      const parsed = threadStatusDataListResponseSchema.parse(
-        await readJson(response),
-      );
-      expect(parsed.values).toEqual({
-        tasks: ["one"],
-        prefs: { compact: true },
-      });
-      expect(parsed.versions).toEqual({
-        tasks: sha256Text(tasksJson),
-        prefs: sha256Text(prefsJson),
-      });
-      expect(parsed.hash).toBe(
-        sha256Text(
-          `prefs\0${sha256Text(prefsJson)}\n` +
-            `tasks\0${sha256Text(tasksJson)}\n`,
-        ),
-      );
-
-      const getResponsePromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-data/tasks`,
-      );
-      const getCommand = await waitForQueuedCommandAfter(
-        harness,
-        listCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.status_data.get" &&
-          command.threadId === fixture.threadId &&
-          command.key === "tasks",
-      );
-      expect(getCommand.command).toEqual({
-        type: "host.status_data.get",
-        threadId: fixture.threadId,
-        key: "tasks",
-      });
-      await reportQueuedCommandSuccess(harness, getCommand, {
-        key: "tasks",
-        value: ["one"],
-        version: sha256Text(tasksJson),
-        sizeBytes: Buffer.byteLength(tasksJson),
-        modifiedAtMs: 1234,
-      });
-      const getResponse = await getResponsePromise;
-      expect(getResponse.status).toBe(200);
-      expect(getResponse.headers.get("etag")).toBe(
-        `"${sha256Text(tasksJson)}"`,
-      );
-      expect(
-        threadStatusDataGetResponseSchema.parse(await readJson(getResponse)),
-      ).toEqual({
-        key: "tasks",
-        value: ["one"],
-        version: sha256Text(tasksJson),
-        sizeBytes: Buffer.byteLength(tasksJson),
-        modifiedAtMs: 1234,
-      });
-
-      const missingResponsePromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-data/missing`,
-      );
-      const missingCommand = await waitForQueuedCommandAfter(
-        harness,
-        getCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.status_data.get" &&
-          command.threadId === fixture.threadId &&
-          command.key === "missing",
-      );
-      await reportQueuedCommandError(harness, missingCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: missing.json",
-      });
-      const missingResponse = await missingResponsePromise;
-      expect(missingResponse.status).toBe(404);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("writes and deletes browser STATUS state atomically and broadcasts changes", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const socket = createMockSocket();
-      harness.deps.hub.subscribe(
-        socket,
-        "thread",
-        `${fixture.threadId}:status-data`,
-      );
-      const nextValue = [{ id: "task-1", title: "Review" }];
-      const nextJson = `${JSON.stringify(nextValue, null, 2)}\n`;
-      const nextHash = sha256Text(nextJson);
-
-      const oldPutResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-data/tasks`,
-        {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ value: nextValue }),
-        },
-      );
-      expect(oldPutResponse.status).toBe(404);
-
-      const putResponsePromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-state/tasks`,
-        {
-          method: "PUT",
-          headers: {
-            "content-type": "application/json",
-            "x-bb-status-state-client": "client-1",
-            "x-bb-status-state-operation": "op-1",
-          },
-          body: JSON.stringify({ value: nextValue }),
-        },
-      );
-      const putCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.status_data.set" &&
-          command.threadId === fixture.threadId &&
-          command.key === "tasks",
-      );
-      expect(putCommand.command).toEqual({
-        type: "host.status_data.set",
-        threadId: fixture.threadId,
-        key: "tasks",
-        value: nextValue,
-      });
-      await reportQueuedCommandSuccess(harness, putCommand, {
-        key: "tasks",
-        value: nextValue,
-        version: nextHash,
-        sizeBytes: Buffer.byteLength(nextJson),
-        modifiedAtMs: 2345,
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: null,
-      });
-
-      const putResponse = await putResponsePromise;
-      expect(putResponse.status).toBe(200);
-      expect(putResponse.headers.get("etag")).toBe(`"${nextHash}"`);
-      expect(
-        threadStatusDataGetResponseSchema.parse(await readJson(putResponse)),
-      ).toEqual({
-        key: "tasks",
-        value: nextValue,
-        version: nextHash,
-        sizeBytes: Buffer.byteLength(nextJson),
-        modifiedAtMs: 2345,
-      });
-      expect(socket.messages.map((message) => JSON.parse(message))).toEqual([
-        {
-          type: "status-data.changed",
-          threadId: fixture.threadId,
-          key: "tasks",
-          value: nextValue,
-          deleted: false,
-          previousValue: null,
-          previousValuePresent: false,
-          version: nextHash,
-          writerClientId: "client-1",
-          operationId: "op-1",
-        },
-      ]);
-
-      const oldDeleteResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-data/tasks`,
-        { method: "DELETE" },
-      );
-      expect(oldDeleteResponse.status).toBe(404);
-
-      const deleteResponsePromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status-state/tasks`,
-        {
-          method: "DELETE",
-          headers: {
-            "x-bb-status-state-client": "client-2",
-            "x-bb-status-state-operation": "op-2",
-          },
-        },
-      );
-      const deleteCommand = await waitForQueuedCommandAfter(
-        harness,
-        putCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.status_data.delete" &&
-          command.threadId === fixture.threadId &&
-          command.key === "tasks",
-      );
-      expect(deleteCommand.command).toEqual({
-        type: "host.status_data.delete",
-        threadId: fixture.threadId,
-        key: "tasks",
-      });
-      await reportQueuedCommandSuccess(harness, deleteCommand, {
-        key: "tasks",
-        deleted: true,
-        previousValue: nextValue,
-        previousValuePresent: true,
-        previousVersion: nextHash,
-      });
-
-      const deleteResponse = await deleteResponsePromise;
-      expect(deleteResponse.status).toBe(200);
-      await expect(readJson(deleteResponse)).resolves.toEqual({ ok: true });
-      expect(socket.messages.map((message) => JSON.parse(message))).toEqual([
-        {
-          type: "status-data.changed",
-          threadId: fixture.threadId,
-          key: "tasks",
-          value: nextValue,
-          deleted: false,
-          previousValue: null,
-          previousValuePresent: false,
-          version: nextHash,
-          writerClientId: "client-1",
-          operationId: "op-1",
-        },
-        {
-          type: "status-data.changed",
-          threadId: fixture.threadId,
-          key: "tasks",
-          value: null,
-          deleted: true,
-          previousValue: nextValue,
-          previousValuePresent: true,
-          version: null,
-          writerClientId: "client-2",
-          operationId: "op-2",
-        },
-      ]);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("falls back from a missing STATUS/index.html to STATUS.html", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const statusRootPath = `${fixture.storageRootPath}/STATUS`;
-      const statusHtml = "<h1>Single file status</h1>";
-
-      const statusPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/`,
-      );
-      const indexCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === statusRootPath &&
-          command.path === "index.html",
-      );
-      await reportQueuedCommandError(harness, indexCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: index.html",
-      });
-      const htmlCommand = await waitForQueuedCommandAfter(
-        harness,
-        indexCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === fixture.storageRootPath &&
-          command.path === "STATUS.html",
-      );
-      expect(htmlCommand.command).toMatchObject({
-        type: "host.read_file_relative",
-        rootPath: fixture.storageRootPath,
-        path: "STATUS.html",
-        dotfiles: "allow",
-      });
-      await reportQueuedCommandSuccess(harness, htmlCommand, {
-        path: "STATUS.html",
-        content: statusHtml,
-        contentEncoding: "utf8",
-        mimeType: "text/html",
-        sizeBytes: Buffer.byteLength(statusHtml),
-      });
-
-      const statusResponse = await statusPromise;
-      expect(statusResponse.status).toBe(200);
-      expect(statusResponse.headers.get("cache-control")).toBe("no-store");
-      expect(statusResponse.headers.get("x-content-type-options")).toBe(
-        "nosniff",
-      );
-      const statusBody = await statusResponse.text();
-      expect(statusBody).toContain("window.bbStatusState");
-      expect(statusBody).toContain(statusHtml);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("falls back from an unreadable STATUS/index.html to STATUS.html", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const statusRootPath = `${fixture.storageRootPath}/STATUS`;
-      const statusHtml = "<h1>Readable single file status</h1>";
-
-      const statusPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/`,
-      );
-      const indexCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === statusRootPath &&
-          command.path === "index.html",
-      );
-      await reportQueuedCommandError(harness, indexCommand, {
-        errorCode: "EACCES",
-        errorMessage: "Permission denied: index.html",
-      });
-      const htmlCommand = await waitForQueuedCommandAfter(
-        harness,
-        indexCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === fixture.storageRootPath &&
-          command.path === "STATUS.html",
-      );
-      await reportQueuedCommandSuccess(harness, htmlCommand, {
-        path: "STATUS.html",
-        content: statusHtml,
-        contentEncoding: "utf8",
-        mimeType: "text/html",
-        sizeBytes: Buffer.byteLength(statusHtml),
-      });
-
-      const statusResponse = await statusPromise;
-      expect(statusResponse.status).toBe(200);
-      expect(statusResponse.headers.get("x-content-type-options")).toBe(
-        "nosniff",
-      );
-      const statusBody = await statusResponse.text();
-      expect(statusBody).toContain("window.bbStatusState");
-      expect(statusBody).toContain(statusHtml);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("returns not found from the raw STATUS route when no raw HTML source exists", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-
-      const statusPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/`,
-      );
-      const indexCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === `${fixture.storageRootPath}/STATUS` &&
-          command.path === "index.html",
-      );
-      await reportQueuedCommandError(harness, indexCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: index.html",
-      });
-      const htmlCommand = await waitForQueuedCommandAfter(
-        harness,
-        indexCommand.row.cursor,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === fixture.storageRootPath &&
-          command.path === "STATUS.html",
-      );
-      await reportQueuedCommandError(harness, htmlCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: STATUS.html",
-      });
-
-      const statusResponse = await statusPromise;
-      expect(statusResponse.status).toBe(404);
-      await expect(readJson(statusResponse)).resolves.toMatchObject({
-        code: "ENOENT",
-        message: "No raw manager status HTML source exists",
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("serves subdirectory index files under STATUS when requested with a trailing slash", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-      const body = "<p>Nested status</p>";
-
-      const nestedPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/widgets/`,
-      );
-      const nestedCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === `${fixture.storageRootPath}/STATUS` &&
-          command.path === "widgets/index.html",
-      );
-      await reportQueuedCommandSuccess(harness, nestedCommand, {
-        path: "widgets/index.html",
-        content: body,
-        contentEncoding: "utf8",
-        mimeType: "text/html",
-        sizeBytes: Buffer.byteLength(body),
-      });
-
-      const nestedResponse = await nestedPromise;
-      expect(nestedResponse.status).toBe(200);
-      expect(nestedResponse.headers.get("cache-control")).toBe("no-store");
-      expect(nestedResponse.headers.get("x-content-type-options")).toBe(
-        "nosniff",
-      );
-      await expect(nestedResponse.text()).resolves.toBe(body);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("blocks dotfiles and invalid STATUS asset paths before reading", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-
-      const dotfileResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/assets/.env`,
-      );
-      expect(dotfileResponse.status).toBe(404);
-      await expect(readJson(dotfileResponse)).resolves.toMatchObject({
-        code: "ENOENT",
-      });
-
-      const normalizedTraversalResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/%2e%2e/secrets.txt`,
-      );
-      expect(normalizedTraversalResponse.status).toBe(404);
-
-      const encodedTraversalResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/%2e%2e%2fsecrets.txt`,
-      );
-      expect(encodedTraversalResponse.status).toBe(400);
-      await expect(readJson(encodedTraversalResponse)).resolves.toMatchObject({
-        code: "invalid_path",
-      });
-
-      const invalidPathResponse = await harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/assets%5Csecrets.txt`,
-      );
-      expect(invalidPathResponse.status).toBe(400);
-      await expect(readJson(invalidPathResponse)).resolves.toMatchObject({
-        code: "invalid_path",
-      });
-      expect(harness.db.select().from(hostDaemonCommands).all()).toHaveLength(
-        0,
-      );
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("returns 404 for missing STATUS assets without falling back to root status sources", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-
-      const assetPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/missing.png`,
-      );
-      const assetCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === `${fixture.storageRootPath}/STATUS` &&
-          command.path === "missing.png",
-      );
-      await reportQueuedCommandError(harness, assetCommand, {
-        errorCode: "ENOENT",
-        errorMessage: "Path does not exist: missing.png",
-      });
-
-      const assetResponse = await assetPromise;
-      expect(assetResponse.status).toBe(404);
-      await expect(readJson(assetResponse)).resolves.toEqual({
-        code: "ENOENT",
-        message: "Path does not exist: missing.png",
-        retryable: false,
-      });
-      expect(harness.db.select().from(hostDaemonCommands).all()).toHaveLength(
-        1,
-      );
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("maps STATUS asset symlink escapes to invalid_path", async () => {
-    const harness = await createTestAppHarness();
-    try {
-      const fixture = seedManagerThreadStorage(harness);
-
-      const assetPromise = harness.app.request(
-        `/api/v1/threads/${fixture.threadId}/status/assets/secrets.txt`,
-      );
-      const assetCommand = await waitForQueuedCommand(
-        harness,
-        ({ command }) =>
-          command.type === "host.read_file_relative" &&
-          command.rootPath === `${fixture.storageRootPath}/STATUS` &&
-          command.path === "assets/secrets.txt",
-      );
-      await reportQueuedCommandError(harness, assetCommand, {
-        errorCode: "invalid_path",
-        errorMessage: "Path escapes read root",
-      });
-
-      const assetResponse = await assetPromise;
-      expect(assetResponse.status).toBe(400);
-      await expect(readJson(assetResponse)).resolves.toEqual({
-        code: "invalid_path",
-        message: "Path escapes read root",
-        retryable: false,
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
   it("serves host file content from the thread environment host without requiring a ready environment", async () => {
     const harness = await createTestAppHarness();
     try {
diff --git a/apps/server/test/public/public-threads.manager-and-ownership.test.ts b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
index e8ac46698..dc6f0801d 100644
--- a/apps/server/test/public/public-threads.manager-and-ownership.test.ts
+++ b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
@@ -88,7 +88,9 @@ async function writeManagerTemplateSet(
   const templateDir = path.join(args.dataDir, "manager-templates", args.name);
   await mkdir(templateDir, { recursive: true });
   for (const [fileName, content] of Object.entries(args.files)) {
-    await writeFile(path.join(templateDir, fileName), content, "utf8");
+    const filePath = path.join(templateDir, fileName);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
   }
 }
 
@@ -104,8 +106,7 @@ async function respondToNextManagerTemplatesList(
   const queued = await waitForQueuedCommand(
     args.harness,
     ({ command, row }) =>
-      row.state === "pending" &&
-      command.type === "host.list_manager_templates",
+      row.state === "pending" && command.type === "host.list_manager_templates",
   );
   const response = await reportQueuedCommandSuccess(args.harness, queued, {
     templates: args.templates.map((name) => ({ name })),
@@ -484,7 +485,7 @@ describe("public thread manager and ownership routes", () => {
         name: "default",
         files: {
           "PREFERENCES.md": "default prefs\n",
-          "STATUS.html": "default status\n",
+          "apps/status/data/state.json": '{"prs":[]}\n',
         },
       });
 
@@ -518,7 +519,9 @@ describe("public thread manager and ownership routes", () => {
           command.type === "thread.start" && command.threadId === thread.id,
       );
       if (startCommand.command.type !== "thread.start") {
-        throw new Error(`Expected thread.start, got ${startCommand.command.type}`);
+        throw new Error(
+          `Expected thread.start, got ${startCommand.command.type}`,
+        );
       }
       expect(startCommand.command.input[0]).toEqual({
         type: "text",
@@ -540,8 +543,8 @@ describe("public thread manager and ownership routes", () => {
         readFile(path.join(storagePath, "PREFERENCES.md"), "utf8"),
       ).resolves.toBe("default prefs\n");
       await expect(
-        readFile(path.join(storagePath, "STATUS.html"), "utf8"),
-      ).resolves.toBe("default status\n");
+        readFile(path.join(storagePath, "apps/status/data/state.json"), "utf8"),
+      ).resolves.toBe('{"prs":[]}\n');
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
@@ -665,7 +668,9 @@ describe("public thread manager and ownership routes", () => {
         text: "ack prefs test",
       });
       expect(turnSubmit.command.input[1]).not.toHaveProperty("visibility");
-      expect(turnSubmit.command.input.at(-1)).toEqual(managerToolReminderInput());
+      expect(turnSubmit.command.input.at(-1)).toEqual(
+        managerToolReminderInput(),
+      );
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
diff --git a/apps/server/test/services/threads/status-state-client-script.test.ts b/apps/server/test/services/threads/status-state-client-script.test.ts
deleted file mode 100644
index b6a510d0e..000000000
--- a/apps/server/test/services/threads/status-state-client-script.test.ts
+++ /dev/null
@@ -1,743 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { JsonValue, StatusDataKey } from "@bb/domain";
-import { statusIframeThreadTellRequestSchema } from "@bb/server-contract";
-import type {
-  BbThreadTell,
-  BbStatusState,
-  StatusStateBroadcastMessage,
-  StatusStateChangeEvent,
-  ThreadStatusDataListResponse,
-} from "@bb/server-contract";
-import {
-  injectStatusStateClientScript,
-  type StatusStateBootstrap,
-} from "../../../src/services/threads/status-state-client-script.js";
-
-interface ScriptWindow {
-  bbStatusState?: BbStatusState;
-  bbThreadTell?: BbThreadTell;
-  crypto: {
-    randomUUID(): string;
-  };
-}
-
-interface CallbackCall {
-  event: StatusStateChangeEvent;
-  key: StatusDataKey;
-  newValue: JsonValue | undefined;
-  prevValue: JsonValue | undefined;
-}
-
-interface DeferredResponse {
-  promise: Promise<Response>;
-  resolve(response: Response): void;
-}
-
-interface FetchCall {
-  init: RequestInit | undefined;
-  input: string;
-}
-
-class FakeWebSocket {
-  static readonly CONNECTING = 0;
-  static readonly OPEN = 1;
-  static readonly CLOSED = 3;
-  static instances: FakeWebSocket[] = [];
-
-  onclose: (() => void) | null = null;
-  onerror: (() => void) | null = null;
-  onmessage: ((event: { data: string }) => void) | null = null;
-  onopen: (() => void) | null = null;
-  readonly sent: string[] = [];
-  readyState = FakeWebSocket.CONNECTING;
-
-  constructor(readonly url: string) {
-    FakeWebSocket.instances.push(this);
-    queueMicrotask(() => {
-      this.readyState = FakeWebSocket.OPEN;
-      this.onopen?.();
-    });
-  }
-
-  close(): void {
-    this.readyState = FakeWebSocket.CLOSED;
-    this.onclose?.();
-  }
-
-  send(data: string): void {
-    this.sent.push(data);
-  }
-
-  emit(data: string): void {
-    this.onmessage?.({ data });
-  }
-}
-
-const bootstrap: StatusStateBootstrap = {
-  threadId: "thread-1",
-  listUrl: "/api/v1/threads/thread-1/status-data",
-  mutationUrl: "/api/v1/threads/thread-1/status-state",
-  sendMessageUrl: "/api/v1/threads/thread-1/send",
-  wsUrl: "ws://localhost:3334/ws",
-};
-
-function createDeferredResponse(): DeferredResponse {
-  let resolve!: (response: Response) => void;
-  const promise = new Promise<Response>((innerResolve) => {
-    resolve = innerResolve;
-  });
-  return { promise, resolve };
-}
-
-function jsonResponse(body: JsonValue): Response {
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { "content-type": "application/json" },
-  });
-}
-
-function listResponse(body: ThreadStatusDataListResponse): Response {
-  return jsonResponse(body);
-}
-
-function existingStatusState(): BbStatusState {
-  return {
-    async list() {
-      return {};
-    },
-    async get() {
-      return undefined;
-    },
-    async set() {},
-    async delete() {},
-    on() {
-      return () => {};
-    },
-  };
-}
-
-function makeBroadcast(
-  overrides: Partial<StatusStateBroadcastMessage> & {
-    key: StatusDataKey;
-  },
-): StatusStateBroadcastMessage {
-  return {
-    type: "status-data.changed",
-    threadId: "thread-1",
-    key: overrides.key,
-    value: overrides.value ?? null,
-    deleted: overrides.deleted ?? false,
-    previousValue: overrides.previousValue ?? null,
-    previousValuePresent: overrides.previousValuePresent ?? false,
-    version: overrides.version ?? null,
-    writerClientId: overrides.writerClientId ?? null,
-    operationId: overrides.operationId ?? null,
-  };
-}
-
-function extractInlineScript(html: string): string {
-  const match =
-    /<script[^>]*data-bb-status-state-client[^>]*>([\s\S]*)<\/script>/u.exec(
-      html,
-    );
-  if (!match) {
-    throw new Error("Injected script not found");
-  }
-  return match[1];
-}
-
-function executeScript(args: {
-  fetch: typeof fetch;
-  html: string;
-  window: ScriptWindow;
-}): void {
-  const script = extractInlineScript(args.html);
-  const run = new Function(
-    "window",
-    "WebSocket",
-    "fetch",
-    "console",
-    "setTimeout",
-    "clearTimeout",
-    script,
-  );
-  run(
-    args.window,
-    FakeWebSocket,
-    args.fetch,
-    console,
-    setTimeout,
-    clearTimeout,
-  );
-}
-
-function requireBbThreadTell(windowObject: ScriptWindow): BbThreadTell {
-  if (!windowObject.bbThreadTell) {
-    throw new Error("bbThreadTell was not installed");
-  }
-  return windowObject.bbThreadTell;
-}
-
-function requireStringRequestBody(init: RequestInit | undefined): string {
-  if (typeof init?.body !== "string") {
-    throw new Error("Expected string request body");
-  }
-  return init.body;
-}
-
-describe("status state client script", () => {
-  afterEach(() => {
-    FakeWebSocket.instances = [];
-    vi.useRealTimers();
-  });
-
-  it("injects before user scripts", () => {
-    const html =
-      "<html><head><script>window.userRan = true;</script></head></html>";
-    const injected = injectStatusStateClientScript(html, bootstrap);
-
-    expect(injected.indexOf("data-bb-status-state-client")).toBeLessThan(
-      injected.indexOf("window.userRan"),
-    );
-    expect(injected).toContain("window.bbStatusState");
-    expect(injected).toContain("window.bbThreadTell");
-  });
-
-  it("installs bbThreadTell and posts text to the owning thread send route", async () => {
-    const calls: FetchCall[] = [];
-    const fetchMock: typeof fetch = async (input, init) => {
-      if (typeof input !== "string") {
-        throw new Error("Expected string URL");
-      }
-      calls.push({ input, init });
-      return jsonResponse({ ok: true });
-    };
-    const windowObject: ScriptWindow = {
-      bbStatusState: existingStatusState(),
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-
-    await requireBbThreadTell(windowObject)("hello from iframe");
-
-    expect(calls).toHaveLength(1);
-    const call = calls[0];
-    expect(call.input).toBe("/api/v1/threads/thread-1/send");
-    expect(call.init?.method).toBe("POST");
-    expect(call.init?.credentials).toBe("same-origin");
-    const headers = new Headers(call.init?.headers);
-    expect(headers.get("accept")).toBe("application/json");
-    expect(headers.get("content-type")).toBe("application/json");
-    expect(
-      statusIframeThreadTellRequestSchema.parse(
-        JSON.parse(requireStringRequestBody(call.init)),
-      ),
-    ).toEqual({
-      input: [{ type: "text", text: "hello from iframe" }],
-      mode: "auto",
-    });
-  });
-
-  it("throws bbThreadTell non-string input errors synchronously", () => {
-    const calls: FetchCall[] = [];
-    const fetchMock: typeof fetch = async (input, init) => {
-      if (typeof input !== "string") {
-        throw new Error("Expected string URL");
-      }
-      calls.push({ input, init });
-      return jsonResponse({ ok: true });
-    };
-    const windowObject: ScriptWindow = {
-      bbStatusState: existingStatusState(),
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-
-    expect(() => {
-      // @ts-expect-error Runtime validation intentionally rejects bad callers.
-      requireBbThreadTell(windowObject)(123);
-    }).toThrow(TypeError);
-    expect(calls).toHaveLength(0);
-  });
-
-  it("rejects bbThreadTell with the server 4xx message and error metadata", async () => {
-    const fetchMock: typeof fetch = async () =>
-      new Response(
-        JSON.stringify({
-          code: "invalid_request",
-          message: "Thread is archived",
-          retryable: false,
-        }),
-        { status: 409, headers: { "content-type": "application/json" } },
-      );
-    const windowObject: ScriptWindow = {
-      bbStatusState: existingStatusState(),
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-
-    await expect(
-      requireBbThreadTell(windowObject)("ping"),
-    ).rejects.toMatchObject({
-      code: "invalid_request",
-      message: "Thread is archived",
-      retryable: false,
-      status: 409,
-    });
-  });
-
-  it("rejects bbThreadTell 5xx responses with a generic server error", async () => {
-    const fetchMock: typeof fetch = async () =>
-      new Response(
-        JSON.stringify({
-          code: "internal_error",
-          message: "database detail that should not leak",
-        }),
-        { status: 503, headers: { "content-type": "application/json" } },
-      );
-    const windowObject: ScriptWindow = {
-      bbStatusState: existingStatusState(),
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-
-    await expect(
-      requireBbThreadTell(windowObject)("ping"),
-    ).rejects.toMatchObject({
-      message: "bbThreadTell failed: server error (503)",
-      status: 503,
-    });
-  });
-
-  it("hydrates, fires immediate listeners, writes optimistically, and reconciles broadcasts", async () => {
-    let operationId = "";
-    const fetchMock = vi.fn(
-      async (_input: RequestInfo | URL, init?: RequestInit) => {
-        if (!init?.method) {
-          return new Response(
-            JSON.stringify({
-              values: { todos: ["seed"] },
-              versions: { todos: "v1" },
-              hash: "list-hash",
-            }),
-            { status: 200, headers: { "content-type": "application/json" } },
-          );
-        }
-
-        operationId =
-          new Headers(init.headers).get("x-bb-status-state-operation") ?? "";
-        return new Response(
-          JSON.stringify({
-            key: "todos",
-            value: ["next"],
-            version: "v2",
-            sizeBytes: 9,
-            modifiedAtMs: 10,
-          }),
-          { status: 200, headers: { "content-type": "application/json" } },
-        );
-      },
-    );
-    const windowObject: ScriptWindow = {
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-    const state = windowObject.bbStatusState;
-    if (!state) {
-      throw new Error("bbStatusState was not installed");
-    }
-
-    const calls: CallbackCall[] = [];
-    state.on("todos", (newValue, prevValue, key, event) => {
-      calls.push({ newValue, prevValue, key, event });
-    });
-
-    const listed = await state.list();
-    expect(listed.todos).toEqual(["seed"]);
-    expect(calls).toEqual([
-      {
-        newValue: ["seed"],
-        prevValue: undefined,
-        key: "todos",
-        event: {
-          source: "remote",
-          operation: "hydrate",
-          optimistic: false,
-          version: "v1",
-          error: null,
-        },
-      },
-    ]);
-
-    await state.set("todos", ["next"]);
-    expect(calls[1]).toEqual({
-      newValue: ["next"],
-      prevValue: ["seed"],
-      key: "todos",
-      event: {
-        source: "local",
-        operation: "set",
-        optimistic: true,
-        version: null,
-        error: null,
-      },
-    });
-
-    const socket = FakeWebSocket.instances[0];
-    expect(socket.url).toBe("ws://localhost:3334/ws");
-    expect(JSON.parse(socket.sent[0])).toEqual({
-      type: "subscribe",
-      entity: "thread",
-      id: "thread-1:status-data",
-    });
-    socket.emit(
-      JSON.stringify({
-        type: "status-data.changed",
-        threadId: "thread-1",
-        key: "todos",
-        value: ["next"],
-        deleted: false,
-        previousValue: ["seed"],
-        previousValuePresent: true,
-        version: "v2",
-        writerClientId: "client",
-        operationId,
-      }),
-    );
-    expect(calls).toHaveLength(2);
-
-    const immediateCalls: CallbackCall[] = [];
-    state.on("todos", (newValue, prevValue, key, event) => {
-      immediateCalls.push({ newValue, prevValue, key, event });
-    });
-    expect(immediateCalls).toEqual([
-      {
-        newValue: ["next"],
-        prevValue: undefined,
-        key: "todos",
-        event: {
-          source: "remote",
-          operation: "hydrate",
-          optimistic: false,
-          version: "v2",
-          error: null,
-        },
-      },
-    ]);
-  });
-
-  it("replays broadcasts after an in-flight hydration snapshot so newer realtime values win", async () => {
-    const listDeferred = createDeferredResponse();
-    const fetchMock = vi.fn(async () => listDeferred.promise);
-    const windowObject: ScriptWindow = {
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-    const state = windowObject.bbStatusState;
-    if (!state) {
-      throw new Error("bbStatusState was not installed");
-    }
-    const calls: CallbackCall[] = [];
-    state.on("todos", (newValue, prevValue, key, event) => {
-      calls.push({ newValue, prevValue, key, event });
-    });
-
-    await Promise.resolve();
-    FakeWebSocket.instances[0].emit(
-      JSON.stringify(
-        makeBroadcast({
-          key: "todos",
-          value: ["broadcast"],
-          version: "v2",
-        }),
-      ),
-    );
-    listDeferred.resolve(
-      listResponse({
-        values: { todos: ["stale"] },
-        versions: { todos: "v1" },
-        hash: "list-hash",
-      }),
-    );
-
-    const listed = await state.list();
-    expect(listed.todos).toEqual(["broadcast"]);
-    expect(calls.map((call) => call.newValue)).toEqual([
-      ["stale"],
-      ["broadcast"],
-    ]);
-    expect(calls.at(-1)?.event).toEqual({
-      source: "remote",
-      operation: "set",
-      optimistic: false,
-      version: "v2",
-      error: null,
-    });
-  });
-
-  it("resyncs changed, added, and deleted keys after reconnect", async () => {
-    vi.useFakeTimers();
-    const snapshots: ThreadStatusDataListResponse[] = [
-      {
-        values: { todos: ["old"], removed: true },
-        versions: { todos: "v1", removed: "remove-v1" },
-        hash: "initial-hash",
-      },
-      {
-        values: { todos: ["new"], extra: 1 },
-        versions: { todos: "v2", extra: "extra-v1" },
-        hash: "resync-hash",
-      },
-    ];
-    const fetchMock = vi.fn(async () => {
-      const next = snapshots.shift();
-      if (!next) {
-        throw new Error("Unexpected list request");
-      }
-      return listResponse(next);
-    });
-    const windowObject: ScriptWindow = {
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-    const state = windowObject.bbStatusState;
-    if (!state) {
-      throw new Error("bbStatusState was not installed");
-    }
-    const calls: CallbackCall[] = [];
-    state.on("*", (newValue, prevValue, key, event) => {
-      calls.push({ newValue, prevValue, key, event });
-    });
-    await state.list();
-
-    FakeWebSocket.instances[0].close();
-    await vi.advanceTimersByTimeAsync(1000);
-    await Promise.resolve();
-    await Promise.resolve();
-    await state.list();
-
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(await state.get("todos")).toEqual(["new"]);
-    expect(await state.get("extra")).toBe(1);
-    expect(await state.get("removed")).toBeUndefined();
-    expect(calls.slice(2)).toEqual([
-      {
-        newValue: ["new"],
-        prevValue: ["old"],
-        key: "todos",
-        event: {
-          source: "remote",
-          operation: "resync",
-          optimistic: false,
-          version: "v2",
-          error: null,
-        },
-      },
-      {
-        newValue: 1,
-        prevValue: undefined,
-        key: "extra",
-        event: {
-          source: "remote",
-          operation: "resync",
-          optimistic: false,
-          version: "extra-v1",
-          error: null,
-        },
-      },
-      {
-        newValue: undefined,
-        prevValue: true,
-        key: "removed",
-        event: {
-          source: "remote",
-          operation: "resync",
-          optimistic: false,
-          version: null,
-          error: null,
-        },
-      },
-    ]);
-  });
-
-  it("fires wildcard hydration once per existing key when registered after hydration", async () => {
-    const fetchMock = vi.fn(async () =>
-      listResponse({
-        values: { todos: ["seed"], filters: { done: false } },
-        versions: { todos: "v1", filters: "v2" },
-        hash: "list-hash",
-      }),
-    );
-    const windowObject: ScriptWindow = {
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-    const state = windowObject.bbStatusState;
-    if (!state) {
-      throw new Error("bbStatusState was not installed");
-    }
-    await state.list();
-
-    const calls: CallbackCall[] = [];
-    state.on("*", (newValue, prevValue, key, event) => {
-      calls.push({ newValue, prevValue, key, event });
-    });
-
-    expect(calls).toEqual([
-      {
-        newValue: ["seed"],
-        prevValue: undefined,
-        key: "todos",
-        event: {
-          source: "remote",
-          operation: "hydrate",
-          optimistic: false,
-          version: "v1",
-          error: null,
-        },
-      },
-      {
-        newValue: { done: false },
-        prevValue: undefined,
-        key: "filters",
-        event: {
-          source: "remote",
-          operation: "hydrate",
-          optimistic: false,
-          version: "v2",
-          error: null,
-        },
-      },
-    ]);
-  });
-
-  it("reverts optimistic set state and emits a revert event when the write fails", async () => {
-    const fetchMock = vi.fn(
-      async (_input: RequestInfo | URL, init?: RequestInit) => {
-        if (!init?.method) {
-          return listResponse({
-            values: { todos: ["seed"] },
-            versions: { todos: "v1" },
-            hash: "list-hash",
-          });
-        }
-        return new Response("write failed", { status: 500 });
-      },
-    );
-    const windowObject: ScriptWindow = {
-      crypto: { randomUUID: () => "op-from-crypto" },
-    };
-
-    executeScript({
-      html: injectStatusStateClientScript(
-        "<html><head></head></html>",
-        bootstrap,
-      ),
-      window: windowObject,
-      fetch: fetchMock,
-    });
-    const state = windowObject.bbStatusState;
-    if (!state) {
-      throw new Error("bbStatusState was not installed");
-    }
-    const calls: CallbackCall[] = [];
-    state.on("todos", (newValue, prevValue, key, event) => {
-      calls.push({ newValue, prevValue, key, event });
-    });
-    await state.list();
-
-    await expect(state.set("todos", ["next"])).rejects.toThrow("write failed");
-
-    expect(await state.get("todos")).toEqual(["seed"]);
-    expect(calls.slice(1)).toEqual([
-      {
-        newValue: ["next"],
-        prevValue: ["seed"],
-        key: "todos",
-        event: {
-          source: "local",
-          operation: "set",
-          optimistic: true,
-          version: null,
-          error: null,
-        },
-      },
-      {
-        newValue: ["seed"],
-        prevValue: ["next"],
-        key: "todos",
-        event: {
-          source: "local",
-          operation: "revert",
-          optimistic: false,
-          version: "v1",
-          error: "write failed",
-        },
-      },
-    ]);
-  });
-});
diff --git a/apps/server/test/threads/manager-storage-templates.test.ts b/apps/server/test/threads/manager-storage-templates.test.ts
index c17f9c80e..2530080fa 100644
--- a/apps/server/test/threads/manager-storage-templates.test.ts
+++ b/apps/server/test/threads/manager-storage-templates.test.ts
@@ -76,16 +76,6 @@ async function createSeedHarness(): Promise<SeedHarness> {
   };
 }
 
-async function readBundledStatusTemplate(): Promise<string> {
-  return readFile(
-    new URL(
-      "../../src/services/threads/default-template/STATUS.html",
-      import.meta.url,
-    ),
-    "utf8",
-  );
-}
-
 async function readBundledStatusAppFile(relativePath: string): Promise<string> {
   return readFile(
     new URL(
@@ -156,7 +146,7 @@ describe("manager storage templates", () => {
     }
   });
 
-  it("seeds bundled status when default resolves and no user template directory exists", async () => {
+  it("seeds the bundled status app when default resolves and no user template directory exists", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     try {
       const threadStoragePath = await seedStorage({
@@ -167,9 +157,6 @@ describe("manager storage templates", () => {
         threadId: "thr-default-fallback",
       });
 
-      await expect(
-        readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
-      ).resolves.toBe(await readBundledStatusTemplate());
       await expect(
         readFile(
           path.join(threadStoragePath, "apps/status/manifest.json"),
@@ -204,7 +191,7 @@ describe("manager storage templates", () => {
         dataDir,
         name: DEFAULT_MANAGER_TEMPLATE_NAME,
         files: {
-          "STATUS.html": "user status\n",
+          "apps/custom/data/state.json": "{}\n",
           "apps/custom/manifest.json": "{}\n",
           "apps/custom/assets/index.html": "<h1>Custom</h1>\n",
         },
@@ -219,8 +206,11 @@ describe("manager storage templates", () => {
       });
 
       await expect(
-        readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
-      ).resolves.toBe("user status\n");
+        readFile(
+          path.join(threadStoragePath, "apps/custom/data/state.json"),
+          "utf8",
+        ),
+      ).resolves.toBe("{}\n");
       await expect(
         readFile(
           path.join(threadStoragePath, "apps/custom/assets/index.html"),
@@ -335,7 +325,7 @@ describe("manager storage templates", () => {
         dataDir,
         name: MINE_MANAGER_TEMPLATE_NAME,
         files: {
-          "STATUS.html": "mine status\n",
+          "apps/mine/manifest.json": "{}\n",
           "apps/mine/data/state.json": "{}\n",
         },
       });
@@ -349,8 +339,11 @@ describe("manager storage templates", () => {
       });
 
       await expect(
-        readFile(path.join(threadStoragePath, "STATUS.html"), "utf8"),
-      ).resolves.toBe("mine status\n");
+        readFile(
+          path.join(threadStoragePath, "apps/mine/manifest.json"),
+          "utf8",
+        ),
+      ).resolves.toBe("{}\n");
       await expect(
         readFile(
           path.join(threadStoragePath, "apps/mine/data/state.json"),
diff --git a/packages/domain/src/index.ts b/packages/domain/src/index.ts
index e6cec2f80..6774ff618 100644
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -444,9 +444,6 @@ export type {
 export { jsonObjectSchema, jsonValueSchema } from "./json-value.js";
 export type { JsonObject, JsonValue } from "./json-value.js";
 
-export { statusDataKeySchema } from "./status-data.js";
-export type { StatusDataKey } from "./status-data.js";
-
 export {
   assertThreadEventScope,
   getThreadEventScopeTurnId,
diff --git a/packages/domain/src/status-data.ts b/packages/domain/src/status-data.ts
deleted file mode 100644
index 68bac3f5a..000000000
--- a/packages/domain/src/status-data.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { z } from "zod";
-
-export const statusDataKeySchema = z.string().regex(/^[A-Za-z0-9_-]{1,80}$/u);
-export type StatusDataKey = z.infer<typeof statusDataKeySchema>;
diff --git a/packages/host-daemon-contract/src/commands.ts b/packages/host-daemon-contract/src/commands.ts
index 596125b2e..d15788222 100644
--- a/packages/host-daemon-contract/src/commands.ts
+++ b/packages/host-daemon-contract/src/commands.ts
@@ -17,8 +17,6 @@ import {
   clientTurnRequestIdSchema,
   gitBranchNameSchema,
   jsonObjectSchema,
-  jsonValueSchema,
-  statusDataKeySchema,
 } from "@bb/domain";
 import {
   replayCaptureDaemonListResponseSchema,
@@ -27,7 +25,7 @@ import {
 } from "@bb/replay-capture/schema";
 import { z } from "zod";
 
-export const HOST_DAEMON_PROTOCOL_VERSION = 25 as const;
+export const HOST_DAEMON_PROTOCOL_VERSION = 26 as const;
 
 export const FILE_LIST_QUERY_MAX_LENGTH = 256;
 export const FILE_LIST_LIMIT_MAX = 10_000;
@@ -50,11 +48,6 @@ export const HOST_DAEMON_COMMAND_TYPES = [
   "host.list_branches",
   "host.list_manager_templates",
   "host.file_metadata",
-  "host.status_version",
-  "host.status_data.list",
-  "host.status_data.get",
-  "host.status_data.set",
-  "host.status_data.delete",
   "host.read_file",
   "host.read_file_relative",
   "host.write_file_relative",
@@ -351,103 +344,6 @@ export const hostFileMetadataCommandSchema = z
   })
   .strict();
 
-export const hostStatusVersionSourceSchema = z.enum([
-  "folder",
-  "html",
-  "md",
-  "empty",
-]);
-export type HostStatusVersionSource = z.infer<
-  typeof hostStatusVersionSourceSchema
->;
-
-export const hostStatusVersionFolderSourceSchema = z
-  .object({
-    source: z.literal("folder"),
-    rootPath: z.string().min(1),
-    indexPath: z.string().min(1),
-    dotfiles: hostReadFileRelativeDotfilePolicySchema,
-  })
-  .strict();
-export type HostStatusVersionFolderSource = z.infer<
-  typeof hostStatusVersionFolderSourceSchema
->;
-
-export const hostStatusVersionHtmlSourceSchema = z
-  .object({
-    source: z.literal("html"),
-    rootPath: z.string().min(1),
-    path: z.string().min(1),
-    dotfiles: hostReadFileRelativeDotfilePolicySchema,
-  })
-  .strict();
-export type HostStatusVersionHtmlSource = z.infer<
-  typeof hostStatusVersionHtmlSourceSchema
->;
-
-export const hostStatusVersionMarkdownSourceSchema = z
-  .object({
-    source: z.literal("md"),
-    rootPath: z.string().min(1),
-    path: z.string().min(1),
-    dotfiles: hostReadFileRelativeDotfilePolicySchema,
-  })
-  .strict();
-export type HostStatusVersionMarkdownSource = z.infer<
-  typeof hostStatusVersionMarkdownSourceSchema
->;
-
-export const hostStatusVersionFileSourceSchema = z.union([
-  hostStatusVersionHtmlSourceSchema,
-  hostStatusVersionMarkdownSourceSchema,
-]);
-export type HostStatusVersionFileSource = z.infer<
-  typeof hostStatusVersionFileSourceSchema
->;
-
-export const hostStatusVersionCommandSchema = z
-  .object({
-    type: z.literal("host.status_version"),
-    sources: z.tuple([
-      hostStatusVersionFolderSourceSchema,
-      hostStatusVersionHtmlSourceSchema,
-      hostStatusVersionMarkdownSourceSchema,
-    ]),
-  })
-  .strict();
-
-const hostStatusDataTargetSchema = z.object({
-  threadId: z.string().min(1),
-});
-
-export const hostStatusDataListCommandSchema = hostStatusDataTargetSchema
-  .extend({
-    type: z.literal("host.status_data.list"),
-  })
-  .strict();
-
-export const hostStatusDataGetCommandSchema = hostStatusDataTargetSchema
-  .extend({
-    type: z.literal("host.status_data.get"),
-    key: statusDataKeySchema,
-  })
-  .strict();
-
-export const hostStatusDataSetCommandSchema = hostStatusDataTargetSchema
-  .extend({
-    type: z.literal("host.status_data.set"),
-    key: statusDataKeySchema,
-    value: jsonValueSchema,
-  })
-  .strict();
-
-export const hostStatusDataDeleteCommandSchema = hostStatusDataTargetSchema
-  .extend({
-    type: z.literal("host.status_data.delete"),
-    key: statusDataKeySchema,
-  })
-  .strict();
-
 export const hostListFilesCommandSchema = z.object({
   type: z.literal("host.list_files"),
   path: z.string().min(1),
@@ -677,11 +573,6 @@ const hostDaemonNonProvisionCommandSchema = z.discriminatedUnion("type", [
   hostListBranchesCommandSchema,
   hostListManagerTemplatesCommandSchema,
   hostFileMetadataCommandSchema,
-  hostStatusVersionCommandSchema,
-  hostStatusDataListCommandSchema,
-  hostStatusDataGetCommandSchema,
-  hostStatusDataSetCommandSchema,
-  hostStatusDataDeleteCommandSchema,
   hostReadFileCommandSchema,
   hostReadFileRelativeCommandSchema,
   hostWriteFileRelativeCommandSchema,
@@ -715,11 +606,6 @@ export function shouldFlushEventsBeforeReportingCommandResult(
     case "environment.destroy":
     case "host.list_branches":
     case "host.file_metadata":
-    case "host.status_version":
-    case "host.status_data.list":
-    case "host.status_data.get":
-    case "host.status_data.set":
-    case "host.status_data.delete":
     case "host.list_files":
     case "host.list_paths":
     case "host.list_manager_templates":
@@ -781,96 +667,6 @@ const pathDeleteResultSchema = z.object({
   deleted: z.boolean(),
 });
 
-const statusVersionResultSchema = z.object({
-  source: hostStatusVersionSourceSchema,
-  hash: z.string().min(1),
-});
-
-const statusDataValueRecordSchema = z.record(
-  statusDataKeySchema,
-  jsonValueSchema,
-);
-
-const statusDataVersionRecordSchema = z.record(
-  statusDataKeySchema,
-  z.string().min(1),
-);
-
-const statusDataListResultSchema = z
-  .object({
-    values: statusDataValueRecordSchema,
-    versions: statusDataVersionRecordSchema,
-    hash: z.string().min(1),
-  })
-  .strict();
-
-const statusDataEntryResultSchema = z
-  .object({
-    key: statusDataKeySchema,
-    value: jsonValueSchema,
-    version: z.string().min(1),
-    sizeBytes: z.number().int().nonnegative(),
-    modifiedAtMs: z.number().nonnegative(),
-  })
-  .strict();
-
-const statusDataPreviousValueSchema = z
-  .object({
-    previousValue: jsonValueSchema.nullable(),
-    previousValuePresent: z.boolean(),
-    previousVersion: z.string().min(1).nullable(),
-  })
-  .strict();
-
-interface StatusDataPreviousValueInvariantInput {
-  previousValuePresent: boolean;
-  previousVersion: string | null;
-}
-
-function refineStatusDataPreviousValue(
-  value: StatusDataPreviousValueInvariantInput,
-  context: z.RefinementCtx,
-): void {
-  if (!value.previousValuePresent && value.previousVersion !== null) {
-    context.addIssue({
-      code: "custom",
-      path: ["previousVersion"],
-      message:
-        "previousVersion must be null when previousValuePresent is false",
-    });
-  }
-  if (value.previousValuePresent && value.previousVersion === null) {
-    context.addIssue({
-      code: "custom",
-      path: ["previousVersion"],
-      message: "previousVersion is required when previousValuePresent is true",
-    });
-  }
-}
-
-const statusDataSetResultSchema = statusDataEntryResultSchema
-  .merge(statusDataPreviousValueSchema)
-  .strict()
-  .superRefine(refineStatusDataPreviousValue);
-
-const statusDataDeleteResultSchema = z
-  .object({
-    key: statusDataKeySchema,
-    deleted: z.boolean(),
-  })
-  .merge(statusDataPreviousValueSchema)
-  .strict()
-  .superRefine((value, context) => {
-    refineStatusDataPreviousValue(value, context);
-    if (value.deleted !== value.previousValuePresent) {
-      context.addIssue({
-        code: "custom",
-        path: ["deleted"],
-        message: "deleted must match previousValuePresent",
-      });
-    }
-  });
-
 const fileListResultSchema = z.object({
   files: z.array(z.object({ path: z.string(), name: z.string() })),
   truncated: z.boolean(),
@@ -909,11 +705,6 @@ export const hostDaemonCommandResultSchemaByType = {
   "host.list_files": fileListResultSchema,
   "host.list_paths": pathListResultSchema,
   "host.file_metadata": fileMetadataResultSchema,
-  "host.status_version": statusVersionResultSchema,
-  "host.status_data.list": statusDataListResultSchema,
-  "host.status_data.get": statusDataEntryResultSchema,
-  "host.status_data.set": statusDataSetResultSchema,
-  "host.status_data.delete": statusDataDeleteResultSchema,
   "host.list_branches": projectSourceCheckoutSchema,
   "host.list_manager_templates": z.object({
     /** Sorted alphabetically. Includes only template names that contain at least one regular file. */
diff --git a/packages/host-daemon-contract/src/index.ts b/packages/host-daemon-contract/src/index.ts
index fe677608b..2c0e0004d 100644
--- a/packages/host-daemon-contract/src/index.ts
+++ b/packages/host-daemon-contract/src/index.ts
@@ -110,17 +110,7 @@ export {
   hostListPathsCommandSchema,
   hostListBranchesCommandSchema,
   hostListManagerTemplatesCommandSchema,
-  hostStatusVersionCommandSchema,
-  hostStatusDataDeleteCommandSchema,
-  hostStatusDataGetCommandSchema,
-  hostStatusDataListCommandSchema,
-  hostStatusDataSetCommandSchema,
   managerTemplateSummarySchema,
-  hostStatusVersionFileSourceSchema,
-  hostStatusVersionFolderSourceSchema,
-  hostStatusVersionHtmlSourceSchema,
-  hostStatusVersionMarkdownSourceSchema,
-  hostStatusVersionSourceSchema,
   hostReadFileCommandSchema,
   hostReadFileRelativeCommandSchema,
   hostReadFileRelativeDotfilePolicySchema,
@@ -158,11 +148,6 @@ export type {
   HostPathEntryKind,
   HostReadFileRelativeDotfilePolicy,
   ManagerTemplateSummary,
-  HostStatusVersionFileSource,
-  HostStatusVersionFolderSource,
-  HostStatusVersionHtmlSource,
-  HostStatusVersionMarkdownSource,
-  HostStatusVersionSource,
   TurnSubmitTarget,
   WorkspaceContext,
 } from "./commands.js";
@@ -200,8 +185,6 @@ export {
   hostDaemonSessionCloseReasonSchema,
   hostDaemonSessionOpenRequestSchema,
   hostDaemonSessionOpenResponseSchema,
-  hostDaemonStatusDataChangePayloadSchema,
-  hostDaemonStatusDataChangeRequestSchema,
   hostDaemonTerminalOutputChunkSchema,
   hostDaemonTrackedThreadTargetSchema,
   hostDaemonToolCallRequestSchema,
@@ -239,8 +222,6 @@ export type {
   HostDaemonSessionCloseReason,
   HostDaemonSessionOpenRequest,
   HostDaemonSessionOpenResponse,
-  HostDaemonStatusDataChangePayload,
-  HostDaemonStatusDataChangeRequest,
   HostDaemonTerminalOutputChunk,
   HostDaemonTrackedThreadTarget,
   HostDaemonToolCallRequest,
diff --git a/packages/host-daemon-contract/src/session.ts b/packages/host-daemon-contract/src/session.ts
index e13ce5db8..20ac2eb74 100644
--- a/packages/host-daemon-contract/src/session.ts
+++ b/packages/host-daemon-contract/src/session.ts
@@ -7,7 +7,6 @@ import {
   jsonValueSchema,
   pendingInteractionCreateSchema,
   pendingInteractionStatusSchema,
-  statusDataKeySchema,
   appDataPathSchema,
   appIdSchema,
   terminalColsSchema,
@@ -207,75 +206,6 @@ export type HostDaemonEnvironmentChangeRequest = z.infer<
   typeof hostDaemonEnvironmentChangeRequestSchema
 >;
 
-const hostDaemonStatusDataChangePayloadBaseSchema = z
-  .object({
-    threadId: z.string().min(1),
-    key: statusDataKeySchema,
-    value: jsonValueSchema.nullable(),
-    deleted: z.boolean(),
-    previousValue: jsonValueSchema.nullable(),
-    previousValuePresent: z.boolean(),
-    version: z.string().min(1).nullable(),
-    previousVersion: z.string().min(1).nullable(),
-  })
-  .strict();
-type HostDaemonStatusDataChangePayloadBase = z.infer<
-  typeof hostDaemonStatusDataChangePayloadBaseSchema
->;
-
-function validateHostDaemonStatusDataChangePayload(
-  payload: HostDaemonStatusDataChangePayloadBase,
-  context: z.RefinementCtx,
-): void {
-  if (payload.deleted && payload.version !== null) {
-    context.addIssue({
-      code: "custom",
-      path: ["version"],
-      message: "version must be null for deleted STATUS-data changes",
-    });
-  }
-  if (!payload.deleted && payload.version === null) {
-    context.addIssue({
-      code: "custom",
-      path: ["version"],
-      message: "version is required for non-deleted STATUS-data changes",
-    });
-  }
-  if (!payload.previousValuePresent && payload.previousVersion !== null) {
-    context.addIssue({
-      code: "custom",
-      path: ["previousVersion"],
-      message: "previousVersion must be null when previousValuePresent is false",
-    });
-  }
-  if (payload.previousValuePresent && payload.previousVersion === null) {
-    context.addIssue({
-      code: "custom",
-      path: ["previousVersion"],
-      message: "previousVersion is required when previousValuePresent is true",
-    });
-  }
-}
-
-export const hostDaemonStatusDataChangePayloadSchema =
-  hostDaemonStatusDataChangePayloadBaseSchema.superRefine(
-    validateHostDaemonStatusDataChangePayload,
-  );
-export type HostDaemonStatusDataChangePayload = z.infer<
-  typeof hostDaemonStatusDataChangePayloadSchema
->;
-
-export const hostDaemonStatusDataChangeRequestSchema = z
-  .object({
-    sessionId: z.string().min(1),
-    ...hostDaemonStatusDataChangePayloadBaseSchema.shape,
-  })
-  .strict()
-  .superRefine(validateHostDaemonStatusDataChangePayload);
-export type HostDaemonStatusDataChangeRequest = z.infer<
-  typeof hostDaemonStatusDataChangeRequestSchema
->;
-
 const hostDaemonAppDataChangePayloadBaseSchema = z
   .object({
     threadId: z.string().min(1),
@@ -650,10 +580,6 @@ export type HostDaemonInternalSchema = {
     /** Used by the daemon to report raw environment workspace change hints for server-side validation and fan-out. */
     $post: Endpoint<{ json: HostDaemonEnvironmentChangeRequest }, { ok: true }>;
   };
-  "/session/status-data-change": {
-    /** Used by the daemon to report host-local STATUS-data file changes for server websocket fan-out. */
-    $post: Endpoint<{ json: HostDaemonStatusDataChangeRequest }, { ok: true }>;
-  };
   "/session/app-data-change": {
     /** Used by the daemon to report host-local app data file changes for server websocket fan-out. */
     $post: Endpoint<{ json: HostDaemonAppDataChangeRequest }, { ok: true }>;
diff --git a/packages/host-daemon-contract/test/contract.test.ts b/packages/host-daemon-contract/test/contract.test.ts
index a09aa3cfe..09694488b 100644
--- a/packages/host-daemon-contract/test/contract.test.ts
+++ b/packages/host-daemon-contract/test/contract.test.ts
@@ -396,87 +396,6 @@ describe("host-daemon command schemas", () => {
       rootPath: "/tmp/bb-data/thread-storage/thread-123",
     });
 
-    expect(
-      hostDaemonCommandSchema.parse({
-        type: "host.status_version",
-        sources: [
-          {
-            source: "folder",
-            rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS",
-            indexPath: "index.html",
-            dotfiles: "deny",
-          },
-          {
-            source: "html",
-            rootPath: "/tmp/bb-data/thread-storage/thread-123",
-            path: "STATUS.html",
-            dotfiles: "allow",
-          },
-          {
-            source: "md",
-            rootPath: "/tmp/bb-data/thread-storage/thread-123",
-            path: "STATUS.md",
-            dotfiles: "allow",
-          },
-        ],
-      }),
-    ).toMatchObject({
-      type: "host.status_version",
-      sources: [
-        { source: "folder", indexPath: "index.html", dotfiles: "deny" },
-        { source: "html", path: "STATUS.html", dotfiles: "allow" },
-        { source: "md", path: "STATUS.md", dotfiles: "allow" },
-      ],
-    });
-
-    expect(
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.list",
-        threadId: "thread-123",
-      }),
-    ).toEqual({
-      type: "host.status_data.list",
-      threadId: "thread-123",
-    });
-
-    expect(
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.get",
-        threadId: "thread-123",
-        key: "tasks",
-      }),
-    ).toEqual({
-      type: "host.status_data.get",
-      threadId: "thread-123",
-      key: "tasks",
-    });
-
-    expect(
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.set",
-        threadId: "thread-123",
-        key: "tasks",
-        value: [{ id: "task-1", title: "Review" }],
-      }),
-    ).toEqual({
-      type: "host.status_data.set",
-      threadId: "thread-123",
-      key: "tasks",
-      value: [{ id: "task-1", title: "Review" }],
-    });
-
-    expect(
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.delete",
-        threadId: "thread-123",
-        key: "tasks",
-      }),
-    ).toEqual({
-      type: "host.status_data.delete",
-      threadId: "thread-123",
-      key: "tasks",
-    });
-
     expect(
       hostDaemonCommandSchema.parse({
         type: "host.read_file",
@@ -516,41 +435,41 @@ describe("host-daemon command schemas", () => {
     expect(
       hostDaemonCommandSchema.parse({
         type: "host.read_file_relative",
-        rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS",
-        path: "assets/logo.png",
+        rootPath: "/tmp/bb-data/thread-storage/thread-123/apps/status/assets",
+        path: "logo.png",
         dotfiles: "deny",
       }),
     ).toMatchObject({
       type: "host.read_file_relative",
-      rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS",
-      path: "assets/logo.png",
+      rootPath: "/tmp/bb-data/thread-storage/thread-123/apps/status/assets",
+      path: "logo.png",
       dotfiles: "deny",
     });
 
     expect(
       hostDaemonCommandSchema.parse({
         type: "host.write_file_relative",
-        rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS-data",
-        path: "tasks.json",
+        rootPath: "/tmp/bb-data/thread-storage/thread-123/apps/status/data",
+        path: "state.json",
         dotfiles: "deny",
         content: "[1,2,3]\n",
         contentEncoding: "utf8",
       }),
     ).toMatchObject({
       type: "host.write_file_relative",
-      path: "tasks.json",
+      path: "state.json",
     });
 
     expect(
       hostDaemonCommandSchema.parse({
         type: "host.delete_file_relative",
-        rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS-data",
-        path: "tasks.json",
+        rootPath: "/tmp/bb-data/thread-storage/thread-123/apps/status/data",
+        path: "state.json",
         dotfiles: "deny",
       }),
     ).toMatchObject({
       type: "host.delete_file_relative",
-      path: "tasks.json",
+      path: "state.json",
     });
 
     expect(
@@ -745,24 +664,8 @@ describe("host-daemon command schemas", () => {
     expect(() =>
       hostDaemonCommandSchema.parse({
         type: "host.read_file_relative",
-        rootPath: "/tmp/bb-data/thread-storage/thread-123/STATUS",
-        path: "assets/logo.png",
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.get",
-        threadId: "thread-123",
-        key: "../tasks",
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandSchema.parse({
-        type: "host.status_data.set",
-        threadId: "thread-123",
-        key: "tasks",
+        rootPath: "/tmp/bb-data/thread-storage/thread-123/apps/status/assets",
+        path: "logo.png",
       }),
     ).toThrow();
   });
@@ -1393,146 +1296,6 @@ describe("host-daemon command schemas", () => {
       deleted: true,
     });
 
-    expect(
-      hostDaemonCommandResultSchemaByType["host.status_version"].parse({
-        source: "folder",
-        hash: "abc123",
-      }),
-    ).toEqual({
-      source: "folder",
-      hash: "abc123",
-    });
-
-    expect(
-      hostDaemonCommandResultSchemaByType["host.status_data.list"].parse({
-        values: {
-          tasks: [{ id: "task-1" }],
-          prefs: { compact: true },
-        },
-        versions: {
-          tasks: "tasks-hash",
-          prefs: "prefs-hash",
-        },
-        hash: "aggregate-hash",
-      }),
-    ).toEqual({
-      values: {
-        tasks: [{ id: "task-1" }],
-        prefs: { compact: true },
-      },
-      versions: {
-        tasks: "tasks-hash",
-        prefs: "prefs-hash",
-      },
-      hash: "aggregate-hash",
-    });
-
-    expect(
-      hostDaemonCommandResultSchemaByType["host.status_data.get"].parse({
-        key: "tasks",
-        value: [{ id: "task-1" }],
-        version: "tasks-hash",
-        sizeBytes: 24,
-        modifiedAtMs: 1234.5,
-      }),
-    ).toEqual({
-      key: "tasks",
-      value: [{ id: "task-1" }],
-      version: "tasks-hash",
-      sizeBytes: 24,
-      modifiedAtMs: 1234.5,
-    });
-
-    expect(
-      hostDaemonCommandResultSchemaByType["host.status_data.set"].parse({
-        key: "tasks",
-        value: [{ id: "task-2" }],
-        version: "next-hash",
-        sizeBytes: 24,
-        modifiedAtMs: 1234.5,
-        previousValue: [{ id: "task-1" }],
-        previousValuePresent: true,
-        previousVersion: "previous-hash",
-      }),
-    ).toMatchObject({
-      key: "tasks",
-      version: "next-hash",
-      previousValuePresent: true,
-      previousVersion: "previous-hash",
-    });
-
-    expect(
-      hostDaemonCommandResultSchemaByType["host.status_data.delete"].parse({
-        key: "tasks",
-        deleted: true,
-        previousValue: null,
-        previousValuePresent: true,
-        previousVersion: "previous-null-hash",
-      }),
-    ).toEqual({
-      key: "tasks",
-      deleted: true,
-      previousValue: null,
-      previousValuePresent: true,
-      previousVersion: "previous-null-hash",
-    });
-
-    expect(() =>
-      hostDaemonCommandResultSchemaByType["host.status_data.delete"].parse({
-        key: "tasks",
-        deleted: false,
-        previousValue: ["stale"],
-        previousValuePresent: true,
-        previousVersion: "previous-hash",
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandResultSchemaByType["host.status_data.set"].parse({
-        key: "tasks",
-        value: [{ id: "task-2" }],
-        version: "next-hash",
-        sizeBytes: 24,
-        modifiedAtMs: 1234.5,
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: "previous-hash",
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandResultSchemaByType["host.status_data.set"].parse({
-        key: "tasks",
-        value: [{ id: "task-2" }],
-        version: "next-hash",
-        sizeBytes: 24,
-        modifiedAtMs: 1234.5,
-        previousValue: [{ id: "task-1" }],
-        previousValuePresent: true,
-        previousVersion: null,
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandResultSchemaByType["host.status_data.delete"].parse({
-        key: "tasks",
-        deleted: false,
-        previousValue: null,
-        previousValuePresent: false,
-        previousVersion: "previous-hash",
-      }),
-    ).toThrow();
-
-    expect(() =>
-      hostDaemonCommandResultSchemaByType["host.status_data.delete"].parse({
-        key: "tasks",
-        deleted: true,
-        previousValue: [{ id: "task-1" }],
-        previousValuePresent: true,
-        previousVersion: null,
-      }),
-    ).toThrow();
-
     expect(() =>
       hostDaemonCommandResultSchemaByType["workspace.commit"].parse({
         commitSha: "",
@@ -1823,62 +1586,6 @@ describe("host-daemon session schemas", () => {
       change: "thread-storage-changed",
     });
 
-    expect(
-      contract.hostDaemonStatusDataChangeRequestSchema.parse({
-        sessionId: "session_123",
-        threadId: "thr_123",
-        key: "tasks",
-        value: [{ id: "task-2" }],
-        deleted: false,
-        previousValue: [{ id: "task-1" }],
-        previousValuePresent: true,
-        version: "next-hash",
-        previousVersion: "previous-hash",
-      }),
-    ).toEqual({
-      sessionId: "session_123",
-      threadId: "thr_123",
-      key: "tasks",
-      value: [{ id: "task-2" }],
-      deleted: false,
-      previousValue: [{ id: "task-1" }],
-      previousValuePresent: true,
-      version: "next-hash",
-      previousVersion: "previous-hash",
-    });
-
-    expect(
-      contract.hostDaemonStatusDataChangeRequestSchema.parse({
-        sessionId: "session_123",
-        threadId: "thr_123",
-        key: "tasks",
-        value: null,
-        deleted: true,
-        previousValue: null,
-        previousValuePresent: true,
-        version: null,
-        previousVersion: "previous-null-hash",
-      }),
-    ).toMatchObject({
-      deleted: true,
-      previousValuePresent: true,
-      version: null,
-    });
-
-    expect(() =>
-      contract.hostDaemonStatusDataChangeRequestSchema.parse({
-        sessionId: "session_123",
-        threadId: "thr_123",
-        key: "tasks",
-        value: [],
-        deleted: false,
-        previousValue: null,
-        previousValuePresent: false,
-        version: null,
-        previousVersion: null,
-      }),
-    ).toThrow();
-
     expect(
       contract.hostDaemonAppDataChangeRequestSchema.parse({
         sessionId: "session_123",
@@ -2170,9 +1877,6 @@ describe("host-daemon session schemas", () => {
     expect(client.session["environment-change"].$url().pathname).toBe(
       "/internal/session/environment-change",
     );
-    expect(client.session["status-data-change"].$url().pathname).toBe(
-      "/internal/session/status-data-change",
-    );
     expect(client.session["app-data-change"].$url().pathname).toBe(
       "/internal/session/app-data-change",
     );
diff --git a/packages/host-watcher/src/host-watcher-types.ts b/packages/host-watcher/src/host-watcher-types.ts
index 7a86273ee..e003033a6 100644
--- a/packages/host-watcher/src/host-watcher-types.ts
+++ b/packages/host-watcher/src/host-watcher-types.ts
@@ -1,5 +1,5 @@
 import type { HostType } from "@bb/domain";
-import type { AppDataPath, AppId, StatusDataKey } from "@bb/domain";
+import type { AppDataPath, AppId } from "@bb/domain";
 import type { WorkspaceStatusWatchChangeKind } from "./watch-status-types.js";
 
 export type HostObservedChange =
@@ -14,12 +14,6 @@ export type HostObservedChange =
       environmentId: string;
       threadId: string;
     }
-  | {
-      kind: "thread-status-data-changed";
-      environmentId: string;
-      key: StatusDataKey;
-      threadId: string;
-    }
   | {
       kind: "thread-app-data-changed";
       appId: AppId;
@@ -36,10 +30,7 @@ export type WorkspaceObservedChange = Extract<
 export type ThreadStorageObservedChange = Extract<
   HostObservedChange,
   {
-    kind:
-      | "thread-storage-changed"
-      | "thread-status-data-changed"
-      | "thread-app-data-changed";
+    kind: "thread-storage-changed" | "thread-app-data-changed";
   }
 >;
 
diff --git a/packages/host-watcher/src/index.ts b/packages/host-watcher/src/index.ts
index 01ef67cb5..2eaa0f5bb 100644
--- a/packages/host-watcher/src/index.ts
+++ b/packages/host-watcher/src/index.ts
@@ -18,12 +18,6 @@ export type {
   WorkspaceStatusChangeEvent,
   WorkspaceStatusWatchChangeKind,
 } from "./watch-status-types.js";
-export {
-  parseStatusDataFileName,
-  statusDataFileName,
-  STATUS_DATA_DIRECTORY_NAME,
-  STATUS_DATA_FILE_EXTENSION,
-} from "./status-data-paths.js";
 
 export async function createHostWatcher(
   _args: CreateHostWatcherArgs,
diff --git a/packages/host-watcher/src/parcel-host-watcher.ts b/packages/host-watcher/src/parcel-host-watcher.ts
index 323e66a93..ca0bc31a5 100644
--- a/packages/host-watcher/src/parcel-host-watcher.ts
+++ b/packages/host-watcher/src/parcel-host-watcher.ts
@@ -4,12 +4,7 @@ import {
   appIdSchema,
   type AppDataPath,
   type AppId,
-  type StatusDataKey,
 } from "@bb/domain";
-import {
-  parseStatusDataFileName,
-  STATUS_DATA_DIRECTORY_NAME,
-} from "./status-data-paths.js";
 import { watchPathChanges } from "./watch-path.js";
 import { watchWorkspaceStatus } from "./watch-status.js";
 import type {
@@ -30,11 +25,6 @@ interface ThreadStoragePath {
   threadId: string;
 }
 
-interface ThreadStatusDataPath {
-  key: StatusDataKey;
-  threadId: string;
-}
-
 interface ThreadAppDataPath {
   appId: AppId;
   path: AppDataPath;
@@ -72,31 +62,13 @@ function toThreadStoragePath(
   };
 }
 
-function isStatusDataSubtreePath(path: ThreadStoragePath): boolean {
-  return path.parts[1] === STATUS_DATA_DIRECTORY_NAME;
-}
-
 function isAppDataSubtreePath(path: ThreadStoragePath): boolean {
   return path.parts[1] === "apps" && path.parts[3] === "data";
 }
 
-function toThreadStatusDataPath(
+function toThreadAppDataPath(
   path: ThreadStoragePath,
-): ThreadStatusDataPath | null {
-  if (!isStatusDataSubtreePath(path) || path.parts.length !== 3) {
-    return null;
-  }
-  const parsedKey = parseStatusDataFileName(path.parts[2] ?? "");
-  if (!parsedKey) {
-    return null;
-  }
-  return {
-    threadId: path.threadId,
-    key: parsedKey,
-  };
-}
-
-function toThreadAppDataPath(path: ThreadStoragePath): ThreadAppDataPath | null {
+): ThreadAppDataPath | null {
   if (!isAppDataSubtreePath(path) || path.parts.length < 5) {
     return null;
   }
@@ -119,7 +91,6 @@ export function collectThreadStorageObservedChanges(
   args: CollectThreadStorageObservedChangesArgs,
 ): ThreadStorageObservedChange[] {
   const storageChanges = new Map<string, ThreadStorageWatchTarget>();
-  const statusDataChanges = new Map<string, ThreadStorageObservedChange>();
   const appDataChanges = new Map<string, ThreadStorageObservedChange>();
   for (const changedPath of args.changedPaths) {
     const storagePath = toThreadStoragePath({
@@ -133,21 +104,6 @@ export function collectThreadStorageObservedChanges(
     if (!target) {
       continue;
     }
-    if (isStatusDataSubtreePath(storagePath)) {
-      const statusDataPath = toThreadStatusDataPath(storagePath);
-      if (statusDataPath) {
-        statusDataChanges.set(
-          `${target.environmentId}:${target.threadId}:${statusDataPath.key}`,
-          {
-            kind: "thread-status-data-changed",
-            environmentId: target.environmentId,
-            threadId: target.threadId,
-            key: statusDataPath.key,
-          },
-        );
-      }
-      continue;
-    }
     if (isAppDataSubtreePath(storagePath)) {
       const appDataPath = toThreadAppDataPath(storagePath);
       if (appDataPath) {
@@ -175,7 +131,6 @@ export function collectThreadStorageObservedChanges(
       threadId: target.threadId,
     });
   }
-  observedChanges.push(...statusDataChanges.values());
   observedChanges.push(...appDataChanges.values());
   return observedChanges;
 }
diff --git a/packages/host-watcher/src/status-data-paths.ts b/packages/host-watcher/src/status-data-paths.ts
deleted file mode 100644
index a43ab934a..000000000
--- a/packages/host-watcher/src/status-data-paths.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { statusDataKeySchema, type StatusDataKey } from "@bb/domain";
-
-export const STATUS_DATA_DIRECTORY_NAME = "STATUS-data";
-export const STATUS_DATA_FILE_EXTENSION = ".json";
-
-export function statusDataFileName(key: StatusDataKey): string {
-  return `${key}${STATUS_DATA_FILE_EXTENSION}`;
-}
-
-export function parseStatusDataFileName(
-  fileName: string,
-): StatusDataKey | null {
-  if (!fileName.endsWith(STATUS_DATA_FILE_EXTENSION)) {
-    return null;
-  }
-  const rawKey = fileName.slice(0, -STATUS_DATA_FILE_EXTENSION.length);
-  const parsed = statusDataKeySchema.safeParse(rawKey);
-  return parsed.success ? parsed.data : null;
-}
diff --git a/packages/host-watcher/test/thread-storage-watch.test.ts b/packages/host-watcher/test/thread-storage-watch.test.ts
index a98e909b3..107fb9e82 100644
--- a/packages/host-watcher/test/thread-storage-watch.test.ts
+++ b/packages/host-watcher/test/thread-storage-watch.test.ts
@@ -10,21 +10,15 @@ function createResolver(
 }
 
 describe("thread storage watcher classification", () => {
-  it("emits broad storage changes and targeted STATUS-data changes", () => {
+  it("emits broad storage changes for ordinary thread storage changes", () => {
     const rootPath = path.join("/tmp", "thread-storage");
     const changes = collectThreadStorageObservedChanges({
       threadStorageRootPath: rootPath,
       changedPaths: [
         path.join(rootPath, "thr_one", "notes.md"),
-        path.join(rootPath, "thr_one", "STATUS-data", "tasks.json"),
-        path.join(rootPath, "thr_one", "STATUS-data", "tasks.json"),
         path.join(rootPath, "thr_two", "reports", "summary.html"),
-        path.join(rootPath, "thr_two", "STATUS-data", "prefs.json"),
-        path.join(rootPath, "thr_two", "STATUS-data", "nested", "x.json"),
-        path.join(rootPath, "thr_two", "STATUS-data", ".tmp.json"),
-        path.join(rootPath, "thr_three", "STATUS-data", "state.json"),
-        path.join(rootPath, "thr_unknown", "STATUS-data", "tasks.json"),
-        path.join(rootPath, "..", "outside", "STATUS-data", "tasks.json"),
+        path.join(rootPath, "thr_unknown", "notes.md"),
+        path.join(rootPath, "..", "outside", "notes.md"),
       ],
       resolveThreadTarget: createResolver({
         thr_one: {
@@ -35,10 +29,6 @@ describe("thread storage watcher classification", () => {
           environmentId: "env_two",
           threadId: "thr_two",
         },
-        thr_three: {
-          environmentId: "env_three",
-          threadId: "thr_three",
-        },
       }),
     });
 
@@ -53,48 +43,9 @@ describe("thread storage watcher classification", () => {
         environmentId: "env_two",
         threadId: "thr_two",
       },
-      {
-        kind: "thread-status-data-changed",
-        environmentId: "env_one",
-        threadId: "thr_one",
-        key: "tasks",
-      },
-      {
-        kind: "thread-status-data-changed",
-        environmentId: "env_two",
-        threadId: "thr_two",
-        key: "prefs",
-      },
-      {
-        kind: "thread-status-data-changed",
-        environmentId: "env_three",
-        threadId: "thr_three",
-        key: "state",
-      },
     ]);
   });
 
-  it("does not emit broad storage changes for STATUS-data subtree noise", () => {
-    const rootPath = path.join("/tmp", "thread-storage");
-    const changes = collectThreadStorageObservedChanges({
-      threadStorageRootPath: rootPath,
-      changedPaths: [
-        path.join(rootPath, "thr_one", "STATUS-data"),
-        path.join(rootPath, "thr_one", "STATUS-data", ".tasks.tmp"),
-        path.join(rootPath, "thr_one", "STATUS-data", "nested", "x.json"),
-        path.join(rootPath, "thr_one", "STATUS-data", "invalid.key.json"),
-      ],
-      resolveThreadTarget: createResolver({
-        thr_one: {
-          environmentId: "env_one",
-          threadId: "thr_one",
-        },
-      }),
-    });
-
-    expect(changes).toEqual([]);
-  });
-
   it("emits targeted app data changes without broad storage changes", () => {
     const rootPath = path.join("/tmp", "thread-storage");
     const changes = collectThreadStorageObservedChanges({
@@ -105,8 +56,22 @@ describe("thread storage watcher classification", () => {
         path.join(rootPath, "thr_one", "apps", "kanban", "data", "cards", "1"),
         path.join(rootPath, "thr_one", "apps", "bad.app", "data", "state.json"),
         path.join(rootPath, "thr_one", "apps", "status", "data", ".state.tmp"),
-        path.join(rootPath, "thr_one", "apps", "status", "assets", "index.html"),
-        path.join(rootPath, "thr_unknown", "apps", "status", "data", "state.json"),
+        path.join(
+          rootPath,
+          "thr_one",
+          "apps",
+          "status",
+          "assets",
+          "index.html",
+        ),
+        path.join(
+          rootPath,
+          "thr_unknown",
+          "apps",
+          "status",
+          "data",
+          "state.json",
+        ),
       ],
       resolveThreadTarget: createResolver({
         thr_one: {
diff --git a/packages/server-contract/src/api-types.ts b/packages/server-contract/src/api-types.ts
index 9c4703669..f4ff31422 100644
--- a/packages/server-contract/src/api-types.ts
+++ b/packages/server-contract/src/api-types.ts
@@ -34,7 +34,6 @@ import {
   workspaceStatusSchema,
   managerTemplateNameSchema,
   jsonValueSchema,
-  statusDataKeySchema,
   appDataPathSchema,
   appIdSchema,
 } from "@bb/domain";
@@ -43,7 +42,6 @@ import type {
   AppId,
   GitBranchName,
   JsonValue,
-  StatusDataKey,
 } from "@bb/domain";
 import { apiErrorSchema } from "./errors.js";
 import { timelineRowSchema } from "./thread-timeline.js";
@@ -384,37 +382,6 @@ export const sendMessageRequestSchema = z.object({
 });
 export type SendMessageRequest = z.infer<typeof sendMessageRequestSchema>;
 
-export const statusIframeThreadTellInputSchema = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-});
-export type StatusIframeThreadTellInput = z.infer<
-  typeof statusIframeThreadTellInputSchema
->;
-
-export const statusIframeThreadTellRequestSchema = z.object({
-  input: z.tuple([statusIframeThreadTellInputSchema]),
-  mode: z.literal("auto"),
-});
-export type StatusIframeThreadTellRequest = z.infer<
-  typeof statusIframeThreadTellRequestSchema
->;
-
-export interface BbThreadTell {
-  (text: string): Promise<void>;
-}
-
-export interface BbStatusIframeWindow extends Window {
-  bbStatusState: BbStatusState;
-  bbThreadTell: BbThreadTell;
-}
-
-declare global {
-  interface Window {
-    bbThreadTell?: BbThreadTell;
-  }
-}
-
 export const sendQueuedMessageModeSchema = z.enum(["auto", "steer"]);
 export type SendQueuedMessageMode = z.infer<typeof sendQueuedMessageModeSchema>;
 
@@ -1044,117 +1011,6 @@ export type ThreadHostFileContentQuery = z.infer<
   typeof threadHostFileContentQuerySchema
 >;
 
-export const threadStatusVersionSourceSchema = z.enum([
-  "folder",
-  "html",
-  "md",
-  "empty",
-]);
-export type ThreadStatusVersionSource = z.infer<
-  typeof threadStatusVersionSourceSchema
->;
-
-export const threadStatusVersionResponseSchema = z.object({
-  source: threadStatusVersionSourceSchema,
-  hash: z.string().min(1),
-});
-export type ThreadStatusVersionResponse = z.infer<
-  typeof threadStatusVersionResponseSchema
->;
-
-export const statusStateChangeEventSourceSchema = z.enum(["local", "remote"]);
-export type StatusStateChangeEventSource = z.infer<
-  typeof statusStateChangeEventSourceSchema
->;
-
-export const statusStateChangeOperationSchema = z.enum([
-  "set",
-  "delete",
-  "hydrate",
-  "resync",
-  "revert",
-]);
-export type StatusStateChangeOperation = z.infer<
-  typeof statusStateChangeOperationSchema
->;
-
-export const statusStateChangeEventSchema = z.object({
-  source: statusStateChangeEventSourceSchema,
-  operation: statusStateChangeOperationSchema,
-  optimistic: z.boolean(),
-  version: z.string().nullable(),
-  error: z.string().nullable(),
-});
-export type StatusStateChangeEvent = z.infer<
-  typeof statusStateChangeEventSchema
->;
-
-export type StatusStateSelector = StatusDataKey | "*";
-
-export type StatusStateChangeCallback = (
-  newValue: JsonValue | undefined,
-  prevValue: JsonValue | undefined,
-  key: StatusDataKey,
-  event: StatusStateChangeEvent,
-) => void;
-
-export interface BbStatusState {
-  list(): Promise<Record<StatusDataKey, JsonValue>>;
-  get(key: StatusDataKey): Promise<JsonValue | undefined>;
-  set(key: StatusDataKey, value: JsonValue): Promise<void>;
-  delete(key: StatusDataKey): Promise<void>;
-  on(
-    selector: StatusStateSelector,
-    callback: StatusStateChangeCallback,
-  ): () => void;
-}
-
-export const threadStatusDataValueRecordSchema = z.record(
-  statusDataKeySchema,
-  jsonValueSchema,
-);
-
-export const threadStatusDataVersionRecordSchema = z.record(
-  statusDataKeySchema,
-  z.string().min(1),
-);
-
-export const threadStatusDataListResponseSchema = z.object({
-  values: threadStatusDataValueRecordSchema,
-  versions: threadStatusDataVersionRecordSchema,
-  hash: z.string().min(1),
-});
-export type ThreadStatusDataListResponse = z.infer<
-  typeof threadStatusDataListResponseSchema
->;
-
-export const threadStatusDataGetResponseSchema = z.object({
-  key: statusDataKeySchema,
-  value: jsonValueSchema,
-  version: z.string().min(1),
-  sizeBytes: z.number().int().nonnegative(),
-  modifiedAtMs: z.number().nonnegative(),
-});
-export type ThreadStatusDataGetResponse = z.infer<
-  typeof threadStatusDataGetResponseSchema
->;
-
-export const statusStateBroadcastMessageSchema = z.object({
-  type: z.literal("status-data.changed"),
-  threadId: z.string().min(1),
-  key: statusDataKeySchema,
-  value: jsonValueSchema.nullable(),
-  deleted: z.boolean(),
-  previousValue: jsonValueSchema.nullable(),
-  previousValuePresent: z.boolean(),
-  version: z.string().min(1).nullable(),
-  writerClientId: z.string().nullable(),
-  operationId: z.string().nullable(),
-});
-export type StatusStateBroadcastMessage = z.infer<
-  typeof statusStateBroadcastMessageSchema
->;
-
 // Keep app path limits in sync with packages/domain/src/apps.ts and the
 // injected app client validator in app-client-script.ts.
 const appEntryPathSegmentPattern = /^[A-Za-z0-9._-]{1,120}$/u;
@@ -1435,7 +1291,10 @@ export interface BbData {
   write(path: AppDataPath, value: JsonValue): Promise<void>;
   delete(path: AppDataPath): Promise<void>;
   list(prefix?: AppDataPath | ""): Promise<BbDataEntry[]>;
-  onChange(prefix: AppDataPath | "", callback: BbDataChangeCallback): () => void;
+  onChange(
+    prefix: AppDataPath | "",
+    callback: BbDataChangeCallback,
+  ): () => void;
 }
 
 export interface Bb {
@@ -1444,6 +1303,12 @@ export interface Bb {
   message?(text: string): Promise<void>;
 }
 
+declare global {
+  interface Window {
+    bb?: Bb;
+  }
+}
+
 export const systemExecutionOptionsQuerySchema = z
   .object({
     providerId: z.string().min(1),
diff --git a/packages/server-contract/src/index.ts b/packages/server-contract/src/index.ts
index 5be4235e1..893ccc7a5 100644
--- a/packages/server-contract/src/index.ts
+++ b/packages/server-contract/src/index.ts
@@ -188,12 +188,6 @@ export {
   threadStorageFilesQuerySchema,
   threadStoragePathListResponseSchema,
   threadStoragePathsQuerySchema,
-  threadStatusVersionResponseSchema,
-  threadStatusVersionSourceSchema,
-  statusStateBroadcastMessageSchema,
-  statusStateChangeEventSchema,
-  statusStateChangeEventSourceSchema,
-  statusStateChangeOperationSchema,
   appCapabilitySchema,
   appContributionSchema,
   appDataBroadcastMessageSchema,
@@ -216,10 +210,6 @@ export {
   appSummarySchema,
   appTemplateSchema,
   createThreadAppRequestSchema,
-  threadStatusDataGetResponseSchema,
-  threadStatusDataListResponseSchema,
-  threadStatusDataValueRecordSchema,
-  threadStatusDataVersionRecordSchema,
   projectAttachmentContentQuerySchema,
   projectBranchesQuerySchema,
   projectBranchesResponseSchema,
@@ -250,8 +240,6 @@ export {
   sendQueuedMessageResponseSchema,
   sendMessageModeSchema,
   sendMessageRequestSchema,
-  statusIframeThreadTellInputSchema,
-  statusIframeThreadTellRequestSchema,
   resolvePendingInteractionRequestSchema,
   scheduledThreadAutomationActionSchema,
   squashMergeActionResponseSchema,
@@ -349,7 +337,6 @@ export type {
   CreateProjectSourceRequest,
   CreateThreadRequest,
   DeleteThreadRequest,
-  BbStatusIframeWindow,
   ThreadCreateOrigin,
   EnvironmentArgs,
   EnvironmentActionApiError,
@@ -372,8 +359,6 @@ export type {
   ThreadStorageFilesQuery,
   ThreadStoragePathListResponse,
   ThreadStoragePathsQuery,
-  ThreadStatusVersionResponse,
-  ThreadStatusVersionSource,
   AppCapability,
   AppContribution,
   AppDataBroadcastMessage,
@@ -400,16 +385,6 @@ export type {
   BbDataChangeEvent,
   BbDataEntry,
   CreateThreadAppRequest,
-  BbStatusState,
-  BbThreadTell,
-  StatusStateBroadcastMessage,
-  StatusStateChangeCallback,
-  StatusStateChangeEvent,
-  StatusStateChangeEventSource,
-  StatusStateChangeOperation,
-  StatusStateSelector,
-  ThreadStatusDataGetResponse,
-  ThreadStatusDataListResponse,
   ProjectAttachmentContentQuery,
   ProjectBranchesQuery,
   ProjectBranchesResponse,
@@ -440,8 +415,6 @@ export type {
   SendQueuedMessageResponse,
   SendMessageMode,
   SendMessageRequest,
-  StatusIframeThreadTellInput,
-  StatusIframeThreadTellRequest,
   ResolvePendingInteractionRequest,
   ScheduledThreadAutomationAction,
   SquashMergeActionResponse,
diff --git a/packages/server-contract/src/public-api.ts b/packages/server-contract/src/public-api.ts
index dcd4637cd..7fe2c2fb2 100644
--- a/packages/server-contract/src/public-api.ts
+++ b/packages/server-contract/src/public-api.ts
@@ -57,9 +57,6 @@ import type {
   ThreadStorageContentQuery,
   ThreadHostFileContentQuery,
   ThreadStorageFilesQuery,
-  ThreadStatusVersionResponse,
-  ThreadStatusDataGetResponse,
-  ThreadStatusDataListResponse,
   ProjectAttachmentContentQuery,
   ProjectBranchesQuery,
   ProjectBranchesResponse,
@@ -127,7 +124,6 @@ import type { ApiError } from "./errors.js";
 
 type PathProjectSourceId = { param: { id: string; sourceId: string } };
 type PathProjectManagerThreadId = { param: { id: string; threadId: string } };
-type PathThreadStatusDataKey = { param: { id: string; key: string } };
 type PathThreadApp = { param: { id: string; appId: string } };
 
 export type PublicApiSchema = {
@@ -578,18 +574,6 @@ export type PublicApiSchema = {
     /** Returns the last used options for the thread for use as defaults in the UI. */
     $get: Endpoint<PathId, ResolvedThreadExecutionOptions | null>;
   };
-  "/threads/:id/status-version": {
-    /** Get the resolved STATUS source and stat-based content hash for iframe cache busting. */
-    $get: Endpoint<PathId, ThreadStatusVersionResponse>;
-  };
-  "/threads/:id/status-data": {
-    /** List persistent reactive JSON state values for a STATUS dashboard. */
-    $get: Endpoint<PathId, ThreadStatusDataListResponse>;
-  };
-  "/threads/:id/status-data/:key": {
-    /** Read one persistent reactive JSON state value for a STATUS dashboard. */
-    $get: Endpoint<PathThreadStatusDataKey, ThreadStatusDataGetResponse>;
-  };
   "/threads/:id/apps": {
     /** List thread apps by reading validated manifests from thread storage. */
     $get: Endpoint<PathId, AppSummary[]>;
@@ -604,7 +588,10 @@ export type PublicApiSchema = {
   };
   "/threads/:id/apps/:appId/data": {
     /** List JSON value files at or below an app data prefix. */
-    $get: Endpoint<PathThreadApp & { query?: AppDataListQuery }, AppDataListResponse>;
+    $get: Endpoint<
+      PathThreadApp & { query?: AppDataListQuery },
+      AppDataListResponse
+    >;
   };
   "/threads/:id/apps/:appId/data/*": {
     /**
diff --git a/packages/server-contract/test/contract.test.ts b/packages/server-contract/test/contract.test.ts
index 693995d61..6d60d6810 100644
--- a/packages/server-contract/test/contract.test.ts
+++ b/packages/server-contract/test/contract.test.ts
@@ -551,42 +551,6 @@ describe("server-contract canonical schemas", () => {
     ).toThrow();
   });
 
-  it("rejects empty STATUS-data broadcast versions", () => {
-    const message = {
-      type: "status-data.changed",
-      threadId: "thr_123",
-      key: "tasks",
-      value: ["one"],
-      deleted: false,
-      previousValue: null,
-      previousValuePresent: false,
-      version: "next-hash",
-      writerClientId: null,
-      operationId: null,
-    };
-
-    expect(contract.statusStateBroadcastMessageSchema.parse(message)).toEqual(
-      message,
-    );
-    expect(
-      contract.statusStateBroadcastMessageSchema.safeParse({
-        ...message,
-        version: "",
-      }).success,
-    ).toBe(false);
-    expect(
-      contract.statusStateBroadcastMessageSchema.parse({
-        ...message,
-        deleted: true,
-        value: null,
-        version: null,
-      }),
-    ).toMatchObject({
-      deleted: true,
-      version: null,
-    });
-  });
-
   it("validates app manifests, icon names, entries, and data broadcasts", () => {
     const manifest = {
       manifestVersion: 1,
diff --git a/packages/templates/src/generated/templates.generated.ts b/packages/templates/src/generated/templates.generated.ts
index ae24b43e6..15b1f81bb 100644
--- a/packages/templates/src/generated/templates.generated.ts
+++ b/packages/templates/src/generated/templates.generated.ts
@@ -16,6 +16,17 @@ export const templateDefinitions = [
       "messageText": "The original message text sent by the agent."
     }
   },
+  {
+    "id": "bbGuideApp",
+    "body": "Apps\n\nApps are the supported way to build dashboards, control panels, and other\ninteractive surfaces inside thread storage. A manager's primary status surface\nis the built-in `status` app. Keep that app current instead of creating legacy\ntop-level status files.\n\nStorage layout:\n\n```text\n$BB_THREAD_STORAGE/\n  apps/\n    status/\n      manifest.json\n      assets/\n        index.html\n      data/\n        state.json\n```\n\nEach app is rooted at `apps/<id>/`. The manifest lives at\n`apps/<id>/manifest.json`, browser files live under `apps/<id>/assets/`, and\ndurable JSON state lives under `apps/<id>/data/`. The `status` app should keep\nits primary shared state in `apps/status/data/state.json`.\n\nManifest:\n\n```json\n{\n  \"manifestVersion\": 1,\n  \"id\": \"status\",\n  \"name\": \"Status\",\n  \"icon\": \"ListTodo\",\n  \"entry\": \"index.html\",\n  \"contributions\": [\"thread.app\"],\n  \"capabilities\": [\"data\", \"message\"]\n}\n```\n\n`id` uses letters, numbers, underscores, and hyphens. `entry` is relative to\n`assets/`. HTML entries load in an app iframe and receive the `window.bb`\nbridge according to `capabilities`; Markdown entries render as static documents\nand do not receive `window.bb`. `capabilities` controls which `window.bb`\nhelpers are injected for HTML entries: `data` enables `window.bb.data`, and\n`message` enables `window.bb.message`.\n\nThe icon is optional and uses a built-in icon name. Icon resolution order is:\n\n1. `manifest.icon`, when present, as a built-in icon.\n2. A custom top-level `logo.svg`, `logo.png`, `logo.jpg`, or `logo.jpeg` in the\n   app root, up to 1 MB.\n3. The built-in `GridView` fallback.\n\nCLI:\n\n```bash\nbb app list --self\nbb app new \"Review Board\" --id review-board --template blank --self\nbb app new \"Status\" --id status --template status --self\nbb app open status --self\nbb app rm review-board --self --yes\n```\n\nPass a thread id instead of `--self` to target another thread. `bb app open`\nprints the app URL. `--json` is available for scripts.\n\nAgent writes:\n\nWrite app data directly to `apps/<id>/data/<path>` using a temp file in the\nsame directory and then `mv` into place. Same-directory rename is atomic on\nmacOS and Linux, and bb broadcasts the committed app-data change.\n\n```bash\ndir=\"$BB_THREAD_STORAGE/apps/status/data\"\nmkdir -p \"$dir\"\ntmp=$(mktemp \"$dir/.state.XXXXXX\")\nprintf '%s\\n' '{\"tasks\":[],\"updatedAt\":\"2026-05-28T00:00:00Z\"}' > \"$tmp\" &&\n  mv \"$tmp\" \"$dir/state.json\"\n```\n\nData paths are relative to the app's `data/` directory. They must not start or\nend with `/`, must not contain backslashes, dot-prefixed segments, `.` or `..`,\nand may be nested up to eight path segments. Each segment may use letters,\nnumbers, dots, underscores, and hyphens.\n\nBrowser API:\n\n```ts\nwindow.bb.appId\nawait window.bb.data?.read(\"state.json\")\nawait window.bb.data?.write(\"state.json\", { tasks: [] })\nawait window.bb.data?.delete(\"state.json\")\nconst entries = await window.bb.data?.list(\"\")\nconst unsubscribe = window.bb.data?.onChange(\"\", (event) => {\n  console.log(event.path, event.value, event.deleted)\n})\nawait window.bb.message?.(\"Please review the current blockers.\")\n```\n\n`window.bb.data` reads and writes JSON values. `onChange(prefix, callback)`\nmatches a single data file when `prefix` equals that path and matches a subtree\nwhen the changed path is below `prefix + \"/\"`; `\"\"` matches all app data.\nRegistering a listener immediately replays existing matching data, and bb\nreplays again after reconnects or app-data resync hints. Later filesystem\nwrites, browser writes, and deletes are delivered after that replay.\n`window.bb.message(text)` sends a normal follow-up message to the thread that\nowns the app.\n\nMinimal status app pattern:\n\n```html\n<main>\n  <h1>Current work</h1>\n  <ul id=\"tasks\"></ul>\n</main>\n<script>\nconst list = document.querySelector(\"#tasks\");\n\nfunction render(state) {\n  const tasks = state?.tasks ?? [];\n  list.replaceChildren(\n    ...tasks.map((task) => {\n      const item = document.createElement(\"li\");\n      item.textContent = `${task.title} - ${task.state}`;\n      return item;\n    }),\n  );\n}\n\nwindow.bb.data?.read(\"state.json\").then(render);\nwindow.bb.data?.onChange(\"state.json\", (event) => render(event.value));\n</script>\n```\n\nStyling:\n\nMake app UI quiet, dense, and consistent with bb unless the user asks for a\ndifferent direction. Use Tailwind for layout utilities if helpful, and use the\nbb-style tokens below for colors, fonts, borders, radius, and shadows. Apps\nrender in iframes, so external resources such as Google Fonts, Tailwind CDN,\nremote images, and stylesheets load normally.\n\n```html\n<script src=\"https://cdn.tailwindcss.com\"></script>\n<link rel=\"preconnect\" href=\"https://fonts.googleapis.com\">\n<link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin>\n<link href=\"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap\" rel=\"stylesheet\">\n<style>\n:root {\n  color-scheme: light;\n  --background: oklch(0.9551 0 0);\n  --foreground: oklch(0.3211 0 0);\n  --card: oklch(0.9702 0 0);\n  --muted: oklch(0.8853 0 0);\n  --muted-foreground: oklch(0.5103 0 0);\n  --border: oklch(0.8576 0 0);\n  --accent: oklch(0.9 0 0);\n  --success: oklch(0.7 0.15 155);\n  --warning: oklch(0.7 0.16 50);\n  --destructive: oklch(0.5594 0.19 25.8625);\n  --radius: 0.5rem;\n  --font-sans: \"Inter\", ui-sans-serif, system-ui, sans-serif;\n  --font-mono: \"Fira Code\", ui-monospace, SFMono-Regular, monospace;\n}\n@media (prefers-color-scheme: dark) {\n  :root {\n    color-scheme: dark;\n    --background: oklch(0.2178 0 0);\n    --foreground: oklch(0.8853 0 0);\n    --card: oklch(0.2435 0 0);\n    --muted: oklch(0.31 0 0);\n    --muted-foreground: oklch(0.7058 0 0);\n    --border: oklch(0.34 0 0);\n    --accent: oklch(0.32 0 0);\n  }\n}\nbody {\n  margin: 0;\n  background: var(--background);\n  color: var(--foreground);\n  font-family: var(--font-sans);\n  font-size: 13px;\n}\n.panel {\n  border: 1px solid var(--border);\n  border-radius: var(--radius);\n  background: var(--card);\n}\n</style>\n```\n\nKeep one canonical app for each concept. For manager progress, update the\n`status` app instead of creating parallel views. Use additional apps only when\nthey are distinct tools or dashboards.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide manager-templates\n  bb guide async",
+    "fileName": "bb-guide-app.md",
+    "kind": "instruction",
+    "title": "bb Guide - Apps",
+    "summary": "Thread app storage, browser API, CLI, and styling reference.",
+    "intent": "Explain the only supported way to build manager-visible dashboards and interactive thread apps.",
+    "editingNotes": "Keep this aligned with routes/threads/apps.ts, app-client-script.ts, app CLI commands, and the default status app template.",
+    "variables": {}
+  },
   {
     "id": "bbGuideAsync",
     "body": "Async scheduled nudges\n\nUse `ASYNC.md` in thread storage when the system should wake a manager thread\nlater for reminders, recurring check-ins, or follow-up work.\n\n`ASYNC.md` is Markdown with YAML frontmatter:\n\n```yaml\n---\ntimezone: America/Los_Angeles\nschedules:\n  - name: daily-recap\n    cron: \"0 8 * * 1-5\"\n  - name: deploy-check\n    cron: \"0 */2 * * *\"\n    timezone: UTC\n---\n```\n\nEach schedule has a matching `## <name>` section in the body with instructions\nfor your future self. The top-level `timezone` defaults to UTC; each schedule\ncan override it.\n\nFor one-off reminders like \"in 10 minutes\", encode the next daily occurrence\nand note in the body to remove the schedule after it fires once.\n\nKeep schedule `name` values stable. The server syncs entries by name, so\nrenaming one creates a new schedule rather than editing it.\n\nConstraints:\n\n- No more than 20 schedules.\n- No interval shorter than 5 minutes.\n- The cron month field must stay `*`.\n\nWhen a scheduled nudge arrives, read the matching section in `ASYNC.md` and\ndecide whether there is real work to do. Only message the user when the nudge\nproduced something useful. Remove schedules that are no longer needed.",
@@ -51,7 +62,7 @@ export const templateDefinitions = [
   },
   {
     "id": "bbGuideManagerTemplates",
-    "body": "Manager templates\n\nManager templates are named bundles of starter files for manager thread\nstorage. When bb starts a new manager thread, the server resolves a template\nand copies that template's top-level regular files into the new manager's\nthread storage before the host daemon receives the initial `thread.start`\ncommand. This is how a fresh manager can boot with starter `PREFERENCES.md`,\n`STATUS.html`, `ASYNC.md`, or other storage files.\n\nDirectory layout:\n\n```text\n<bb-data-dir>/manager-templates/\n  active\n  default/\n    STATUS.html\n  sawyer-next/\n    PREFERENCES.md\n    STATUS.html\n```\n\nIn this guide, `<bb-data-dir>` is your bb data directory. Packaged installs\ndefault to `$HOME/.bb`. In source development, `pnpm dev` sets `BB_DATA_DIR`\nto the current checkout's data directory; use `$BB_DATA_DIR/manager-templates/`.\nOverride packaged installs with the `BB_DATA_DIR` env var.\n\n`active` is a plain text file. bb reads the first line, trims it, and uses it\nas the template name. Missing or empty `active` means `default`. An invalid\nname logs a warning and falls back to `default`. Template names must be one\ndirectory name: 1-128 characters, no `/` or `\\`, and not `.` or `..`.\n\nEach subdirectory is a template set. The directory name is the template name.\n\nWhat gets seeded:\n\nbb copies every top-level regular file from the selected template directory\ninto `<bb-data-dir>/thread-storage/<manager-thread-id>/`. There is no filename\nallowlist: `PREFERENCES.md`, `STATUS.html`, `STATUS.md`, and `ASYNC.md` are\nconventions, not the only files allowed. Subdirectories and symlinks are\nignored. Dotfiles are copied if they are regular files. Existing destination\nfiles are left as-is; seeding does not overwrite, delete, or refresh files.\n\nIf `default/` is missing, bb uses a bundled fallback template containing only\n`STATUS.html`. If `default/` exists but is empty, no bundled files are mixed\nin. If a selected non-default template is missing, bb logs a warning and skips\nstorage seeding.\n\nWhen it runs:\n\nSeeding happens while building the manager `thread.start` command, normally\nafter `POST /api/v1/projects/:id/managers` or `bb manager hire` creates the\nmanager and the environment is ready. It happens before the host daemon starts\nthe provider thread. The copy operation is safe to run more than once because\nexisting files are skipped; it is not a refresh mechanism for managers that\nalready have storage.\n\nSelecting a template:\n\nFor one manager, pass a template name at hire time:\n\n```bash\nbb manager hire --template sawyer-next\n```\n\n`--template` overrides the `active` pointer for that manager creation only.\n\nFor future managers by default, edit the active pointer:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nmkdir -p \"$DATA_DIR/manager-templates\"\nprintf 'sawyer-next\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nThere is no dedicated CLI command today for changing the global active\ntemplate.\n\nCreating a template:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nmkdir -p \"$DATA_DIR/manager-templates/sawyer-next\"\ncp \"$DATA_DIR/manager-templates/default/STATUS.html\" \\\n  \"$DATA_DIR/manager-templates/sawyer-next/STATUS.html\"\n$EDITOR \"$DATA_DIR/manager-templates/sawyer-next/PREFERENCES.md\"\nprintf 'sawyer-next\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nPromoting current preferences:\n\nManagers see their storage path in runtime context. To save the current\nmanager's `PREFERENCES.md` to the default template:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nTHREAD_STORAGE=\"/absolute/path/from-manager-runtime-context\"\nmkdir -p \"$DATA_DIR/manager-templates/default\"\ncp \"$THREAD_STORAGE/PREFERENCES.md\" \\\n  \"$DATA_DIR/manager-templates/default/PREFERENCES.md\"\nprintf 'default\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nCopy `STATUS.html`, `STATUS.md`, or `ASYNC.md` into the same template\ndirectory when those starter files should be shared too.\n\nLimitations and gotchas:\n\n- There is no dedicated CLI or UI for changing `active`.\n- Template file contents are not schema-validated before copying.\n- Only top-level regular files are copied; template subdirectories are ignored.\n- Existing thread storage files are never overwritten by seeding.\n- A user-authored `default/` directory fully replaces the bundled fallback,\n  even if it is empty.\n- Missing selected non-default templates skip seeding instead of falling back\n  to `default`.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide styling\n  bb guide async",
+    "body": "Manager templates\n\nManager templates are named bundles of starter files for manager thread\nstorage. When bb starts a new manager thread, the server resolves a template\nand recursively copies regular files into the new manager's thread storage\nbefore the host daemon receives the initial `thread.start` command. This is how\na fresh manager can boot with starter `PREFERENCES.md`, `ASYNC.md`, and\n`apps/status/` files.\n\nDirectory layout:\n\n```text\n<bb-data-dir>/manager-templates/\n  active\n  default/\n    apps/\n      status/\n        manifest.json\n        assets/\n          index.html\n        data/\n          state.json\n  sawyer-next/\n    PREFERENCES.md\n    apps/\n      status/\n        manifest.json\n        assets/\n          index.html\n        data/\n          state.json\n```\n\nIn this guide, `<bb-data-dir>` is your bb data directory. Packaged installs\ndefault to `$HOME/.bb`. In source development, `pnpm dev` sets `BB_DATA_DIR`\nto the current checkout's data directory; use `$BB_DATA_DIR/manager-templates/`.\nOverride packaged installs with the `BB_DATA_DIR` env var.\n\n`active` is a plain text file. bb reads the first line, trims it, and uses it\nas the template name. Missing or empty `active` means `default`. An invalid\nname logs a warning and falls back to `default`. Template names must be one\ndirectory name: 1-128 characters, no `/` or `\\`, and not `.` or `..`.\n\nEach subdirectory is a template set. The directory name is the template name.\n\nWhat gets seeded:\n\nbb recursively copies every regular file from the selected template directory\ninto `<bb-data-dir>/thread-storage/<manager-thread-id>/`. There is no filename\nallowlist: `PREFERENCES.md`, `ASYNC.md`, `apps/status/manifest.json`, and\n`apps/status/data/state.json` are conventions, not the only files allowed.\nSymlinks and other non-regular files are ignored. Existing destination files\nare left as-is; seeding does not overwrite, delete, or refresh files.\n\nIf `default/` is missing, bb uses a bundled fallback template containing only\nthe `status` app:\n\n```text\napps/status/manifest.json\napps/status/assets/index.html\napps/status/data/state.json\n```\n\nIf `default/` exists but is empty, no bundled files are mixed in. If a selected\nnon-default template is missing, bb logs a warning and skips storage seeding.\n\nWhen it runs:\n\nSeeding happens while building the manager `thread.start` command, normally\nafter `POST /api/v1/projects/:id/managers` or `bb manager hire` creates the\nmanager and the environment is ready. It happens before the host daemon starts\nthe provider thread. The copy operation is safe to run more than once because\nexisting files are skipped; it is not a refresh mechanism for managers that\nalready have storage.\n\nSelecting a template:\n\nFor one manager, pass a template name at hire time:\n\n```bash\nbb manager hire --template sawyer-next\n```\n\n`--template` overrides the `active` pointer for that manager creation only.\n\nFor future managers by default, edit the active pointer:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nmkdir -p \"$DATA_DIR/manager-templates\"\nprintf 'sawyer-next\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nThere is no dedicated CLI command today for changing the global active\ntemplate.\n\nCreating a template:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nmkdir -p \"$DATA_DIR/manager-templates/sawyer-next\"\ncp -R \"$DATA_DIR/manager-templates/default/apps\" \\\n  \"$DATA_DIR/manager-templates/sawyer-next/apps\"\n$EDITOR \"$DATA_DIR/manager-templates/sawyer-next/PREFERENCES.md\"\nprintf 'sawyer-next\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nPromoting current preferences:\n\nManagers see their storage path in runtime context. To save the current\nmanager's `PREFERENCES.md` and status app starter state to the default\ntemplate:\n\n```bash\nDATA_DIR=\"${BB_DATA_DIR:-$HOME/.bb}\"\nTHREAD_STORAGE=\"/absolute/path/from-manager-runtime-context\"\nmkdir -p \"$DATA_DIR/manager-templates/default/apps/status\"\ncp \"$THREAD_STORAGE/PREFERENCES.md\" \\\n  \"$DATA_DIR/manager-templates/default/PREFERENCES.md\"\ncp -R \"$THREAD_STORAGE/apps/status/.\" \\\n  \"$DATA_DIR/manager-templates/default/apps/status/\"\nprintf 'default\\n' > \"$DATA_DIR/manager-templates/active\"\n```\n\nCopy `ASYNC.md` or additional `apps/<id>/` directories into the same template\ndirectory when those starter files should be shared too.\n\nLimitations and gotchas:\n\n- There is no dedicated CLI or UI for changing `active`.\n- Template file contents are not schema-validated before copying.\n- Symlinks and other non-regular files are ignored.\n- Existing thread storage files are never overwritten by seeding.\n- A user-authored `default/` directory fully replaces the bundled fallback,\n  even if it is empty.\n- Missing selected non-default templates skip seeding instead of falling back\n  to `default`.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide app\n  bb guide async",
     "fileName": "bb-guide-manager-templates.md",
     "kind": "instruction",
     "title": "bb Guide - Manager Templates",
@@ -73,7 +84,7 @@ export const templateDefinitions = [
   },
   {
     "id": "bbGuideOverview",
-    "body": "bb is an agent orchestration tool for managing multiple agents.\n\nCore concepts:\n\n- Project — maps to a repository. All threads belong to a project.\n- Thread — a single agent conversation. The fundamental unit of work.\n- Environment — where a thread runs. Kinds: project checkout or isolated worktree. Multiple threads can share an environment.\n- Provider — the agent backend powering a thread (e.g., codex, claude-code). Each provider supports different models.\n- Host — where environments run. Hosts are long-lived local or remote machines.\n\nThread types:\n\n- standard — does coding, research, debugging, or other tasks.\n- manager — coordinates work across other threads. Communicates with the user through the exact user-message tool exposed by the provider: `mcp__bb-bridge__message_user` in Claude Code, `message_user` in Codex and Pi.\n\nThreads can have a parent-child relationship. The parent manages the child and receives lifecycle notifications when it completes, fails, or is interrupted. Threads without a parent are managed by the user.\n\nContext variables set automatically inside a thread environment:\n\n- BB_PROJECT_ID — current project\n- BB_THREAD_ID — current thread\n- BB_ENVIRONMENT_ID — current environment\n\nRun `bb status` to see your current context (resolved project and thread IDs).\n\nAll commands support --json for machine-readable output.\n\nRun `bb guide <chapter>` for command details:\n\n  threads        Spawning, inspecting, messaging, and managing threads\n  environments   Environment operations, commits, and merges\n  managers       Hiring and managing project managers\n  manager-templates\n                 Seeding new manager storage from template bundles\n  status-state   Persistent reactive JSON state for STATUS dashboards\n  providers      Discovering providers and models\n  projects       Project CRUD and sources\n  hosts          Listing and understanding hosts\n  styling        How to style STATUS/ and STATUS.html surfaces to match the bb UI\n  async          Defining scheduled nudges with ASYNC.md",
+    "body": "bb is an agent orchestration tool for managing multiple agents.\n\nCore concepts:\n\n- Project — maps to a repository. All threads belong to a project.\n- Thread — a single agent conversation. The fundamental unit of work.\n- Environment — where a thread runs. Kinds: project checkout or isolated worktree. Multiple threads can share an environment.\n- Provider — the agent backend powering a thread (e.g., codex, claude-code). Each provider supports different models.\n- Host — where environments run. Hosts are long-lived local or remote machines.\n\nThread types:\n\n- standard — does coding, research, debugging, or other tasks.\n- manager — coordinates work across other threads. Communicates with the user through the exact user-message tool exposed by the provider: `mcp__bb-bridge__message_user` in Claude Code, `message_user` in Codex and Pi.\n\nThreads can have a parent-child relationship. The parent manages the child and receives lifecycle notifications when it completes, fails, or is interrupted. Threads without a parent are managed by the user.\n\nContext variables set automatically inside a thread environment:\n\n- BB_PROJECT_ID — current project\n- BB_THREAD_ID — current thread\n- BB_ENVIRONMENT_ID — current environment\n\nRun `bb status` to see your current context (resolved project and thread IDs).\n\nAll commands support --json for machine-readable output.\n\nRun `bb guide <chapter>` for command details:\n\n  threads        Spawning, inspecting, messaging, and managing threads\n  environments   Environment operations, commits, and merges\n  managers       Hiring and managing project managers\n  manager-templates\n                 Seeding new manager storage from template bundles\n  app            Thread apps, the status app, app data, browser APIs, and styling\n  providers      Discovering providers and models\n  projects       Project CRUD and sources\n  hosts          Listing and understanding hosts\n  styling        Alias for app\n  async          Defining scheduled nudges with ASYNC.md",
     "fileName": "bb-guide-overview.md",
     "kind": "instruction",
     "title": "bb Guide Overview",
@@ -104,28 +115,6 @@ export const templateDefinitions = [
     "editingNotes": "Keep flags accurate against the CLI implementation.",
     "variables": {}
   },
-  {
-    "id": "bbGuideStatusState",
-    "body": "STATUS state\n\n`window.bbStatusState` is injected into the root manager STATUS document served\nfrom `/api/v1/threads/<thread-id>/status/`. Use it when `STATUS/index.html` or\n`STATUS.html` needs durable JSON state for controls, forms, filters, task\nboards, or other dashboard UI that should survive iframe reloads and update\nacross open tabs.\n\nDo not use it for rendering source files or static assets. Keep ordinary HTML,\nCSS, JS, images, and fonts in `STATUS/`; use STATUS state for data the dashboard\nand manager agent both need to read or update.\n\nStorage layout:\n\n```text\n$BB_THREAD_STORAGE/\n  STATUS/\n    index.html\n  STATUS-data/\n    tasks.json\n    dashboard-prefs.json\n```\n\n`BB_THREAD_STORAGE` is the canonical path to the current thread's durable\nstorage. Each key is one flat file at `STATUS-data/<key>.json`. Keys must match\n`^[A-Za-z0-9_-]{1,80}$`; no colons, slashes, dots, spaces, or nested paths. The\nfile stores the raw JSON value, not an envelope.\n\nAgent writes:\n\nWrite via a temp file in the same directory, then `mv` it into place. Same-dir\nrename is atomic on macOS and Linux, and the server-wide watcher broadcasts the\ncommitted change on `thread:<thread-id>:status-data`.\n\n```bash\nkey=\"tasks\"\njson='[{\"id\":\"task-1\",\"title\":\"Review\",\"status\":\"todo\"}]'\ndir=\"$BB_THREAD_STORAGE/STATUS-data\"\nmkdir -p \"$dir\"\ntmp=$(mktemp \"$dir/.${key}.XXXXXX\")\nprintf '%s\\n' \"$json\" > \"$tmp\" && mv \"$tmp\" \"$dir/${key}.json\"\n```\n\nDelete with `rm`:\n\n```bash\nrm -f \"$BB_THREAD_STORAGE/STATUS-data/tasks.json\"\n```\n\nMalformed JSON or invalid key filenames are ignored and logged by the server;\nthey do not broadcast. STATUS state is last-write-wins. There is no\ncompare-and-set path for agent filesystem writes.\n\nBrowser API:\n\n```ts\ntype StatusStateSelector = StatusDataKey | \"*\";\n\ninterface BbStatusState {\n  list(): Promise<Record<StatusDataKey, JsonValue>>;\n  get(key: StatusDataKey): Promise<JsonValue | undefined>;\n  set(key: StatusDataKey, value: JsonValue): Promise<void>;\n  delete(key: StatusDataKey): Promise<void>;\n  on(selector: StatusStateSelector, callback: StatusStateChangeCallback): () => void;\n}\n\ntype StatusStateChangeCallback = (\n  newValue: JsonValue | undefined,\n  prevValue: JsonValue | undefined,\n  key: StatusDataKey,\n  event: StatusStateChangeEvent,\n) => void;\n\ninterface StatusStateChangeEvent {\n  source: \"local\" | \"remote\";\n  operation: \"set\" | \"delete\" | \"hydrate\" | \"resync\" | \"revert\";\n  optimistic: boolean;\n  version: string | null;\n  error: string | null;\n}\n```\n\nHydration and reactivity:\n\n- The global exists before dashboard scripts run.\n- `on(key, cb)` fires for an existing hydrated key as soon as the listener is\n  registered. `on(\"*\", cb)` fires once for each existing key.\n- Local `set` and `delete` calls update the in-memory state optimistically and\n  fire callbacks with `source: \"local\"` and `optimistic: true`.\n- Agent filesystem writes, browser writes, and deletes broadcast over bb's\n  realtime WebSocket on the `thread:<thread-id>:status-data` channel.\n- On WebSocket reconnect, the client lists current state again and fires\n  `operation: \"resync\"` callbacks for differences.\n- STATUS-data writes do not affect `status-version`, so they do not reload the\n  iframe document.\n\nMinimal dashboard example:\n\n```html\n<button id=\"add\">Add task</button>\n<pre id=\"out\"></pre>\n<script>\nconst out = document.querySelector(\"#out\");\n\nfunction render(value) {\n  out.textContent = JSON.stringify(value ?? [], null, 2);\n}\n\nwindow.bbStatusState.on(\"tasks\", render);\n\ndocument.querySelector(\"#add\").addEventListener(\"click\", async () => {\n  const current = (await window.bbStatusState.get(\"tasks\")) ?? [];\n  await window.bbStatusState.set(\"tasks\", [\n    ...current,\n    { id: crypto.randomUUID(), title: \"New task\", status: \"todo\" }\n  ]);\n});\n</script>\n```\n\nSending a message to the manager:\n\n`window.bbThreadTell(text)` is also injected into the same root STATUS document.\nIt sends a normal follow-up message to the manager thread that owns the iframe:\n\n```ts\nwindow.bbThreadTell(text: string): Promise<void>\n```\n\nThere is no thread id argument. The iframe runtime uses the thread context from\n`/api/v1/threads/<thread-id>/status/` and posts to:\n\n```http\nPOST /api/v1/threads/<thread-id>/send\n```\n\nThe request body is:\n\n```json\n{\n  \"input\": [{ \"type\": \"text\", \"text\": \"hello\" }],\n  \"mode\": \"auto\"\n}\n```\n\nThe promise resolves when the server accepts the send route. 4xx responses\nreject with the server error message and attach `status`, `code`, and\n`retryable` fields when present. 5xx responses reject with\n`bbThreadTell failed: server error (<status>)`.\n\nExample component pattern:\n\n```html\n<textarea id=\"manager-message\" rows=\"3\"></textarea>\n<button id=\"manager-send\" type=\"button\">Send to manager</button>\n<output id=\"manager-send-status\"></output>\n<script>\nconst textarea = document.querySelector(\"#manager-message\");\nconst status = document.querySelector(\"#manager-send-status\");\n\ndocument.querySelector(\"#manager-send\").addEventListener(\"click\", async () => {\n  status.textContent = \"\";\n  try {\n    await window.bbThreadTell(textarea.value);\n    textarea.value = \"\";\n    status.textContent = \"sent\";\n    setTimeout(() => {\n      if (status.textContent === \"sent\") status.textContent = \"\";\n    }, 2000);\n  } catch (error) {\n    status.textContent =\n      error instanceof Error ? error.message : \"Message failed\";\n  }\n});\n</script>\n```\n\nLimits:\n\nThere is no new bb-specific size cap for v1. Existing browser memory, file\ntransport, and JSON parse costs still apply. Keep STATUS-data values focused on\ndashboard state, not large artifacts.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide styling",
-    "fileName": "bb-guide-status-state.md",
-    "kind": "instruction",
-    "title": "bb Guide - STATUS State",
-    "summary": "Persistent reactive JSON state and manager messaging for STATUS dashboards.",
-    "intent": "Explain window.bbStatusState, window.bbThreadTell, direct STATUS-data storage, and atomic agent writes.",
-    "editingNotes": "Keep this aligned with STATUS-data filesystem watching, /api/v1/threads/:id/status-data reads, /api/v1/threads/:id/send, and the injected client.",
-    "variables": {}
-  },
-  {
-    "id": "bbGuideStyling",
-    "body": "Status styling\n\n`STATUS/index.html` and `STATUS.html` render in an unsandboxed iframe in the bb\nsecondary panel. External resources such as Google Fonts, Tailwind CDN, remote\nimages, and stylesheets load normally. For local assets, use the folder form:\nput `index.html` plus any local images, CSS, JS, or fonts inside `STATUS/`, then\nreference them with relative URLs like `style.css`, `app.js`, or `logo.png`.\nThe dashboard auto-refreshes when resolved STATUS content changes.\n\nUnless the user asks for a different visual direction, make the HTML status\nsurface look like bb: dense, minimal, and built from the same tokens. Use\nTailwind for layout, spacing, grids, flex rows, responsive behavior, and small\nutility styling, then use the bb CSS variables below for colors, fonts, borders,\nradius, and shadows.\n\nLoad Tailwind and bb's app fonts with:\n\n```html\n<script src=\"https://cdn.tailwindcss.com\"></script>\n<link rel=\"preconnect\" href=\"https://fonts.googleapis.com\">\n<link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin>\n<link href=\"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap\" rel=\"stylesheet\">\n```\n\nbb's app dark mode is class-based on the parent app root. The iframe does not\ninherit that `.dark` class, so an HTML status document that wants light and dark\nrendering should use `@media (prefers-color-scheme: dark)` as the closest\navailable signal for the user's OS theme.\n\nPaste this starter block into `STATUS/index.html` or `STATUS.html` so the page\nuses bb's actual design tokens:\n\n```html\n<style>\n:root {\n  color-scheme: light;\n  --background: oklch(0.9551 0 0);\n  --foreground: oklch(0.3211 0 0);\n  --card: oklch(0.9702 0 0);\n  --card-foreground: oklch(0.3211 0 0);\n  --popover: oklch(0.9702 0 0);\n  --popover-foreground: oklch(0.3211 0 0);\n  --primary: oklch(0.4891 0 0);\n  --primary-foreground: oklch(1 0 0);\n  --secondary: oklch(0.9067 0 0);\n  --secondary-foreground: oklch(0.3211 0 0);\n  --muted: oklch(0.8853 0 0);\n  --muted-foreground: oklch(0.5103 0 0);\n  --accent: oklch(0.9 0 0);\n  --accent-foreground: oklch(0.3211 0 0);\n  --state-hover: oklch(0.92 0 0);\n  --state-active: oklch(0.88 0 0);\n  --destructive: oklch(0.5594 0.19 25.8625);\n  --destructive-foreground: oklch(1 0 0);\n  --attention: oklch(0.74 0.15 80);\n  --attention-foreground: oklch(0.3211 0 0);\n  --warning: oklch(0.7 0.16 50);\n  --warning-foreground: oklch(0.3211 0 0);\n  --success: oklch(0.7 0.15 155);\n  --success-foreground: oklch(0.3211 0 0);\n  --diff-added: oklch(0.5 0.13 163);\n  --diff-removed: oklch(0.5 0.17 28);\n  --border: oklch(0.8576 0 0);\n  --input: oklch(0.9067 0 0);\n  --ring: oklch(0.4891 0 0);\n  --chart-1: oklch(0.4891 0 0);\n  --chart-2: oklch(0.4863 0.0361 196.0278);\n  --chart-3: oklch(0.6534 0 0);\n  --chart-4: oklch(0.7316 0 0);\n  --chart-5: oklch(0.8078 0 0);\n  --sidebar: oklch(0.937 0 0);\n  --sidebar-foreground: oklch(0.3211 0 0);\n  --sidebar-primary: oklch(0.4891 0 0);\n  --sidebar-primary-foreground: oklch(1 0 0);\n  --sidebar-accent: oklch(0.8078 0 0);\n  --sidebar-accent-foreground: oklch(0.3211 0 0);\n  --sidebar-border: oklch(0.8576 0 0);\n  --sidebar-ring: oklch(0.4891 0 0);\n  --font-sans: \"Inter Variable\", Inter, sans-serif;\n  --font-serif: Georgia, serif;\n  --font-mono: \"Fira Code\", monospace;\n  --radius: 0.35rem;\n  --radius-sm: calc(var(--radius) - 4px);\n  --radius-md: calc(var(--radius) - 2px);\n  --radius-lg: var(--radius);\n  --radius-xl: calc(var(--radius) + 4px);\n  --bb-sidebar-row-height: 1.75rem;\n  --bb-sidebar-row-height-coarse: 2.5rem;\n  --shadow-x: 0px;\n  --shadow-y: 2px;\n  --shadow-blur: 0px;\n  --shadow-spread: 0px;\n  --shadow-opacity: 0.15;\n  --shadow-color: hsl(0 0% 20% / 0.1);\n  --shadow-2xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);\n  --shadow-xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);\n  --shadow-sm:\n    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);\n  --shadow:\n    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);\n  --shadow-md:\n    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 2px 4px -1px hsl(0 0% 20% / 0.15);\n  --shadow-lg:\n    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 4px 6px -1px hsl(0 0% 20% / 0.15);\n  --shadow-xl:\n    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 8px 10px -1px hsl(0 0% 20% / 0.15);\n  --shadow-2xl: 0px 2px 0px 0px hsl(0 0% 20% / 0.38);\n  --tracking-normal: 0em;\n  --spacing: 0.25rem;\n  --icon-stroke-width: 1.75;\n  --text-sm: 0.8125rem;\n  --text-base: 0.9375rem;\n  --text-base--line-height: 1.375rem;\n  --ansi-0: #000000;\n  --ansi-1: #a11616;\n  --ansi-2: #13704a;\n  --ansi-3: #7f6a00;\n  --ansi-4: #1f5ca6;\n  --ansi-5: #8a2f8a;\n  --ansi-6: #0b6f88;\n  --ansi-7: #3d3d3d;\n  --ansi-8: #3a3a3a;\n  --ansi-9: #d32f2f;\n  --ansi-10: #197c52;\n  --ansi-11: #a35f00;\n  --ansi-12: #2666b0;\n  --ansi-13: #9b349b;\n  --ansi-14: #0f7798;\n  --ansi-15: #1f1f1f;\n  --ansi-bg-fg-0: #ffffff;\n  --ansi-bg-fg-1: #ffffff;\n  --ansi-bg-fg-2: #ffffff;\n  --ansi-bg-fg-3: #ffffff;\n  --ansi-bg-fg-4: #ffffff;\n  --ansi-bg-fg-5: #ffffff;\n  --ansi-bg-fg-6: #ffffff;\n  --ansi-bg-fg-7: #ffffff;\n  --ansi-bg-fg-8: #ffffff;\n  --ansi-bg-fg-9: #ffffff;\n  --ansi-bg-fg-10: #ffffff;\n  --ansi-bg-fg-11: #ffffff;\n  --ansi-bg-fg-12: #ffffff;\n  --ansi-bg-fg-13: #ffffff;\n  --ansi-bg-fg-14: #ffffff;\n  --ansi-bg-fg-15: #ffffff;\n}\n\n@media (prefers-color-scheme: dark) {\n  :root {\n    color-scheme: dark;\n    --background: oklch(0.195 0 0);\n    --foreground: oklch(0.8853 0 0);\n    --card: oklch(0.2435 0 0);\n    --card-foreground: oklch(0.8853 0 0);\n    --popover: oklch(0.2435 0 0);\n    --popover-foreground: oklch(0.8853 0 0);\n    --primary: oklch(0.7058 0 0);\n    --primary-foreground: oklch(0.2178 0 0);\n    --secondary: oklch(0.3092 0 0);\n    --secondary-foreground: oklch(0.8853 0 0);\n    --muted: oklch(0.285 0 0);\n    --muted-foreground: oklch(0.66 0 0);\n    --accent: oklch(0.285 0 0);\n    --accent-foreground: oklch(0.8853 0 0);\n    --state-hover: oklch(0.255 0 0);\n    --state-active: oklch(0.305 0 0);\n    --destructive: oklch(0.56 0.19 22.1703);\n    --destructive-foreground: oklch(1 0 0);\n    --attention: oklch(0.8 0.15 80);\n    --attention-foreground: oklch(0.2178 0 0);\n    --warning: oklch(0.75 0.16 50);\n    --warning-foreground: oklch(0.2178 0 0);\n    --success: oklch(0.74 0.15 155);\n    --success-foreground: oklch(0.2178 0 0);\n    --diff-added: oklch(0.77 0.17 163);\n    --diff-removed: oklch(0.72 0.19 22);\n    --border: oklch(0.329 0 0);\n    --input: oklch(0.3092 0 0);\n    --ring: oklch(0.7058 0 0);\n    --chart-1: oklch(0.7058 0 0);\n    --chart-2: oklch(0.6714 0.0339 206.3482);\n    --chart-3: oklch(0.5452 0 0);\n    --chart-4: oklch(0.4604 0 0);\n    --chart-5: oklch(0.3715 0 0);\n    --sidebar: oklch(0.24 0 0);\n    --sidebar-foreground: oklch(0.8853 0 0);\n    --sidebar-primary: oklch(0.7058 0 0);\n    --sidebar-primary-foreground: oklch(0.2178 0 0);\n    --sidebar-accent: oklch(0.32 0 0);\n    --sidebar-accent-foreground: oklch(0.8853 0 0);\n    --sidebar-border: oklch(0.32 0 0);\n    --sidebar-ring: oklch(0.7058 0 0);\n    --font-sans: \"Inter Variable\", Inter, sans-serif;\n    --font-serif: Georgia, serif;\n    --font-mono: \"Fira Code\", monospace;\n    --radius: 0.35rem;\n    --shadow-x: 0px;\n    --shadow-y: 2px;\n    --shadow-blur: 0px;\n    --shadow-spread: 0px;\n    --shadow-opacity: 0.15;\n    --shadow-color: hsl(0 0% 20% / 0.1);\n    --shadow-2xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);\n    --shadow-xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);\n    --shadow-sm:\n      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);\n    --shadow:\n      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);\n    --shadow-md:\n      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 2px 4px -1px hsl(0 0% 20% / 0.15);\n    --shadow-lg:\n      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 4px 6px -1px hsl(0 0% 20% / 0.15);\n    --shadow-xl:\n      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 8px 10px -1px hsl(0 0% 20% / 0.15);\n    --shadow-2xl: 0px 2px 0px 0px hsl(0 0% 20% / 0.38);\n    --ansi-0: #858585;\n    --ansi-1: #d85e5e;\n    --ansi-2: #0dbc79;\n    --ansi-3: #e5e510;\n    --ansi-4: #3c88dc;\n    --ansi-5: #c85ac8;\n    --ansi-6: #11a8cd;\n    --ansi-7: #e5e5e5;\n    --ansi-8: #9a9a9a;\n    --ansi-9: #ff6f6f;\n    --ansi-10: #23d18b;\n    --ansi-11: #f5f543;\n    --ansi-12: #5aaaf2;\n    --ansi-13: #d670d6;\n    --ansi-14: #29b8db;\n    --ansi-15: #ffffff;\n    --ansi-bg-fg-0: #000000;\n    --ansi-bg-fg-1: #000000;\n    --ansi-bg-fg-2: #000000;\n    --ansi-bg-fg-3: #000000;\n    --ansi-bg-fg-4: #000000;\n    --ansi-bg-fg-5: #000000;\n    --ansi-bg-fg-6: #000000;\n    --ansi-bg-fg-7: #000000;\n    --ansi-bg-fg-8: #000000;\n    --ansi-bg-fg-9: #000000;\n    --ansi-bg-fg-10: #000000;\n    --ansi-bg-fg-11: #000000;\n    --ansi-bg-fg-12: #000000;\n    --ansi-bg-fg-13: #000000;\n    --ansi-bg-fg-14: #000000;\n    --ansi-bg-fg-15: #000000;\n  }\n}\n\nhtml,\nbody {\n  margin: 0;\n  min-height: 100%;\n  background: var(--background);\n  color: var(--foreground);\n  font-family: var(--font-sans);\n  font-size: var(--text-base);\n  line-height: var(--text-base--line-height);\n}\n\nbody {\n  padding: 1rem;\n}\n\n.card {\n  background: var(--card);\n  color: var(--card-foreground);\n  border: 1px solid var(--border);\n  border-radius: var(--radius);\n  box-shadow: var(--shadow-sm);\n}\n</style>\n```\n\nKeep the design dense and minimal so it feels native to bb: small text,\nhairline borders, subtle shadows, and semantic color only for status pills such\nas success, attention, or destructive. Use the same shapes as the app: cards on\n`--card`, `1px` borders using `--border`, and `--radius` with `--shadow-sm`.",
-    "fileName": "bb-guide-styling.md",
-    "kind": "instruction",
-    "title": "bb Guide - Styling",
-    "summary": "Styling reference for manager status surfaces rendered inside bb.",
-    "intent": "Give agents the tokens and starter CSS needed to make STATUS/index.html or STATUS.html match the bb UI.",
-    "editingNotes": "Keep this as the canonical styling reference for HTML status surfaces. Manager prompts should point here instead of inlining tokens.",
-    "variables": {}
-  },
   {
     "id": "bbGuideThreads",
     "body": "Thread commands\n\nEvery command supports --json for machine-readable output.\n\nSpawning:\n\n  bb thread spawn --prompt \"...\" [options]\n\n    --prompt <prompt>              Initial prompt (required)\n    --title <title>                Thread title\n    --project <id>                 Project (defaults to BB_PROJECT_ID)\n    --parent-thread <id>           Parent thread (defaults to BB_THREAD_ID)\n    --provider <id>                Provider override\n    --model <model>                Model override\n    --reasoning-level <level>      Reasoning level: low, medium, high, xhigh, max (provider-dependent)\n    --environment <id-or-path>     Attach to an existing environment (UUID or workspace path)\n    --new-environment <kind>       Create a new environment (worktree)\n    --service-tier <tier>          Service tier: fast, default\n    --permission-mode <mode>       Permission mode: full, workspace-write, or readonly\n    --host <id>                    Host ID (defaults to local host)\n    --no-context-parent-thread     Do not default parent thread to BB_THREAD_ID\n\n  When --provider and --model are omitted, the project's remembered defaults apply.\n  When --parent-thread is omitted inside a thread, BB_THREAD_ID is used automatically.\n\nListing:\n\n  bb thread list                           List threads\n    --project <id>                         Filter by project (defaults to BB_PROJECT_ID)\n    --parent-thread <id>                   Filter by parent/manager\n    --archived                             Show only archived threads\n\nInspecting:\n\n  bb thread show [id]                      Show thread details (defaults to BB_THREAD_ID)\n    --self                                 Target current thread\n    --work-status                          Include git working-tree status\n    --git-diff                             Include git diff\n    --diff-target <type>                   Diff scope: uncommitted, branch_committed, all, commit\n    --diff-sha <sha>                       Commit SHA (for --diff-target commit)\n    --diff-merge-base <branch>             Override merge-base branch for diff\n    --merge-base-branches                  List available merge-base branches\n\n  bb thread log [id]                       Show thread event log\n    --self                                 Target current thread\n    --format <format>                      Output format: json, minimal, verbose\n    --limit <count>                        Limit entries\n    --after-seq <seq>                      Paginate after sequence number\n\n  bb thread output <id>                    Get the final output of a thread\n\n  bb thread wait [id]                      Wait for a thread status or event\n    --status <status>                      Wait for this status\n    --event <type>                         Wait for this event type\n    --timeout <seconds>                    Timeout\n    --poll-interval <ms>                   Polling interval in milliseconds\n\nMessaging:\n\n  bb thread tell <id> <message>            Send a follow-up message\n    --mode <mode>                          Message mode (e.g., steer)\n    --model <model>                        Model override for this turn\n    --reasoning-level <level>              Reasoning level override\n\n  bb thread stop [id]                      Stop an active thread\n    --self                                 Stop current thread\n\nOwnership:\n\n  bb thread update [id]                    Update thread metadata\n    --self                                 Target current thread\n    --title <title>                        Set title\n    --parent-thread <id>                   Assign to a parent/manager\n    --clear-parent-thread                  Remove parent assignment\n\nLifecycle:\n\n  bb thread archive [id]                   Archive a thread\n    --self                                 Archive current thread\n\n  bb thread unarchive [id]                 Unarchive a thread\n    --self                                 Unarchive current thread\n\n  bb thread delete <id>                    Delete permanently\n    --yes                                  Skip confirmation\n\nRead-only commands infer the thread from BB_THREAD_ID.\nMutating commands require an explicit ID or --self.",
@@ -168,7 +157,7 @@ export const templateDefinitions = [
   },
   {
     "id": "managerAgentInstructions",
-    "body": "You are a manager in a project inside bb, a futuristic IDE where agents collaborate to complete tasks and you (the manager) have full control over the environment. You should be helpful, friendly, and proactive.\n\nYour job is to coordinate work across child threads, keep the user informed, and keep the system moving. Delegate substantive work by default. Use the manager thread for lightweight coordination, quick scoping, routing decisions, and final review.\n\nThe user will most likely be doing coding work. You should keep them updated on the changes, but not overload them with too much information. You are a middle manager reporting updates to your supervisor (the user) and delegating work to your team (child threads).\n\n## The BB System\n\nbb is the IDE that you live in. It is a UI and runtime for agents and you will primarily interact with it through the `bb` CLI.\n\n`bb` has four core primitives:\n\n- A **host** is a machine. Hosts run environments. Use `bb host list` to see available hosts.\n- An **environment** is a workspace on a host: the project checkout or an isolated git worktree.\n- A **thread** is a single agent conversation attached to an environment. Threads are the fundamental unit of work.\n- A **project** maps to a repository. All threads and environments belong to a project.\n\nThese connect in a chain: a project has hosts, hosts have environments, and environments have threads. Multiple threads can share one environment (useful for multi-thread collaboration like code-then-review). Each thread is either **standard** (does the work) or **manager** (coordinates the work). You are a manager.\n\nThe default operating model is to spawn worker threads on the same host as you, each in its own isolated worktree. This gives file-level isolation between workers and lets you directly access their worktree paths for inspection. When the user has a preference for a different host, follow that.\n\nThreads can have a parent-child relationship. A parent thread manages the child. When a child thread completes, bb notifies the parent. Threads without a parent are managed directly by the user.\n\nAs a manager, you use the `bb` CLI to spawn worker threads, inspect their progress, and manage them directly. Run `bb guide` for the system overview and `bb guide <chapter>` for detailed command reference.\n\n## Storage\n\nYou have access to durable storage. Think of this like a shared drive where you can keep notes, files, and artifacts. Use it to collaborate with your user or to write down information you want to remember for later. Use this as the place to keep plans, todos, and other work artifacts you want to share with the user.\n\nA few **special** well known files in your storage:\n\n- **`PREFERENCES.md`** — durable user preferences and collaboration norms. Create it as you learn about the user, and keep it current.\n- **`STATUS/`, `STATUS.html`, or `STATUS.md`** — a concise, current view of your work. As a manager you juggle many tasks; keep this status surface up to date so the user can catch up at a glance. The bb UI loads one server-resolved iframe URL (`/api/v1/threads/<thread-id>/status/`) and chooses the first available source in this order: `STATUS/index.html`, then `STATUS.html`, then `STATUS.md`. Use `STATUS/index.html` when you want a rich multi-asset dashboard with local images, CSS, JS, or fonts; every local asset must live inside `STATUS/` to be served. Dot-prefixed files or directories anywhere under `STATUS/` are not served. Use `STATUS.html` for a simple single-file HTML page. Use `STATUS.md` for lightweight markdown.\n- **`ASYNC.md`** — scheduled nudges. Use this for reminders, recurring check-ins, and other work that should wake you up later. Run `bb guide async` for syntax, constraints, and examples.\n\nPreferences and starter storage files can be saved as manager templates in `{{managerDataDir}}/manager-templates/` so future managers boot with the same starting state. Run `bb guide manager-templates` for the layout and commands.\n\nUnless otherwise specified, make `STATUS/index.html` or `STATUS.html` styled like bb and use Tailwind. The UI renders HTML status surfaces in an unsandboxed iframe, so external resources such as Tailwind CDN, Google Fonts, remote images, and stylesheets load normally. For bb design tokens, fonts, light/dark variables, Tailwind setup, and a starter `<style>` snippet, run `bb guide styling`.\n\nSTATUS dashboards can read and write persistent reactive JSON state under `STATUS-data/`; run `bb guide status-state` for the direct `$BB_THREAD_STORAGE/STATUS-data/<key>.json` write pattern, browser API, and manager messaging helper.\n\nThe storage directory is yours to organize. Write down anything your future self or the user might find useful. Use `notes/`, `plans/`, `research/`, and `scratch/` as default folders when they fit. When an artifact does not belong in the repository, put it in thread storage.\n\n## How to communicate\n\n**IMPORTANT**: A user will not see a message you do not send through the `message_user` tool.\n\nAll user-facing output goes through the user-message tool. Call the exact tool id exposed in your tool list: `mcp__bb-bridge__message_user` when present, otherwise `message_user`. Plain assistant text is not visible to users — they only see their own messages and what you publish through that tool. Worker messages, orchestration notes, and internal lifecycle messages are not directly visible to the user.\n\nA typical update cadence is: a short kickoff when work starts, a completion update when it finishes, and extra updates only for blockers or meaningful scope changes. Keep updates concise, factual, and ownership-clear.\n\nWhen you need user input, approval, or help clearing a blocker, ask clearly through the same exact user-message tool.\n\n## System messages\n\nMessages prefixed with `[bb system]` are internal lifecycle signals, not user requests. The important ones:\n\n- **Thread complete / failed / interrupted** — review the thread's result or error and decide whether to update the user, retry, or delegate a follow-up.\n- **Ownership assigned** — a thread is now yours to manage. Inspect it and decide how to proceed.\n- **Ownership removed** — stop treating that thread as active managed work.\n\n### File links and deliverables\n\nWhen sharing a file or deliverable, use a Markdown link whose target is the full absolute path. Example: `[Investigation report]({{managerDataDir}}/thread-storage/thr_abc123/reports/investigation.md)`.\n\nUse absolute paths that start with `/`, not relative paths. Prefer linking the specific Markdown file you created or updated so the user can open it directly.\n\n## How to work\n\n### Delegation is the default\n\nAny substantive task — coding, file edits, debugging, investigations, multi-step analysis — goes to a managed child thread. The manager thread handles only lightweight coordination: quick reads to scope work, status checks, and deciding what to delegate next. Unless the user explicitly asks you to do otherwise. Remember the user is always the boss and can fire you or change how you work at any time.\n\nDelegation means creating a BB child thread with `bb thread spawn`. If a spawn fails, tell the user and retry. \n\nWhen you delegate, give the thread a clear prompt: objective, constraints, expected deliverable, and how to validate the result. Prefer one clear owner per task. Ask workers to report outcome, changed files or created artifacts, validation performed, and any blockers.\n\nAfter delegating, let the worker execute. Send additional worker instructions only when requirements changed, the worker asked a question, or a blocker/error must be handled. Then wait for the system to notify you when the thread completes — do not loop on `bb thread show`, `bb thread log`, or `bb thread list` to detect completion.\n\nDo not use shell sleeps, `tail` loops, repeated log reads, repeated status reads, or transcript scraping to watch worker progress. Inspect a child thread when you need to make a routing decision, review completed work, or investigate a failure.\n\nContext variables `BB_PROJECT_ID` and `BB_THREAD_ID` are set automatically in your environment, so `--project` and `--parent-thread` default to the right values when you run `bb thread spawn` from the manager thread. Fresh managed child threads also default to a managed worktree and `workspace-write` permission mode when the selected provider supports it, so you usually do not need to pass those flags explicitly.\n\nEach worker thread's changes usually live in its own worktree. Keep same-environment reuse explicit with `--environment <environment-id>` when you want an implementation thread and a review thread to share files. Review worker changes in the worker environment — do not reapply edits into the manager checkout unless the user explicitly asked for that.\n\n### Direct manager work\n\nDirect manager execution is for trivial, low-latency work where delegation overhead is clearly higher than doing the work directly, or when immediate user unblock requires a small inspection. Keep direct execution minimal and return to delegation-first behavior afterward unless the user explicitly asks you to stay in direct execution mode.\n\nUnless the user explicitly asks you to do otherwise. Remember the user is always the boss and can fire you or change how you work at any time.\n\n### Common patterns\n\n**Simple delegation**: Scope the work with a quick inspection. If you are unsure which provider or model to use, run `bb provider list` and `bb provider models <provider-id>`. Spawn a thread with `bb thread spawn --title \"...\" --prompt \"...\"`. Send the user a kickoff update. When the completion notification arrives, review with `bb thread show <id> --git-diff` and `bb thread output <id>`, then update the user.\n\n**Pipeline**: When a follow-on thread (like a reviewer) needs to see the same files, get the environment ID from `bb thread show <original-id> --json` and spawn into it with `--environment <environment-id>`. That same-environment reuse is an explicit override; fresh managed children otherwise start in a separate managed worktree. After the review thread completes, triage its findings and send specific fix instructions back to the original thread via `bb thread tell`.\n\n**Parallel work**: When the user gives you several independent tasks, spawn a thread for each. Report on each as it completes rather than waiting for all to finish.\n\n**Taking over a thread**: `bb thread update <id> --parent-thread <your-id>`. Inspect its state with `bb thread show` and `bb thread log`, understand its goal, and manage it from there.\n\n**Handing off a thread**: If a user asks to takeover a thread: `bb thread update <id> --clear-parent-thread`.\n\n**Worker errors**: Inspect with `bb thread show <id> --json` and `bb thread log <id>`. Handle transient issues autonomously — retry or clarify via `bb thread tell`. Escalate when the error needs information only the user has or is significant enough they should know about.\n\n**Interrupted or stopped workers**: Inspect the thread state before acting. If CLI output, logs, or lifecycle events indicate the user stopped it manually, treat that as intentional. Summarize the stopped state if useful, but do not resume, restart, retry, replace, or continue the work unless the user explicitly asks.\n\n**Stopping a thread**: If a worker is stuck or no longer needed, stop it with `bb thread stop <id>`.\n\n**Plan decomposition**: Identify independent work units, spawn a thread per unit. Workers run in separate worktrees so they do not conflict during execution, but merging multiple worktrees back can still produce conflicts — coordinate if needed.\n\n### Thread lifecycle\n\nKeep threads around when follow-up work is likely. Archive threads once they are no longer needed with `bb thread archive <id>`. Do not archive threads that still hold active work or environments with uncommitted changes the user may need.\n\n### Scheduled nudges\n\nUse `ASYNC.md` in your thread storage for scheduled reminders, recurring check-ins, and wakeups. Run `bb guide async` for the file syntax, constraints, and examples.\n\nWhen a scheduled nudge arrives, read the matching section in `ASYNC.md` and decide whether there is real work to do. Only message the user when the nudge produced something useful. Remove schedules that are no longer needed.\n\n### Cross-manager coordination\n\nIf you need context from another manager, use `bb thread tell <manager-id> \"...\"`. Use `bb thread list --parent-thread <manager-id>` to see what another manager is working on. This is rare.\n\n---\n\nRuntime context:\n\n- Manager thread ID: `{{managerThreadId}}`\n- Host: `{{hostId}}`\n- Project: `{{projectName}}` (`{{projectId}}`)\n- Project root: `{{projectRootPath}}`\n- BB data dir: `{{managerDataDir}}`\n- Thread storage: `{{threadStoragePath}}`\n- Local timezone: `{{localTimezone}}`",
+    "body": "You are a manager in a project inside bb, a futuristic IDE where agents collaborate to complete tasks and you (the manager) have full control over the environment. You should be helpful, friendly, and proactive.\n\nYour job is to coordinate work across child threads, keep the user informed, and keep the system moving. Delegate substantive work by default. Use the manager thread for lightweight coordination, quick scoping, routing decisions, and final review.\n\nThe user will most likely be doing coding work. You should keep them updated on the changes, but not overload them with too much information. You are a middle manager reporting updates to your supervisor (the user) and delegating work to your team (child threads).\n\n## The BB System\n\nbb is the IDE that you live in. It is a UI and runtime for agents and you will primarily interact with it through the `bb` CLI.\n\n`bb` has four core primitives:\n\n- A **host** is a machine. Hosts run environments. Use `bb host list` to see available hosts.\n- An **environment** is a workspace on a host: the project checkout or an isolated git worktree.\n- A **thread** is a single agent conversation attached to an environment. Threads are the fundamental unit of work.\n- A **project** maps to a repository. All threads and environments belong to a project.\n\nThese connect in a chain: a project has hosts, hosts have environments, and environments have threads. Multiple threads can share one environment (useful for multi-thread collaboration like code-then-review). Each thread is either **standard** (does the work) or **manager** (coordinates the work). You are a manager.\n\nThe default operating model is to spawn worker threads on the same host as you, each in its own isolated worktree. This gives file-level isolation between workers and lets you directly access their worktree paths for inspection. When the user has a preference for a different host, follow that.\n\nThreads can have a parent-child relationship. A parent thread manages the child. When a child thread completes, bb notifies the parent. Threads without a parent are managed directly by the user.\n\nAs a manager, you use the `bb` CLI to spawn worker threads, inspect their progress, and manage them directly. Run `bb guide` for the system overview and `bb guide <chapter>` for detailed command reference.\n\n## Storage\n\nYou have access to durable storage. Think of this like a shared drive where you can keep notes, files, and artifacts. Use it to collaborate with your user or to write down information you want to remember for later. Use this as the place to keep plans, todos, and other work artifacts you want to share with the user.\n\nA few **special** well known files in your storage:\n\n- **`PREFERENCES.md`** — durable user preferences and collaboration norms. Create it as you learn about the user, and keep it current.\n- **`apps/status/`** — the built-in manager status app. Keep `apps/status/data/state.json` current so the user can catch up at a glance. Use `bb guide app` for the app layout, browser API, data writes, and styling guidance.\n- **`ASYNC.md`** — scheduled nudges. Use this for reminders, recurring check-ins, and other work that should wake you up later. Run `bb guide async` for syntax, constraints, and examples.\n\nPreferences and starter storage files can be saved as manager templates in `{{managerDataDir}}/manager-templates/` so future managers boot with the same starting state. Run `bb guide manager-templates` for the layout and commands.\n\nApps can read and write persistent reactive JSON state under `apps/<id>/data/` and can send messages to the owning thread through `window.bb.message`. Managers should update app data directly with same-directory temp-file writes and atomic renames. Use `bb app` for app creation, listing, URLs, and removal.\n\nThe storage directory is yours to organize. Write down anything your future self or the user might find useful. Use `notes/`, `plans/`, `research/`, and `scratch/` as default folders when they fit. When an artifact does not belong in the repository, put it in thread storage.\n\n## How to communicate\n\n**IMPORTANT**: A user will not see a message you do not send through the `message_user` tool.\n\nAll user-facing output goes through the user-message tool. Call the exact tool id exposed in your tool list: `mcp__bb-bridge__message_user` when present, otherwise `message_user`. Plain assistant text is not visible to users — they only see their own messages and what you publish through that tool. Worker messages, orchestration notes, and internal lifecycle messages are not directly visible to the user.\n\nA typical update cadence is: a short kickoff when work starts, a completion update when it finishes, and extra updates only for blockers or meaningful scope changes. Keep updates concise, factual, and ownership-clear.\n\nWhen you need user input, approval, or help clearing a blocker, ask clearly through the same exact user-message tool.\n\n## System messages\n\nMessages prefixed with `[bb system]` are internal lifecycle signals, not user requests. The important ones:\n\n- **Thread complete / failed / interrupted** — review the thread's result or error and decide whether to update the user, retry, or delegate a follow-up.\n- **Ownership assigned** — a thread is now yours to manage. Inspect it and decide how to proceed.\n- **Ownership removed** — stop treating that thread as active managed work.\n\n### File links and deliverables\n\nWhen sharing a file or deliverable, use a Markdown link whose target is the full absolute path. Example: `[Investigation report]({{managerDataDir}}/thread-storage/thr_abc123/reports/investigation.md)`.\n\nUse absolute paths that start with `/`, not relative paths. Prefer linking the specific Markdown file you created or updated so the user can open it directly.\n\n## How to work\n\n### Delegation is the default\n\nAny substantive task — coding, file edits, debugging, investigations, multi-step analysis — goes to a managed child thread. The manager thread handles only lightweight coordination: quick reads to scope work, status checks, and deciding what to delegate next. Unless the user explicitly asks you to do otherwise. Remember the user is always the boss and can fire you or change how you work at any time.\n\nDelegation means creating a BB child thread with `bb thread spawn`. If a spawn fails, tell the user and retry. \n\nWhen you delegate, give the thread a clear prompt: objective, constraints, expected deliverable, and how to validate the result. Prefer one clear owner per task. Ask workers to report outcome, changed files or created artifacts, validation performed, and any blockers.\n\nAfter delegating, let the worker execute. Send additional worker instructions only when requirements changed, the worker asked a question, or a blocker/error must be handled. Then wait for the system to notify you when the thread completes — do not loop on `bb thread show`, `bb thread log`, or `bb thread list` to detect completion.\n\nDo not use shell sleeps, `tail` loops, repeated log reads, repeated status reads, or transcript scraping to watch worker progress. Inspect a child thread when you need to make a routing decision, review completed work, or investigate a failure.\n\nContext variables `BB_PROJECT_ID` and `BB_THREAD_ID` are set automatically in your environment, so `--project` and `--parent-thread` default to the right values when you run `bb thread spawn` from the manager thread. Fresh managed child threads also default to a managed worktree and `workspace-write` permission mode when the selected provider supports it, so you usually do not need to pass those flags explicitly.\n\nEach worker thread's changes usually live in its own worktree. Keep same-environment reuse explicit with `--environment <environment-id>` when you want an implementation thread and a review thread to share files. Review worker changes in the worker environment — do not reapply edits into the manager checkout unless the user explicitly asked for that.\n\n### Direct manager work\n\nDirect manager execution is for trivial, low-latency work where delegation overhead is clearly higher than doing the work directly, or when immediate user unblock requires a small inspection. Keep direct execution minimal and return to delegation-first behavior afterward unless the user explicitly asks you to stay in direct execution mode.\n\nUnless the user explicitly asks you to do otherwise. Remember the user is always the boss and can fire you or change how you work at any time.\n\n### Common patterns\n\n**Simple delegation**: Scope the work with a quick inspection. If you are unsure which provider or model to use, run `bb provider list` and `bb provider models <provider-id>`. Spawn a thread with `bb thread spawn --title \"...\" --prompt \"...\"`. Send the user a kickoff update. When the completion notification arrives, review with `bb thread show <id> --git-diff` and `bb thread output <id>`, then update the user.\n\n**Pipeline**: When a follow-on thread (like a reviewer) needs to see the same files, get the environment ID from `bb thread show <original-id> --json` and spawn into it with `--environment <environment-id>`. That same-environment reuse is an explicit override; fresh managed children otherwise start in a separate managed worktree. After the review thread completes, triage its findings and send specific fix instructions back to the original thread via `bb thread tell`.\n\n**Parallel work**: When the user gives you several independent tasks, spawn a thread for each. Report on each as it completes rather than waiting for all to finish.\n\n**Taking over a thread**: `bb thread update <id> --parent-thread <your-id>`. Inspect its state with `bb thread show` and `bb thread log`, understand its goal, and manage it from there.\n\n**Handing off a thread**: If a user asks to takeover a thread: `bb thread update <id> --clear-parent-thread`.\n\n**Worker errors**: Inspect with `bb thread show <id> --json` and `bb thread log <id>`. Handle transient issues autonomously — retry or clarify via `bb thread tell`. Escalate when the error needs information only the user has or is significant enough they should know about.\n\n**Interrupted or stopped workers**: Inspect the thread state before acting. If CLI output, logs, or lifecycle events indicate the user stopped it manually, treat that as intentional. Summarize the stopped state if useful, but do not resume, restart, retry, replace, or continue the work unless the user explicitly asks.\n\n**Stopping a thread**: If a worker is stuck or no longer needed, stop it with `bb thread stop <id>`.\n\n**Plan decomposition**: Identify independent work units, spawn a thread per unit. Workers run in separate worktrees so they do not conflict during execution, but merging multiple worktrees back can still produce conflicts — coordinate if needed.\n\n### Thread lifecycle\n\nKeep threads around when follow-up work is likely. Archive threads once they are no longer needed with `bb thread archive <id>`. Do not archive threads that still hold active work or environments with uncommitted changes the user may need.\n\n### Scheduled nudges\n\nUse `ASYNC.md` in your thread storage for scheduled reminders, recurring check-ins, and wakeups. Run `bb guide async` for the file syntax, constraints, and examples.\n\nWhen a scheduled nudge arrives, read the matching section in `ASYNC.md` and decide whether there is real work to do. Only message the user when the nudge produced something useful. Remove schedules that are no longer needed.\n\n### Cross-manager coordination\n\nIf you need context from another manager, use `bb thread tell <manager-id> \"...\"`. Use `bb thread list --parent-thread <manager-id>` to see what another manager is working on. This is rare.\n\n---\n\nRuntime context:\n\n- Manager thread ID: `{{managerThreadId}}`\n- Host: `{{hostId}}`\n- Project: `{{projectName}}` (`{{projectId}}`)\n- Project root: `{{projectRootPath}}`\n- BB data dir: `{{managerDataDir}}`\n- Thread storage: `{{threadStoragePath}}`\n- Local timezone: `{{localTimezone}}`",
     "fileName": "manager-agent-instructions.md",
     "kind": "instruction",
     "title": "Manager Agent Instructions",
@@ -300,7 +289,7 @@ export const templateDefinitions = [
   },
   {
     "id": "systemMessageManagerWelcome",
-    "body": "[bb system]\n\nWelcome. You just came online inside bb. You are a manager helping your user get things done.\n\nFirst, inspect `PREFERENCES.md` in your thread storage.\n\nIf it contains real saved preferences, treat them as the user's starting\npreferences. Briefly confirm you have them, ask only for useful refinements, and skip the full meet-and-greet.\n\nIf `PREFERENCES.md` does not exist or still contains starter/no-preferences\ncontent, do the first-boot conversation. Do not interrogate. Do not sound like a\nform. Just talk.\n\nUse the exact user-message tool available to you:\n`mcp__bb-bridge__message_user` when present, otherwise `message_user`. You need\nto call this tool to send messages to the user.\n\nYour first user-facing message must anchor two things up front: **scope** (what\nyou should be working on) and **landing mode** (how worker output reaches the\ncodebase). Ask both — either in the same message, or in a tight follow-up you\nexplicitly promise.\n\nFor scope, surface these three common shapes (verbatim or paraphrased) and make\nclear the user can name something else entirely:\n\n- Manage an individual feature or workstream.\n- Manage all coding agents across this repo.\n- Manage a specific process (code review, async triage, releases, ...).\n\nFor landing mode, ask whether the user wants a PR opened per worker or worker\nbranches merged directly into a local branch. Note that the choice is editable\nlater. Record the answer in `PREFERENCES.md` under the existing\n**Landing changes** bullet — it already documents the two modes\n(`Open PRs` and `No PRs — local merge, push on request`).\n\nStart with something in this spirit:\n\n> Hey. I just came online as your bb manager. Two questions to start.\n>\n> What's the scope? Common shapes:\n> - a feature or workstream you want me to drive\n> - all the coding-agent work across this repo\n> - a specific process (review, triage, releases)\n>\n> Or something else — tell me what fits.\n>\n> And when workers finish: open a PR per worker, or merge into a local branch? Easy to change later.\n\nAfter scope and landing mode are settled, figure out together:\n\n1. What the user wants to be called.\n2. How they want you to refer to yourself, if they care.\n3. The working vibe: terse, warm, formal, weird, direct, playful, or something else.\n4. Update cadence, boundaries, and anything they do not want you to do.\n5. Any stable workflow preferences worth remembering.\n\nCreate, replace, or update `PREFERENCES.md` with what you learn. If the user gives you a\nname, vibe, or other identity details for yourself, record those too.\n\n`STATUS/`, `STATUS.html`, `STATUS.md`, and `ASYNC.md` may also already exist from user\ntemplates. Preserve any seeded structure and keep the files current as you work.\n\nDepending on user preferences you might want to update the status surface to match their landing mode.\n\nIf there is no `PREFERENCES.md` fill out this template with what you learn and save it:\n\n```\n# User Preferences\n\nThis file is the manager's durable memory of how the user wants to be worked with. Edit it as you learn — keep it current.\n\n## Identity\n\n- Preferred name: _(fill this out)_\n\n## Workflow\n\n- Base branch: main (default) or something else? _(fill this out)_\n- **Delegator workflow**: never do substantive work in the manager thread. Always spawn a child thread for coding, edits, investigations, or multi-step analysis.\n- **Fresh base branch before every spawn**: before every `bb thread spawn`, ensure the local base branch (default `main`) is current with origin so workers start from the latest base.\n\n## Delivery\n- Ask the user to choose how they want worker output to be delivered:\n  - Open PRs (default)\n  **or**\n  - No PRs — Ask the user for confirmation before pushing/merging worker branches into a local branch.\n  **or**\n  - Merge into a local branch (like a staging area) automatically without PRs, and push to origin on user go-ahead.\n\n## Keeping the user updated\n  Adjust the status surface (`STATUS/index.html`, `STATUS.html`, or `STATUS.md`) to match the chosen mode (see next bullet).\n- **Status mode**: if the user opens PRs, the status surface tracks open PRs in its primary section. If the user does NOT use PRs, replace the `Open PRs` section with two sections instead: **In progress** (branches actively being worked on by workers) and **Ready for review** (branches that are validated and waiting for the user's go-ahead to push or merge). If you use an HTML template with snippet patterns, copy/paste as needed.\n- **Status refresh**: keep the status surface current with the state of the world\n  - after any state-affecting action (worker spawn, branch ready, PR opened, merge, close, push).\n  - **after every child thread completion notification** (on any `[bb system] Thread complete/failed/interrupted`), even if the thread didn't obviously touch the tracked state — reconcile the relevant section.\n- **Status styling**: run `bb guide styling` for the bb design tokens, fonts, and a starter `<style>` snippet so an iframe-rendered HTML status surface matches the rest of the app. Use `STATUS/` when local assets need to be served.\n- **Status state**: dashboards may include forms, buttons, and shared JSON state. Use `bb guide status-state` when the status surface should persist interactive state that you can also inspect or update as the manager.\n- Also keep running tasks and any user action items in the status surface\n\n## Open questions to resolve when natural\n\n- Preferred name / how to address the user\n- Worker defaults (provider / reasoning level / permission mode / preferred model) — ask the user when it comes up; do not assume a default.\n- Anything else the user wants surfaced in the status surface (extra sections, custom info, integrations) — ask once when natural and update the template accordingly.\n- Update verbosity preference (terse vs detailed)\n- Any specific area of the codebase that's currently the focus\n```\n\nWhen finished you can ask whether the user wants to save these preferences as manager template defaults for future managers. If they say yes, run `bb guide manager-templates` for the current layout and commands.",
+    "body": "[bb system]\n\nWelcome. You just came online inside bb. You are a manager helping your user get things done.\n\nFirst, inspect `PREFERENCES.md` in your thread storage.\n\nIf it contains real saved preferences, treat them as the user's starting\npreferences. Briefly confirm you have them, ask only for useful refinements, and skip the full meet-and-greet.\n\nIf `PREFERENCES.md` does not exist or still contains starter/no-preferences\ncontent, do the first-boot conversation. Do not interrogate. Do not sound like a\nform. Just talk.\n\nUse the exact user-message tool available to you:\n`mcp__bb-bridge__message_user` when present, otherwise `message_user`. You need\nto call this tool to send messages to the user.\n\nYour first user-facing message must anchor two things up front: **scope** (what\nyou should be working on) and **landing mode** (how worker output reaches the\ncodebase). Ask both — either in the same message, or in a tight follow-up you\nexplicitly promise.\n\nFor scope, surface these three common shapes (verbatim or paraphrased) and make\nclear the user can name something else entirely:\n\n- Manage an individual feature or workstream.\n- Manage all coding agents across this repo.\n- Manage a specific process (code review, async triage, releases, ...).\n\nFor landing mode, ask whether the user wants a PR opened per worker or worker\nbranches merged directly into a local branch. Note that the choice is editable\nlater. Record the answer in `PREFERENCES.md` under the existing\n**Landing changes** bullet — it already documents the two modes\n(`Open PRs` and `No PRs — local merge, push on request`).\n\nStart with something in this spirit:\n\n> Hey. I just came online as your bb manager. Two questions to start.\n>\n> What's the scope? Common shapes:\n> - a feature or workstream you want me to drive\n> - all the coding-agent work across this repo\n> - a specific process (review, triage, releases)\n>\n> Or something else — tell me what fits.\n>\n> And when workers finish: open a PR per worker, or merge into a local branch? Easy to change later.\n\nAfter scope and landing mode are settled, figure out together:\n\n1. What the user wants to be called.\n2. How they want you to refer to yourself, if they care.\n3. The working vibe: terse, warm, formal, weird, direct, playful, or something else.\n4. Update cadence, boundaries, and anything they do not want you to do.\n5. Any stable workflow preferences worth remembering.\n\nCreate, replace, or update `PREFERENCES.md` with what you learn. If the user gives you a\nname, vibe, or other identity details for yourself, record those too.\n\n`apps/status/`, `PREFERENCES.md`, and `ASYNC.md` may already exist from user\ntemplates. Preserve any seeded structure and keep the status app current as you work.\n\nDepending on user preferences you might want to update `apps/status/data/state.json`\nto match their landing mode.\n\nIf there is no `PREFERENCES.md` fill out this template with what you learn and save it:\n\n```\n# User Preferences\n\nThis file is the manager's durable memory of how the user wants to be worked with. Edit it as you learn — keep it current.\n\n## Identity\n\n- Preferred name: _(fill this out)_\n\n## Workflow\n\n- Base branch: main (default) or something else? _(fill this out)_\n- **Delegator workflow**: never do substantive work in the manager thread. Always spawn a child thread for coding, edits, investigations, or multi-step analysis.\n- **Fresh base branch before every spawn**: before every `bb thread spawn`, ensure the local base branch (default `main`) is current with origin so workers start from the latest base.\n\n## Delivery\n- Ask the user to choose how they want worker output to be delivered:\n  - Open PRs (default)\n  **or**\n  - No PRs — Ask the user for confirmation before pushing/merging worker branches into a local branch.\n  **or**\n  - Merge into a local branch (like a staging area) automatically without PRs, and push to origin on user go-ahead.\n\n## Keeping the user updated\n  Adjust the `status` app to match the chosen mode.\n- **Status mode**: if the user opens PRs, the status app tracks open PRs in its primary section. If the user does NOT use PRs, use two sections instead: **In progress** (branches actively being worked on by workers) and **Ready for review** (branches that are validated and waiting for the user's go-ahead to push or merge).\n- **Status refresh**: keep `apps/status/data/state.json` current with the state of the world\n  - after any state-affecting action (worker spawn, branch ready, PR opened, merge, close, push).\n  - **after every child thread completion notification** (on any `[bb system] Thread complete/failed/interrupted`), even if the thread didn't obviously touch the tracked state — reconcile the relevant section.\n- **Status app**: run `bb guide app` for app data, `window.bb`, styling, and `bb app` commands.\n- Also keep running tasks and any user action items in the status app.\n\n## Open questions to resolve when natural\n\n- Preferred name / how to address the user\n- Worker defaults (provider / reasoning level / permission mode / preferred model) — ask the user when it comes up; do not assume a default.\n- Anything else the user wants surfaced in the status app (extra sections, custom info, integrations) — ask once when natural and update the template accordingly.\n- Update verbosity preference (terse vs detailed)\n- Any specific area of the codebase that's currently the focus\n```\n\nWhen finished you can ask whether the user wants to save these preferences as manager template defaults for future managers. If they say yes, run `bb guide manager-templates` for the current layout and commands.",
     "fileName": "system-message-manager-welcome.md",
     "kind": "prompt",
     "title": "Manager Welcome",
@@ -397,6 +386,7 @@ export interface TemplateVariables {
     senderThreadId: string;
     messageText: string;
   };
+  bbGuideApp: Record<string, never>;
   bbGuideAsync: Record<string, never>;
   bbGuideEnvironments: Record<string, never>;
   bbGuideHosts: Record<string, never>;
@@ -405,8 +395,6 @@ export interface TemplateVariables {
   bbGuideOverview: Record<string, never>;
   bbGuideProjects: Record<string, never>;
   bbGuideProviders: Record<string, never>;
-  bbGuideStatusState: Record<string, never>;
-  bbGuideStyling: Record<string, never>;
   bbGuideThreads: Record<string, never>;
   generateCommitMessage: {
     diffDescription: string;
diff --git a/packages/templates/src/templates/bb-guide-app.md b/packages/templates/src/templates/bb-guide-app.md
new file mode 100644
index 000000000..aa4f9a42b
--- /dev/null
+++ b/packages/templates/src/templates/bb-guide-app.md
@@ -0,0 +1,208 @@
+---
+kind: instruction
+title: bb Guide - Apps
+summary: Thread app storage, browser API, CLI, and styling reference.
+intent: Explain the only supported way to build manager-visible dashboards and interactive thread apps.
+editingNotes: Keep this aligned with routes/threads/apps.ts, app-client-script.ts, app CLI commands, and the default status app template.
+---
+Apps
+
+Apps are the supported way to build dashboards, control panels, and other
+interactive surfaces inside thread storage. A manager's primary status surface
+is the built-in `status` app. Keep that app current instead of creating legacy
+top-level status files.
+
+Storage layout:
+
+```text
+$BB_THREAD_STORAGE/
+  apps/
+    status/
+      manifest.json
+      assets/
+        index.html
+      data/
+        state.json
+```
+
+Each app is rooted at `apps/<id>/`. The manifest lives at
+`apps/<id>/manifest.json`, browser files live under `apps/<id>/assets/`, and
+durable JSON state lives under `apps/<id>/data/`. The `status` app should keep
+its primary shared state in `apps/status/data/state.json`.
+
+Manifest:
+
+```json
+{
+  "manifestVersion": 1,
+  "id": "status",
+  "name": "Status",
+  "icon": "ListTodo",
+  "entry": "index.html",
+  "contributions": ["thread.app"],
+  "capabilities": ["data", "message"]
+}
+```
+
+`id` uses letters, numbers, underscores, and hyphens. `entry` is relative to
+`assets/`. HTML entries load in an app iframe and receive the `window.bb`
+bridge according to `capabilities`; Markdown entries render as static documents
+and do not receive `window.bb`. `capabilities` controls which `window.bb`
+helpers are injected for HTML entries: `data` enables `window.bb.data`, and
+`message` enables `window.bb.message`.
+
+The icon is optional and uses a built-in icon name. Icon resolution order is:
+
+1. `manifest.icon`, when present, as a built-in icon.
+2. A custom top-level `logo.svg`, `logo.png`, `logo.jpg`, or `logo.jpeg` in the
+   app root, up to 1 MB.
+3. The built-in `GridView` fallback.
+
+CLI:
+
+```bash
+bb app list --self
+bb app new "Review Board" --id review-board --template blank --self
+bb app new "Status" --id status --template status --self
+bb app open status --self
+bb app rm review-board --self --yes
+```
+
+Pass a thread id instead of `--self` to target another thread. `bb app open`
+prints the app URL. `--json` is available for scripts.
+
+Agent writes:
+
+Write app data directly to `apps/<id>/data/<path>` using a temp file in the
+same directory and then `mv` into place. Same-directory rename is atomic on
+macOS and Linux, and bb broadcasts the committed app-data change.
+
+```bash
+dir="$BB_THREAD_STORAGE/apps/status/data"
+mkdir -p "$dir"
+tmp=$(mktemp "$dir/.state.XXXXXX")
+printf '%s\n' '{"tasks":[],"updatedAt":"2026-05-28T00:00:00Z"}' > "$tmp" &&
+  mv "$tmp" "$dir/state.json"
+```
+
+Data paths are relative to the app's `data/` directory. They must not start or
+end with `/`, must not contain backslashes, dot-prefixed segments, `.` or `..`,
+and may be nested up to eight path segments. Each segment may use letters,
+numbers, dots, underscores, and hyphens.
+
+Browser API:
+
+```ts
+window.bb.appId
+await window.bb.data?.read("state.json")
+await window.bb.data?.write("state.json", { tasks: [] })
+await window.bb.data?.delete("state.json")
+const entries = await window.bb.data?.list("")
+const unsubscribe = window.bb.data?.onChange("", (event) => {
+  console.log(event.path, event.value, event.deleted)
+})
+await window.bb.message?.("Please review the current blockers.")
+```
+
+`window.bb.data` reads and writes JSON values. `onChange(prefix, callback)`
+matches a single data file when `prefix` equals that path and matches a subtree
+when the changed path is below `prefix + "/"`; `""` matches all app data.
+Registering a listener immediately replays existing matching data, and bb
+replays again after reconnects or app-data resync hints. Later filesystem
+writes, browser writes, and deletes are delivered after that replay.
+`window.bb.message(text)` sends a normal follow-up message to the thread that
+owns the app.
+
+Minimal status app pattern:
+
+```html
+<main>
+  <h1>Current work</h1>
+  <ul id="tasks"></ul>
+</main>
+<script>
+const list = document.querySelector("#tasks");
+
+function render(state) {
+  const tasks = state?.tasks ?? [];
+  list.replaceChildren(
+    ...tasks.map((task) => {
+      const item = document.createElement("li");
+      item.textContent = `${task.title} - ${task.state}`;
+      return item;
+    }),
+  );
+}
+
+window.bb.data?.read("state.json").then(render);
+window.bb.data?.onChange("state.json", (event) => render(event.value));
+</script>
+```
+
+Styling:
+
+Make app UI quiet, dense, and consistent with bb unless the user asks for a
+different direction. Use Tailwind for layout utilities if helpful, and use the
+bb-style tokens below for colors, fonts, borders, radius, and shadows. Apps
+render in iframes, so external resources such as Google Fonts, Tailwind CDN,
+remote images, and stylesheets load normally.
+
+```html
+<script src="https://cdn.tailwindcss.com"></script>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
+<style>
+:root {
+  color-scheme: light;
+  --background: oklch(0.9551 0 0);
+  --foreground: oklch(0.3211 0 0);
+  --card: oklch(0.9702 0 0);
+  --muted: oklch(0.8853 0 0);
+  --muted-foreground: oklch(0.5103 0 0);
+  --border: oklch(0.8576 0 0);
+  --accent: oklch(0.9 0 0);
+  --success: oklch(0.7 0.15 155);
+  --warning: oklch(0.7 0.16 50);
+  --destructive: oklch(0.5594 0.19 25.8625);
+  --radius: 0.5rem;
+  --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
+  --font-mono: "Fira Code", ui-monospace, SFMono-Regular, monospace;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    color-scheme: dark;
+    --background: oklch(0.2178 0 0);
+    --foreground: oklch(0.8853 0 0);
+    --card: oklch(0.2435 0 0);
+    --muted: oklch(0.31 0 0);
+    --muted-foreground: oklch(0.7058 0 0);
+    --border: oklch(0.34 0 0);
+    --accent: oklch(0.32 0 0);
+  }
+}
+body {
+  margin: 0;
+  background: var(--background);
+  color: var(--foreground);
+  font-family: var(--font-sans);
+  font-size: 13px;
+}
+.panel {
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--card);
+}
+</style>
+```
+
+Keep one canonical app for each concept. For manager progress, update the
+`status` app instead of creating parallel views. Use additional apps only when
+they are distinct tools or dashboards.
+
+Related guides:
+
+  bb guide overview
+  bb guide managers
+  bb guide manager-templates
+  bb guide async
diff --git a/packages/templates/src/templates/bb-guide-manager-templates.md b/packages/templates/src/templates/bb-guide-manager-templates.md
index d520c8bd8..2c5687427 100644
--- a/packages/templates/src/templates/bb-guide-manager-templates.md
+++ b/packages/templates/src/templates/bb-guide-manager-templates.md
@@ -9,10 +9,10 @@ Manager templates
 
 Manager templates are named bundles of starter files for manager thread
 storage. When bb starts a new manager thread, the server resolves a template
-and copies that template's top-level regular files into the new manager's
-thread storage before the host daemon receives the initial `thread.start`
-command. This is how a fresh manager can boot with starter `PREFERENCES.md`,
-`STATUS.html`, `ASYNC.md`, or other storage files.
+and recursively copies regular files into the new manager's thread storage
+before the host daemon receives the initial `thread.start` command. This is how
+a fresh manager can boot with starter `PREFERENCES.md`, `ASYNC.md`, and
+`apps/status/` files.
 
 Directory layout:
 
@@ -20,10 +20,22 @@ Directory layout:
 <bb-data-dir>/manager-templates/
   active
   default/
-    STATUS.html
+    apps/
+      status/
+        manifest.json
+        assets/
+          index.html
+        data/
+          state.json
   sawyer-next/
     PREFERENCES.md
-    STATUS.html
+    apps/
+      status/
+        manifest.json
+        assets/
+          index.html
+        data/
+          state.json
 ```
 
 In this guide, `<bb-data-dir>` is your bb data directory. Packaged installs
@@ -40,17 +52,24 @@ Each subdirectory is a template set. The directory name is the template name.
 
 What gets seeded:
 
-bb copies every top-level regular file from the selected template directory
+bb recursively copies every regular file from the selected template directory
 into `<bb-data-dir>/thread-storage/<manager-thread-id>/`. There is no filename
-allowlist: `PREFERENCES.md`, `STATUS.html`, `STATUS.md`, and `ASYNC.md` are
-conventions, not the only files allowed. Subdirectories and symlinks are
-ignored. Dotfiles are copied if they are regular files. Existing destination
-files are left as-is; seeding does not overwrite, delete, or refresh files.
+allowlist: `PREFERENCES.md`, `ASYNC.md`, `apps/status/manifest.json`, and
+`apps/status/data/state.json` are conventions, not the only files allowed.
+Symlinks and other non-regular files are ignored. Existing destination files
+are left as-is; seeding does not overwrite, delete, or refresh files.
 
 If `default/` is missing, bb uses a bundled fallback template containing only
-`STATUS.html`. If `default/` exists but is empty, no bundled files are mixed
-in. If a selected non-default template is missing, bb logs a warning and skips
-storage seeding.
+the `status` app:
+
+```text
+apps/status/manifest.json
+apps/status/assets/index.html
+apps/status/data/state.json
+```
+
+If `default/` exists but is empty, no bundled files are mixed in. If a selected
+non-default template is missing, bb logs a warning and skips storage seeding.
 
 When it runs:
 
@@ -87,8 +106,8 @@ Creating a template:
 ```bash
 DATA_DIR="${BB_DATA_DIR:-$HOME/.bb}"
 mkdir -p "$DATA_DIR/manager-templates/sawyer-next"
-cp "$DATA_DIR/manager-templates/default/STATUS.html" \
-  "$DATA_DIR/manager-templates/sawyer-next/STATUS.html"
+cp -R "$DATA_DIR/manager-templates/default/apps" \
+  "$DATA_DIR/manager-templates/sawyer-next/apps"
 $EDITOR "$DATA_DIR/manager-templates/sawyer-next/PREFERENCES.md"
 printf 'sawyer-next\n' > "$DATA_DIR/manager-templates/active"
 ```
@@ -96,25 +115,28 @@ printf 'sawyer-next\n' > "$DATA_DIR/manager-templates/active"
 Promoting current preferences:
 
 Managers see their storage path in runtime context. To save the current
-manager's `PREFERENCES.md` to the default template:
+manager's `PREFERENCES.md` and status app starter state to the default
+template:
 
 ```bash
 DATA_DIR="${BB_DATA_DIR:-$HOME/.bb}"
 THREAD_STORAGE="/absolute/path/from-manager-runtime-context"
-mkdir -p "$DATA_DIR/manager-templates/default"
+mkdir -p "$DATA_DIR/manager-templates/default/apps/status"
 cp "$THREAD_STORAGE/PREFERENCES.md" \
   "$DATA_DIR/manager-templates/default/PREFERENCES.md"
+cp -R "$THREAD_STORAGE/apps/status/." \
+  "$DATA_DIR/manager-templates/default/apps/status/"
 printf 'default\n' > "$DATA_DIR/manager-templates/active"
 ```
 
-Copy `STATUS.html`, `STATUS.md`, or `ASYNC.md` into the same template
+Copy `ASYNC.md` or additional `apps/<id>/` directories into the same template
 directory when those starter files should be shared too.
 
 Limitations and gotchas:
 
 - There is no dedicated CLI or UI for changing `active`.
 - Template file contents are not schema-validated before copying.
-- Only top-level regular files are copied; template subdirectories are ignored.
+- Symlinks and other non-regular files are ignored.
 - Existing thread storage files are never overwritten by seeding.
 - A user-authored `default/` directory fully replaces the bundled fallback,
   even if it is empty.
@@ -125,5 +147,5 @@ Related guides:
 
   bb guide overview
   bb guide managers
-  bb guide styling
+  bb guide app
   bb guide async
diff --git a/packages/templates/src/templates/bb-guide-overview.md b/packages/templates/src/templates/bb-guide-overview.md
index 5918576fa..4e6e9cc75 100644
--- a/packages/templates/src/templates/bb-guide-overview.md
+++ b/packages/templates/src/templates/bb-guide-overview.md
@@ -39,9 +39,9 @@ Run `bb guide <chapter>` for command details:
   managers       Hiring and managing project managers
   manager-templates
                  Seeding new manager storage from template bundles
-  status-state   Persistent reactive JSON state for STATUS dashboards
+  app            Thread apps, the status app, app data, browser APIs, and styling
   providers      Discovering providers and models
   projects       Project CRUD and sources
   hosts          Listing and understanding hosts
-  styling        How to style STATUS/ and STATUS.html surfaces to match the bb UI
+  styling        Alias for app
   async          Defining scheduled nudges with ASYNC.md
diff --git a/packages/templates/src/templates/bb-guide-status-state.md b/packages/templates/src/templates/bb-guide-status-state.md
deleted file mode 100644
index 90d45f6a8..000000000
--- a/packages/templates/src/templates/bb-guide-status-state.md
+++ /dev/null
@@ -1,195 +0,0 @@
----
-kind: instruction
-title: bb Guide - STATUS State
-summary: Persistent reactive JSON state and manager messaging for STATUS dashboards.
-intent: Explain window.bbStatusState, window.bbThreadTell, direct STATUS-data storage, and atomic agent writes.
-editingNotes: Keep this aligned with STATUS-data filesystem watching, /api/v1/threads/:id/status-data reads, /api/v1/threads/:id/send, and the injected client.
----
-STATUS state
-
-`window.bbStatusState` is injected into the root manager STATUS document served
-from `/api/v1/threads/<thread-id>/status/`. Use it when `STATUS/index.html` or
-`STATUS.html` needs durable JSON state for controls, forms, filters, task
-boards, or other dashboard UI that should survive iframe reloads and update
-across open tabs.
-
-Do not use it for rendering source files or static assets. Keep ordinary HTML,
-CSS, JS, images, and fonts in `STATUS/`; use STATUS state for data the dashboard
-and manager agent both need to read or update.
-
-Storage layout:
-
-```text
-$BB_THREAD_STORAGE/
-  STATUS/
-    index.html
-  STATUS-data/
-    tasks.json
-    dashboard-prefs.json
-```
-
-`BB_THREAD_STORAGE` is the canonical path to the current thread's durable
-storage. Each key is one flat file at `STATUS-data/<key>.json`. Keys must match
-`^[A-Za-z0-9_-]{1,80}$`; no colons, slashes, dots, spaces, or nested paths. The
-file stores the raw JSON value, not an envelope.
-
-Agent writes:
-
-Write via a temp file in the same directory, then `mv` it into place. Same-dir
-rename is atomic on macOS and Linux, and the server-wide watcher broadcasts the
-committed change on `thread:<thread-id>:status-data`.
-
-```bash
-key="tasks"
-json='[{"id":"task-1","title":"Review","status":"todo"}]'
-dir="$BB_THREAD_STORAGE/STATUS-data"
-mkdir -p "$dir"
-tmp=$(mktemp "$dir/.${key}.XXXXXX")
-printf '%s\n' "$json" > "$tmp" && mv "$tmp" "$dir/${key}.json"
-```
-
-Delete with `rm`:
-
-```bash
-rm -f "$BB_THREAD_STORAGE/STATUS-data/tasks.json"
-```
-
-Malformed JSON or invalid key filenames are ignored and logged by the server;
-they do not broadcast. STATUS state is last-write-wins. There is no
-compare-and-set path for agent filesystem writes.
-
-Browser API:
-
-```ts
-type StatusStateSelector = StatusDataKey | "*";
-
-interface BbStatusState {
-  list(): Promise<Record<StatusDataKey, JsonValue>>;
-  get(key: StatusDataKey): Promise<JsonValue | undefined>;
-  set(key: StatusDataKey, value: JsonValue): Promise<void>;
-  delete(key: StatusDataKey): Promise<void>;
-  on(selector: StatusStateSelector, callback: StatusStateChangeCallback): () => void;
-}
-
-type StatusStateChangeCallback = (
-  newValue: JsonValue | undefined,
-  prevValue: JsonValue | undefined,
-  key: StatusDataKey,
-  event: StatusStateChangeEvent,
-) => void;
-
-interface StatusStateChangeEvent {
-  source: "local" | "remote";
-  operation: "set" | "delete" | "hydrate" | "resync" | "revert";
-  optimistic: boolean;
-  version: string | null;
-  error: string | null;
-}
-```
-
-Hydration and reactivity:
-
-- The global exists before dashboard scripts run.
-- `on(key, cb)` fires for an existing hydrated key as soon as the listener is
-  registered. `on("*", cb)` fires once for each existing key.
-- Local `set` and `delete` calls update the in-memory state optimistically and
-  fire callbacks with `source: "local"` and `optimistic: true`.
-- Agent filesystem writes, browser writes, and deletes broadcast over bb's
-  realtime WebSocket on the `thread:<thread-id>:status-data` channel.
-- On WebSocket reconnect, the client lists current state again and fires
-  `operation: "resync"` callbacks for differences.
-- STATUS-data writes do not affect `status-version`, so they do not reload the
-  iframe document.
-
-Minimal dashboard example:
-
-```html
-<button id="add">Add task</button>
-<pre id="out"></pre>
-<script>
-const out = document.querySelector("#out");
-
-function render(value) {
-  out.textContent = JSON.stringify(value ?? [], null, 2);
-}
-
-window.bbStatusState.on("tasks", render);
-
-document.querySelector("#add").addEventListener("click", async () => {
-  const current = (await window.bbStatusState.get("tasks")) ?? [];
-  await window.bbStatusState.set("tasks", [
-    ...current,
-    { id: crypto.randomUUID(), title: "New task", status: "todo" }
-  ]);
-});
-</script>
-```
-
-Sending a message to the manager:
-
-`window.bbThreadTell(text)` is also injected into the same root STATUS document.
-It sends a normal follow-up message to the manager thread that owns the iframe:
-
-```ts
-window.bbThreadTell(text: string): Promise<void>
-```
-
-There is no thread id argument. The iframe runtime uses the thread context from
-`/api/v1/threads/<thread-id>/status/` and posts to:
-
-```http
-POST /api/v1/threads/<thread-id>/send
-```
-
-The request body is:
-
-```json
-{
-  "input": [{ "type": "text", "text": "hello" }],
-  "mode": "auto"
-}
-```
-
-The promise resolves when the server accepts the send route. 4xx responses
-reject with the server error message and attach `status`, `code`, and
-`retryable` fields when present. 5xx responses reject with
-`bbThreadTell failed: server error (<status>)`.
-
-Example component pattern:
-
-```html
-<textarea id="manager-message" rows="3"></textarea>
-<button id="manager-send" type="button">Send to manager</button>
-<output id="manager-send-status"></output>
-<script>
-const textarea = document.querySelector("#manager-message");
-const status = document.querySelector("#manager-send-status");
-
-document.querySelector("#manager-send").addEventListener("click", async () => {
-  status.textContent = "";
-  try {
-    await window.bbThreadTell(textarea.value);
-    textarea.value = "";
-    status.textContent = "sent";
-    setTimeout(() => {
-      if (status.textContent === "sent") status.textContent = "";
-    }, 2000);
-  } catch (error) {
-    status.textContent =
-      error instanceof Error ? error.message : "Message failed";
-  }
-});
-</script>
-```
-
-Limits:
-
-There is no new bb-specific size cap for v1. Existing browser memory, file
-transport, and JSON parse costs still apply. Keep STATUS-data values focused on
-dashboard state, not large artifacts.
-
-Related guides:
-
-  bb guide overview
-  bb guide managers
-  bb guide styling
diff --git a/packages/templates/src/templates/bb-guide-styling.md b/packages/templates/src/templates/bb-guide-styling.md
deleted file mode 100644
index 4eca5b304..000000000
--- a/packages/templates/src/templates/bb-guide-styling.md
+++ /dev/null
@@ -1,286 +0,0 @@
----
-kind: instruction
-title: bb Guide - Styling
-summary: Styling reference for manager status surfaces rendered inside bb.
-intent: Give agents the tokens and starter CSS needed to make STATUS/index.html or STATUS.html match the bb UI.
-editingNotes: Keep this as the canonical styling reference for HTML status surfaces. Manager prompts should point here instead of inlining tokens.
----
-Status styling
-
-`STATUS/index.html` and `STATUS.html` render in an unsandboxed iframe in the bb
-secondary panel. External resources such as Google Fonts, Tailwind CDN, remote
-images, and stylesheets load normally. For local assets, use the folder form:
-put `index.html` plus any local images, CSS, JS, or fonts inside `STATUS/`, then
-reference them with relative URLs like `style.css`, `app.js`, or `logo.png`.
-The dashboard auto-refreshes when resolved STATUS content changes.
-
-Unless the user asks for a different visual direction, make the HTML status
-surface look like bb: dense, minimal, and built from the same tokens. Use
-Tailwind for layout, spacing, grids, flex rows, responsive behavior, and small
-utility styling, then use the bb CSS variables below for colors, fonts, borders,
-radius, and shadows.
-
-Load Tailwind and bb's app fonts with:
-
-```html
-<script src="https://cdn.tailwindcss.com"></script>
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
-```
-
-bb's app dark mode is class-based on the parent app root. The iframe does not
-inherit that `.dark` class, so an HTML status document that wants light and dark
-rendering should use `@media (prefers-color-scheme: dark)` as the closest
-available signal for the user's OS theme.
-
-Paste this starter block into `STATUS/index.html` or `STATUS.html` so the page
-uses bb's actual design tokens:
-
-```html
-<style>
-:root {
-  color-scheme: light;
-  --background: oklch(0.9551 0 0);
-  --foreground: oklch(0.3211 0 0);
-  --card: oklch(0.9702 0 0);
-  --card-foreground: oklch(0.3211 0 0);
-  --popover: oklch(0.9702 0 0);
-  --popover-foreground: oklch(0.3211 0 0);
-  --primary: oklch(0.4891 0 0);
-  --primary-foreground: oklch(1 0 0);
-  --secondary: oklch(0.9067 0 0);
-  --secondary-foreground: oklch(0.3211 0 0);
-  --muted: oklch(0.8853 0 0);
-  --muted-foreground: oklch(0.5103 0 0);
-  --accent: oklch(0.9 0 0);
-  --accent-foreground: oklch(0.3211 0 0);
-  --state-hover: oklch(0.92 0 0);
-  --state-active: oklch(0.88 0 0);
-  --destructive: oklch(0.5594 0.19 25.8625);
-  --destructive-foreground: oklch(1 0 0);
-  --attention: oklch(0.74 0.15 80);
-  --attention-foreground: oklch(0.3211 0 0);
-  --warning: oklch(0.7 0.16 50);
-  --warning-foreground: oklch(0.3211 0 0);
-  --success: oklch(0.7 0.15 155);
-  --success-foreground: oklch(0.3211 0 0);
-  --diff-added: oklch(0.5 0.13 163);
-  --diff-removed: oklch(0.5 0.17 28);
-  --border: oklch(0.8576 0 0);
-  --input: oklch(0.9067 0 0);
-  --ring: oklch(0.4891 0 0);
-  --chart-1: oklch(0.4891 0 0);
-  --chart-2: oklch(0.4863 0.0361 196.0278);
-  --chart-3: oklch(0.6534 0 0);
-  --chart-4: oklch(0.7316 0 0);
-  --chart-5: oklch(0.8078 0 0);
-  --sidebar: oklch(0.937 0 0);
-  --sidebar-foreground: oklch(0.3211 0 0);
-  --sidebar-primary: oklch(0.4891 0 0);
-  --sidebar-primary-foreground: oklch(1 0 0);
-  --sidebar-accent: oklch(0.8078 0 0);
-  --sidebar-accent-foreground: oklch(0.3211 0 0);
-  --sidebar-border: oklch(0.8576 0 0);
-  --sidebar-ring: oklch(0.4891 0 0);
-  --font-sans: "Inter Variable", Inter, sans-serif;
-  --font-serif: Georgia, serif;
-  --font-mono: "Fira Code", monospace;
-  --radius: 0.35rem;
-  --radius-sm: calc(var(--radius) - 4px);
-  --radius-md: calc(var(--radius) - 2px);
-  --radius-lg: var(--radius);
-  --radius-xl: calc(var(--radius) + 4px);
-  --bb-sidebar-row-height: 1.75rem;
-  --bb-sidebar-row-height-coarse: 2.5rem;
-  --shadow-x: 0px;
-  --shadow-y: 2px;
-  --shadow-blur: 0px;
-  --shadow-spread: 0px;
-  --shadow-opacity: 0.15;
-  --shadow-color: hsl(0 0% 20% / 0.1);
-  --shadow-2xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);
-  --shadow-xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);
-  --shadow-sm:
-    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);
-  --shadow:
-    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);
-  --shadow-md:
-    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 2px 4px -1px hsl(0 0% 20% / 0.15);
-  --shadow-lg:
-    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 4px 6px -1px hsl(0 0% 20% / 0.15);
-  --shadow-xl:
-    0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 8px 10px -1px hsl(0 0% 20% / 0.15);
-  --shadow-2xl: 0px 2px 0px 0px hsl(0 0% 20% / 0.38);
-  --tracking-normal: 0em;
-  --spacing: 0.25rem;
-  --icon-stroke-width: 1.75;
-  --text-sm: 0.8125rem;
-  --text-base: 0.9375rem;
-  --text-base--line-height: 1.375rem;
-  --ansi-0: #000000;
-  --ansi-1: #a11616;
-  --ansi-2: #13704a;
-  --ansi-3: #7f6a00;
-  --ansi-4: #1f5ca6;
-  --ansi-5: #8a2f8a;
-  --ansi-6: #0b6f88;
-  --ansi-7: #3d3d3d;
-  --ansi-8: #3a3a3a;
-  --ansi-9: #d32f2f;
-  --ansi-10: #197c52;
-  --ansi-11: #a35f00;
-  --ansi-12: #2666b0;
-  --ansi-13: #9b349b;
-  --ansi-14: #0f7798;
-  --ansi-15: #1f1f1f;
-  --ansi-bg-fg-0: #ffffff;
-  --ansi-bg-fg-1: #ffffff;
-  --ansi-bg-fg-2: #ffffff;
-  --ansi-bg-fg-3: #ffffff;
-  --ansi-bg-fg-4: #ffffff;
-  --ansi-bg-fg-5: #ffffff;
-  --ansi-bg-fg-6: #ffffff;
-  --ansi-bg-fg-7: #ffffff;
-  --ansi-bg-fg-8: #ffffff;
-  --ansi-bg-fg-9: #ffffff;
-  --ansi-bg-fg-10: #ffffff;
-  --ansi-bg-fg-11: #ffffff;
-  --ansi-bg-fg-12: #ffffff;
-  --ansi-bg-fg-13: #ffffff;
-  --ansi-bg-fg-14: #ffffff;
-  --ansi-bg-fg-15: #ffffff;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    color-scheme: dark;
-    --background: oklch(0.195 0 0);
-    --foreground: oklch(0.8853 0 0);
-    --card: oklch(0.2435 0 0);
-    --card-foreground: oklch(0.8853 0 0);
-    --popover: oklch(0.2435 0 0);
-    --popover-foreground: oklch(0.8853 0 0);
-    --primary: oklch(0.7058 0 0);
-    --primary-foreground: oklch(0.2178 0 0);
-    --secondary: oklch(0.3092 0 0);
-    --secondary-foreground: oklch(0.8853 0 0);
-    --muted: oklch(0.285 0 0);
-    --muted-foreground: oklch(0.66 0 0);
-    --accent: oklch(0.285 0 0);
-    --accent-foreground: oklch(0.8853 0 0);
-    --state-hover: oklch(0.255 0 0);
-    --state-active: oklch(0.305 0 0);
-    --destructive: oklch(0.56 0.19 22.1703);
-    --destructive-foreground: oklch(1 0 0);
-    --attention: oklch(0.8 0.15 80);
-    --attention-foreground: oklch(0.2178 0 0);
-    --warning: oklch(0.75 0.16 50);
-    --warning-foreground: oklch(0.2178 0 0);
-    --success: oklch(0.74 0.15 155);
-    --success-foreground: oklch(0.2178 0 0);
-    --diff-added: oklch(0.77 0.17 163);
-    --diff-removed: oklch(0.72 0.19 22);
-    --border: oklch(0.329 0 0);
-    --input: oklch(0.3092 0 0);
-    --ring: oklch(0.7058 0 0);
-    --chart-1: oklch(0.7058 0 0);
-    --chart-2: oklch(0.6714 0.0339 206.3482);
-    --chart-3: oklch(0.5452 0 0);
-    --chart-4: oklch(0.4604 0 0);
-    --chart-5: oklch(0.3715 0 0);
-    --sidebar: oklch(0.24 0 0);
-    --sidebar-foreground: oklch(0.8853 0 0);
-    --sidebar-primary: oklch(0.7058 0 0);
-    --sidebar-primary-foreground: oklch(0.2178 0 0);
-    --sidebar-accent: oklch(0.32 0 0);
-    --sidebar-accent-foreground: oklch(0.8853 0 0);
-    --sidebar-border: oklch(0.32 0 0);
-    --sidebar-ring: oklch(0.7058 0 0);
-    --font-sans: "Inter Variable", Inter, sans-serif;
-    --font-serif: Georgia, serif;
-    --font-mono: "Fira Code", monospace;
-    --radius: 0.35rem;
-    --shadow-x: 0px;
-    --shadow-y: 2px;
-    --shadow-blur: 0px;
-    --shadow-spread: 0px;
-    --shadow-opacity: 0.15;
-    --shadow-color: hsl(0 0% 20% / 0.1);
-    --shadow-2xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);
-    --shadow-xs: 0px 2px 0px 0px hsl(0 0% 20% / 0.07);
-    --shadow-sm:
-      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);
-    --shadow:
-      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 1px 2px -1px hsl(0 0% 20% / 0.15);
-    --shadow-md:
-      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 2px 4px -1px hsl(0 0% 20% / 0.15);
-    --shadow-lg:
-      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 4px 6px -1px hsl(0 0% 20% / 0.15);
-    --shadow-xl:
-      0px 2px 0px 0px hsl(0 0% 20% / 0.15), 0px 8px 10px -1px hsl(0 0% 20% / 0.15);
-    --shadow-2xl: 0px 2px 0px 0px hsl(0 0% 20% / 0.38);
-    --ansi-0: #858585;
-    --ansi-1: #d85e5e;
-    --ansi-2: #0dbc79;
-    --ansi-3: #e5e510;
-    --ansi-4: #3c88dc;
-    --ansi-5: #c85ac8;
-    --ansi-6: #11a8cd;
-    --ansi-7: #e5e5e5;
-    --ansi-8: #9a9a9a;
-    --ansi-9: #ff6f6f;
-    --ansi-10: #23d18b;
-    --ansi-11: #f5f543;
-    --ansi-12: #5aaaf2;
-    --ansi-13: #d670d6;
-    --ansi-14: #29b8db;
-    --ansi-15: #ffffff;
-    --ansi-bg-fg-0: #000000;
-    --ansi-bg-fg-1: #000000;
-    --ansi-bg-fg-2: #000000;
-    --ansi-bg-fg-3: #000000;
-    --ansi-bg-fg-4: #000000;
-    --ansi-bg-fg-5: #000000;
-    --ansi-bg-fg-6: #000000;
-    --ansi-bg-fg-7: #000000;
-    --ansi-bg-fg-8: #000000;
-    --ansi-bg-fg-9: #000000;
-    --ansi-bg-fg-10: #000000;
-    --ansi-bg-fg-11: #000000;
-    --ansi-bg-fg-12: #000000;
-    --ansi-bg-fg-13: #000000;
-    --ansi-bg-fg-14: #000000;
-    --ansi-bg-fg-15: #000000;
-  }
-}
-
-html,
-body {
-  margin: 0;
-  min-height: 100%;
-  background: var(--background);
-  color: var(--foreground);
-  font-family: var(--font-sans);
-  font-size: var(--text-base);
-  line-height: var(--text-base--line-height);
-}
-
-body {
-  padding: 1rem;
-}
-
-.card {
-  background: var(--card);
-  color: var(--card-foreground);
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  box-shadow: var(--shadow-sm);
-}
-</style>
-```
-
-Keep the design dense and minimal so it feels native to bb: small text,
-hairline borders, subtle shadows, and semantic color only for status pills such
-as success, attention, or destructive. Use the same shapes as the app: cards on
-`--card`, `1px` borders using `--border`, and `--radius` with `--shadow-sm`.
diff --git a/packages/templates/src/templates/manager-agent-instructions.md b/packages/templates/src/templates/manager-agent-instructions.md
index d6b60584f..6857ab230 100644
--- a/packages/templates/src/templates/manager-agent-instructions.md
+++ b/packages/templates/src/templates/manager-agent-instructions.md
@@ -47,14 +47,12 @@ You have access to durable storage. Think of this like a shared drive where you
 A few **special** well known files in your storage:
 
 - **`PREFERENCES.md`** — durable user preferences and collaboration norms. Create it as you learn about the user, and keep it current.
-- **`STATUS/`, `STATUS.html`, or `STATUS.md`** — a concise, current view of your work. As a manager you juggle many tasks; keep this status surface up to date so the user can catch up at a glance. The bb UI loads one server-resolved iframe URL (`/api/v1/threads/<thread-id>/status/`) and chooses the first available source in this order: `STATUS/index.html`, then `STATUS.html`, then `STATUS.md`. Use `STATUS/index.html` when you want a rich multi-asset dashboard with local images, CSS, JS, or fonts; every local asset must live inside `STATUS/` to be served. Dot-prefixed files or directories anywhere under `STATUS/` are not served. Use `STATUS.html` for a simple single-file HTML page. Use `STATUS.md` for lightweight markdown.
+- **`apps/status/`** — the built-in manager status app. Keep `apps/status/data/state.json` current so the user can catch up at a glance. Use `bb guide app` for the app layout, browser API, data writes, and styling guidance.
 - **`ASYNC.md`** — scheduled nudges. Use this for reminders, recurring check-ins, and other work that should wake you up later. Run `bb guide async` for syntax, constraints, and examples.
 
 Preferences and starter storage files can be saved as manager templates in `{{managerDataDir}}/manager-templates/` so future managers boot with the same starting state. Run `bb guide manager-templates` for the layout and commands.
 
-Unless otherwise specified, make `STATUS/index.html` or `STATUS.html` styled like bb and use Tailwind. The UI renders HTML status surfaces in an unsandboxed iframe, so external resources such as Tailwind CDN, Google Fonts, remote images, and stylesheets load normally. For bb design tokens, fonts, light/dark variables, Tailwind setup, and a starter `<style>` snippet, run `bb guide styling`.
-
-STATUS dashboards can read and write persistent reactive JSON state under `STATUS-data/`; run `bb guide status-state` for the direct `$BB_THREAD_STORAGE/STATUS-data/<key>.json` write pattern, browser API, and manager messaging helper.
+Apps can read and write persistent reactive JSON state under `apps/<id>/data/` and can send messages to the owning thread through `window.bb.message`. Managers should update app data directly with same-directory temp-file writes and atomic renames. Use `bb app` for app creation, listing, URLs, and removal.
 
 The storage directory is yours to organize. Write down anything your future self or the user might find useful. Use `notes/`, `plans/`, `research/`, and `scratch/` as default folders when they fit. When an artifact does not belong in the repository, put it in thread storage.
 
diff --git a/packages/templates/src/templates/system-message-manager-welcome.md b/packages/templates/src/templates/system-message-manager-welcome.md
index ee89a1c3a..9f9e66abe 100644
--- a/packages/templates/src/templates/system-message-manager-welcome.md
+++ b/packages/templates/src/templates/system-message-manager-welcome.md
@@ -64,10 +64,11 @@ After scope and landing mode are settled, figure out together:
 Create, replace, or update `PREFERENCES.md` with what you learn. If the user gives you a
 name, vibe, or other identity details for yourself, record those too.
 
-`STATUS/`, `STATUS.html`, `STATUS.md`, and `ASYNC.md` may also already exist from user
-templates. Preserve any seeded structure and keep the files current as you work.
+`apps/status/`, `PREFERENCES.md`, and `ASYNC.md` may already exist from user
+templates. Preserve any seeded structure and keep the status app current as you work.
 
-Depending on user preferences you might want to update the status surface to match their landing mode.
+Depending on user preferences you might want to update `apps/status/data/state.json`
+to match their landing mode.
 
 If there is no `PREFERENCES.md` fill out this template with what you learn and save it:
 
@@ -95,20 +96,19 @@ This file is the manager's durable memory of how the user wants to be worked wit
   - Merge into a local branch (like a staging area) automatically without PRs, and push to origin on user go-ahead.
 
 ## Keeping the user updated
-  Adjust the status surface (`STATUS/index.html`, `STATUS.html`, or `STATUS.md`) to match the chosen mode (see next bullet).
-- **Status mode**: if the user opens PRs, the status surface tracks open PRs in its primary section. If the user does NOT use PRs, replace the `Open PRs` section with two sections instead: **In progress** (branches actively being worked on by workers) and **Ready for review** (branches that are validated and waiting for the user's go-ahead to push or merge). If you use an HTML template with snippet patterns, copy/paste as needed.
-- **Status refresh**: keep the status surface current with the state of the world
+  Adjust the `status` app to match the chosen mode.
+- **Status mode**: if the user opens PRs, the status app tracks open PRs in its primary section. If the user does NOT use PRs, use two sections instead: **In progress** (branches actively being worked on by workers) and **Ready for review** (branches that are validated and waiting for the user's go-ahead to push or merge).
+- **Status refresh**: keep `apps/status/data/state.json` current with the state of the world
   - after any state-affecting action (worker spawn, branch ready, PR opened, merge, close, push).
   - **after every child thread completion notification** (on any `[bb system] Thread complete/failed/interrupted`), even if the thread didn't obviously touch the tracked state — reconcile the relevant section.
-- **Status styling**: run `bb guide styling` for the bb design tokens, fonts, and a starter `<style>` snippet so an iframe-rendered HTML status surface matches the rest of the app. Use `STATUS/` when local assets need to be served.
-- **Status state**: dashboards may include forms, buttons, and shared JSON state. Use `bb guide status-state` when the status surface should persist interactive state that you can also inspect or update as the manager.
-- Also keep running tasks and any user action items in the status surface
+- **Status app**: run `bb guide app` for app data, `window.bb`, styling, and `bb app` commands.
+- Also keep running tasks and any user action items in the status app.
 
 ## Open questions to resolve when natural
 
 - Preferred name / how to address the user
 - Worker defaults (provider / reasoning level / permission mode / preferred model) — ask the user when it comes up; do not assume a default.
-- Anything else the user wants surfaced in the status surface (extra sections, custom info, integrations) — ask once when natural and update the template accordingly.
+- Anything else the user wants surfaced in the status app (extra sections, custom info, integrations) — ask once when natural and update the template accordingly.
 - Update verbosity preference (terse vs detailed)
 - Any specific area of the codebase that's currently the focus
 ```
diff --git a/packages/templates/test/templates.test.ts b/packages/templates/test/templates.test.ts
index 12efc7c7a..7fcc9049d 100644
--- a/packages/templates/test/templates.test.ts
+++ b/packages/templates/test/templates.test.ts
@@ -100,14 +100,9 @@ describe("@bb/templates", () => {
     expect(rendered).toContain("mcp__bb-bridge__message_user");
     expect(rendered).toContain("bb thread spawn");
     expect(rendered).toContain("Simple delegation");
-    expect(rendered).toContain(
-      "Use `STATUS/index.html` when you want a rich multi-asset dashboard",
-    );
-    expect(rendered).toContain("The UI renders HTML status surfaces");
-    expect(rendered).toContain(
-      "Unless otherwise specified, make `STATUS/index.html` or `STATUS.html` styled like bb and use Tailwind.",
-    );
-    expect(rendered).toContain("bb guide styling");
+    expect(rendered).toContain("`apps/status/`");
+    expect(rendered).toContain("apps/status/data/state.json");
+    expect(rendered).toContain("bb guide app");
     expect(rendered).toContain("bb guide async");
     expect(rendered).toContain("bb guide manager-templates");
     expect(rendered).toContain("/tmp/bb-data/manager-templates/");
@@ -140,9 +135,7 @@ describe("@bb/templates", () => {
       fence: "```",
       preferencesContent: "- concise updates\n",
     });
-    expect(updated).toContain(
-      "PREFERENCES.md has been updated. New contents:",
-    );
+    expect(updated).toContain("PREFERENCES.md has been updated. New contents:");
     expect(updated).toContain("- concise updates");
 
     expect(
@@ -174,9 +167,7 @@ describe("@bb/templates", () => {
       "Your first user-facing message must anchor two things up front",
     );
     expect(rendered).toContain("- Manage an individual feature or workstream.");
-    expect(rendered).toContain(
-      "- Manage all coding agents across this repo.",
-    );
+    expect(rendered).toContain("- Manage all coding agents across this repo.");
     expect(rendered).toContain(
       "- Manage a specific process (code review, async triage, releases, ...).",
     );
@@ -186,21 +177,18 @@ describe("@bb/templates", () => {
     );
   });
 
-  it("renders bbGuideStyling", () => {
+  it("renders bbGuideApp", () => {
     const templates = listTemplates();
-    expect(templates.some((template) => template.id === "bbGuideStyling")).toBe(
+    expect(templates.some((template) => template.id === "bbGuideApp")).toBe(
       true,
     );
 
-    const rendered = renderTemplate("bbGuideStyling", {});
+    const rendered = renderTemplate("bbGuideApp", {});
 
-    expect(rendered).toContain("Status styling");
-    expect(rendered).toContain(
-      "For local assets, use the folder form",
-    );
-    expect(rendered).toContain(
-      "Unless the user asks for a different visual direction, make the HTML status",
-    );
+    expect(rendered).toContain("Apps");
+    expect(rendered).toContain("apps/status/data/state.json");
+    expect(rendered).toContain("window.bb.data");
+    expect(rendered).toContain("bb app list --self");
     expect(rendered).toContain(
       '<script src="https://cdn.tailwindcss.com"></script>',
     );
@@ -211,8 +199,7 @@ describe("@bb/templates", () => {
     expect(rendered).toContain(
       "@media (prefers-color-scheme: dark) {\n  :root {",
     );
-    expect(rendered).toContain("--background: oklch(0.195 0 0);");
-    expect(rendered).toContain("--text-base: 0.9375rem;");
+    expect(rendered).toContain("--background: oklch(0.2178 0 0);");
   });
 
   it("renders bbGuideAsync", () => {
@@ -247,7 +234,7 @@ describe("@bb/templates", () => {
     expect(rendered).not.toContain("$HOME/.bb-dev");
     expect(rendered).toContain("bb manager hire --template sawyer-next");
     expect(rendered).toContain("There is no filename\nallowlist");
-    expect(rendered).toContain("Only top-level regular files are copied");
+    expect(rendered).toContain("recursively copies every regular file");
   });
 
   it("renders standardAgentInstructions without user-question guidance", () => {
diff --git a/tests/integration/fake/smoke/status-data-watch.test.ts b/tests/integration/fake/smoke/status-data-watch.test.ts
deleted file mode 100644
index 8754748ba..000000000
--- a/tests/integration/fake/smoke/status-data-watch.test.ts
+++ /dev/null
@@ -1,354 +0,0 @@
-import fs from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { createFakeAdapter } from "@bb/agent-runtime/test";
-import {
-  statusStateBroadcastMessageSchema,
-  type StatusStateBroadcastMessage,
-} from "@bb/server-contract";
-import { describe, expect, it } from "vitest";
-import { WebSocket, type RawData } from "ws";
-import { createHostThread, sendTextMessage } from "../../helpers/api.js";
-import { waitForThreadStatus } from "../../helpers/assertions.js";
-import { withHarness } from "../../helpers/harness.js";
-import { removePathWithRetry } from "../../helpers/remove-path.js";
-import {
-  createProjectFixture,
-  DEFAULT_TIMEOUT_MS,
-  TURN_TIMEOUT_MS,
-} from "./shared.js";
-
-interface DelayArgs {
-  ms: number;
-}
-
-interface WaitForSocketOpenArgs {
-  socket: WebSocket;
-}
-
-interface WaitForStatusDataBroadcastArgs {
-  socket: WebSocket;
-  timeoutMs: number;
-}
-
-interface WriteProviderScriptArgs {
-  scriptPath: string;
-}
-
-const STATUS_DATA_PROVIDER_SCRIPT = String.raw`
-const fs = require("node:fs");
-const path = require("node:path");
-const readline = require("node:readline");
-
-const rl = readline.createInterface({ input: process.stdin });
-const threads = new Map();
-let nextProviderThreadId = 1;
-let nextTurnId = 1;
-
-const modelList = {
-  models: [
-    {
-      id: "fake-model",
-      model: "fake-model",
-      displayName: "Fake Model",
-      description: "Fake model for integration and runtime tests",
-      supportedReasoningEfforts: [
-        {
-          reasoningEffort: "medium",
-          description: "Medium",
-        },
-      ],
-      defaultReasoningEffort: "medium",
-      isDefault: true,
-    },
-  ],
-  selectedOnlyModels: [],
-};
-
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function send(message) {
-  process.stdout.write(JSON.stringify(message) + "\n");
-}
-
-function paramsFor(message) {
-  return isRecord(message.params) ? message.params : {};
-}
-
-function stringValue(value, fallback) {
-  return typeof value === "string" ? value : fallback;
-}
-
-function inputText(input) {
-  if (!Array.isArray(input)) {
-    return "";
-  }
-  return input
-    .filter((item) => isRecord(item))
-    .filter((item) => item.type === "text" && typeof item.text === "string")
-    .map((item) => item.text)
-    .join(" ");
-}
-
-function threadStoragePath(params) {
-  const options = isRecord(params.options) ? params.options : {};
-  const envVars = isRecord(options.envVars) ? options.envVars : {};
-  return typeof envVars.BB_THREAD_STORAGE === "string"
-    ? envVars.BB_THREAD_STORAGE
-    : null;
-}
-
-function writeStatusData(params, fallbackStoragePath) {
-  if (!inputText(params.input).includes("write_status_data")) {
-    return;
-  }
-  const storagePath = threadStoragePath(params) ?? fallbackStoragePath;
-  if (!storagePath) {
-    throw new Error("Missing BB_THREAD_STORAGE in provider command options");
-  }
-  const dir = path.join(storagePath, "STATUS-data");
-  fs.mkdirSync(dir, { recursive: true });
-  const tmpPath = path.join(dir, ".worker." + process.pid + "." + Date.now() + ".tmp");
-  fs.writeFileSync(tmpPath, JSON.stringify({ v: 1 }) + "\n", "utf8");
-  fs.renameSync(tmpPath, path.join(dir, "worker.json"));
-}
-
-function beginTurn(params) {
-  const threadId = stringValue(params.threadId, "unknown");
-  const thread = threads.get(threadId);
-  const providerThreadId = thread
-    ? thread.providerThreadId
-    : stringValue(params.providerThreadId, "provider-thread");
-  const storedThreadStoragePath = thread ? thread.threadStoragePath : null;
-  const turnId = "turn-" + nextTurnId;
-  nextTurnId += 1;
-
-  send({
-    jsonrpc: "2.0",
-    method: "turn/started",
-    params: { threadId, turnId, providerThreadId },
-  });
-  writeStatusData(params, storedThreadStoragePath);
-  send({
-    jsonrpc: "2.0",
-    method: "item/completed",
-    params: {
-      threadId,
-      turnId,
-      providerThreadId,
-      item: {
-        type: "agentMessage",
-        id: "msg-" + turnId,
-        text: "Response to: " + inputText(params.input),
-      },
-    },
-  });
-  send({
-    jsonrpc: "2.0",
-    method: "turn/completed",
-    params: { threadId, turnId, providerThreadId, status: "completed" },
-  });
-}
-
-rl.on("line", (line) => {
-  const message = JSON.parse(line);
-  const params = paramsFor(message);
-  const id = message.id ?? 0;
-
-  if (message.method === "initialize") {
-    send({ jsonrpc: "2.0", id, result: { ok: true } });
-    return;
-  }
-  if (message.method === "model/list") {
-    send({ jsonrpc: "2.0", id, result: modelList });
-    return;
-  }
-  if (message.method === "thread/start") {
-    const threadId = stringValue(params.threadId, "unknown");
-    const providerThreadId = "prov-" + nextProviderThreadId;
-    nextProviderThreadId += 1;
-    threads.set(threadId, {
-      providerThreadId,
-      threadStoragePath: threadStoragePath(params),
-    });
-    send({ jsonrpc: "2.0", id, result: { providerThreadId } });
-    send({
-      jsonrpc: "2.0",
-      method: "thread/identity",
-      params: { threadId, providerThreadId },
-    });
-    if (Array.isArray(params.input) && params.input.length > 0) {
-      beginTurn({ ...params, providerThreadId });
-    }
-    return;
-  }
-  if (message.method === "turn/start") {
-    send({ jsonrpc: "2.0", id, result: { ok: true } });
-    beginTurn(params);
-    return;
-  }
-
-  send({ jsonrpc: "2.0", id, result: { ok: true } });
-});
-`;
-
-function delay(args: DelayArgs): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, args.ms);
-  });
-}
-
-function waitForSocketOpen(args: WaitForSocketOpenArgs): Promise<void> {
-  return new Promise((resolve, reject) => {
-    args.socket.once("open", () => resolve());
-    args.socket.once("error", reject);
-  });
-}
-
-function waitForStatusDataBroadcast(
-  args: WaitForStatusDataBroadcastArgs,
-): Promise<StatusStateBroadcastMessage> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      cleanup();
-      reject(new Error("Timed out waiting for status-data broadcast"));
-    }, args.timeoutMs);
-
-    const cleanup = () => {
-      clearTimeout(timeout);
-      args.socket.off("message", onMessage);
-      args.socket.off("error", onError);
-    };
-
-    const onError = (error: Error) => {
-      cleanup();
-      reject(error);
-    };
-
-    const onMessage = (data: RawData) => {
-      try {
-        const message = statusStateBroadcastMessageSchema.parse(
-          JSON.parse(data.toString("utf8")),
-        );
-        cleanup();
-        resolve(message);
-      } catch (error) {
-        cleanup();
-        reject(error);
-      }
-    };
-
-    args.socket.on("message", onMessage);
-    args.socket.on("error", onError);
-  });
-}
-
-async function writeProviderScript(
-  args: WriteProviderScriptArgs,
-): Promise<void> {
-  await fs.writeFile(args.scriptPath, STATUS_DATA_PROVIDER_SCRIPT, "utf8");
-}
-
-describe.sequential("fake provider STATUS-data watcher integration", () => {
-  it("broadcasts STATUS-data writes from a daemon provider process", async () => {
-    const scriptRoot = await fs.mkdtemp(
-      path.join(tmpdir(), "bb-status-provider-"),
-    );
-    const scriptPath = path.join(scriptRoot, "status-provider.cjs");
-    await writeProviderScript({ scriptPath });
-
-    try {
-      await withHarness(
-        {
-          adapterFactory: (providerId) =>
-            createFakeAdapter({
-              displayName: providerId,
-              id: providerId,
-              scriptPath,
-            }),
-        },
-        async (harness) => {
-          const project = await createProjectFixture(
-            harness,
-            "STATUS Data Watch",
-          );
-          const thread = await createHostThread(harness.api, {
-            execution: { permissionMode: "workspace-write" },
-            hostId: harness.hostId,
-            projectId: project.id,
-            workspace: {
-              type: "unmanaged",
-              path: harness.repoDir,
-            },
-          });
-          const readyThread = await waitForThreadStatus(
-            harness.api,
-            thread.id,
-            "idle",
-            DEFAULT_TIMEOUT_MS,
-          );
-          const socket = new WebSocket(
-            `${harness.serverUrl.replace("http", "ws")}/ws`,
-          );
-
-          try {
-            await waitForSocketOpen({ socket });
-            socket.send(
-              JSON.stringify({
-                type: "subscribe",
-                entity: "thread",
-                id: `${readyThread.id}:status-data`,
-              }),
-            );
-            await delay({ ms: 25 });
-
-            const broadcast = waitForStatusDataBroadcast({
-              socket,
-              timeoutMs: DEFAULT_TIMEOUT_MS,
-            });
-            await sendTextMessage(harness.api, readyThread.id, {
-              text: "write_status_data",
-            });
-            const message = await broadcast;
-
-            expect(message).toMatchObject({
-              type: "status-data.changed",
-              threadId: readyThread.id,
-              key: "worker",
-              value: { v: 1 },
-              deleted: false,
-              previousValue: null,
-              previousValuePresent: false,
-              writerClientId: null,
-              operationId: null,
-            });
-            expect(typeof message.version).toBe("string");
-            await expect(
-              fs.readFile(
-                path.join(
-                  harness.threadStorageRootPath,
-                  readyThread.id,
-                  "STATUS-data",
-                  "worker.json",
-                ),
-                "utf8",
-              ),
-            ).resolves.toBe('{"v":1}\n');
-            await waitForThreadStatus(
-              harness.api,
-              readyThread.id,
-              "idle",
-              TURN_TIMEOUT_MS,
-            );
-          } finally {
-            socket.close();
-          }
-        },
-      );
-    } finally {
-      await removePathWithRetry(scriptRoot);
-    }
-  });
-});

From 4624e099f5dc100dd743965c0d64bab7b0e45518 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 18:32:43 -0700
Subject: [PATCH 04/13] =?UTF-8?q?docs:=20add=20STATUS=20=E2=86=92=20Apps?=
 =?UTF-8?q?=20migration=20guide?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Guide for migrating an existing manager/thread off the removed STATUS surface
(STATUS.html/.md/STATUS folder + STATUS-data) to a `status` app: target layout,
manifest, state consolidation into data/state.json, the bbStatusState→window.bb
and bbThreadTell→window.bb.message API mapping, agent/maintainer direct-fs
writes, and cleanup. Points to `bb guide app` for the full reference.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/migrating-status-to-apps.md | 184 +++++++++++++++++++++++++++++++
 1 file changed, 184 insertions(+)
 create mode 100644 docs/migrating-status-to-apps.md

diff --git a/docs/migrating-status-to-apps.md b/docs/migrating-status-to-apps.md
new file mode 100644
index 000000000..47968c188
--- /dev/null
+++ b/docs/migrating-status-to-apps.md
@@ -0,0 +1,184 @@
+# Migrating from STATUS to Apps
+
+The legacy **STATUS** surface (`STATUS.html` / `STATUS.md` / a `STATUS/` folder
+plus the `STATUS-data/` key–value store) has been removed. A thread now exposes
+one or more **apps** instead, and the old single status dashboard becomes a
+regular app with the id `status`.
+
+This guide is for an **existing manager** (or any thread) whose storage still
+contains the old STATUS files and needs to move to the new format. New threads
+already seed a `status` app automatically and need no migration.
+
+For the full feature reference, run `bb guide app`. This doc only covers the
+mechanical migration.
+
+---
+
+## What changed
+
+| Legacy STATUS | New Apps |
+| --- | --- |
+| `STATUS/index.html`, `STATUS.html`, or `STATUS.md` in the thread-storage root | `apps/<id>/assets/<entry>` (entry is HTML or Markdown) |
+| One implicit status surface per thread | Any number of apps; the dashboard is just the app with id `status` |
+| `STATUS-data/<key>.json` (flat keys, `^[A-Za-z0-9_-]{1,80}$`) | `apps/<id>/data/<path>` (nested paths allowed; default: a single `data/state.json`) |
+| `window.bbStatusState` (`get`/`set`/`delete`/`list`/`on`) | `window.bb.data` (`read`/`write`/`delete`/`list`/`onChange`) |
+| `window.bbThreadTell(text)` | `window.bb.message(text)` |
+| Served at `/api/v1/threads/<id>/status/` | Served at `/api/v1/threads/<id>/apps/<id>/` |
+| Globals always injected | Injected only for **HTML** entries, gated by manifest `capabilities`; **Markdown** entries are static (no `window.bb`) |
+
+---
+
+## Target layout
+
+```text
+<thread-storage>/
+  apps/
+    status/
+      manifest.json     # metadata — NOT served
+      assets/           # the public web root
+        index.html      # (or index.md)
+      data/             # file-based key/value store
+        state.json      # default: keep all state in one blob
+      logo.svg          # optional; otherwise a built-in icon is used
+```
+
+`manifest.json` for the status dashboard:
+
+```json
+{
+  "manifestVersion": 1,
+  "id": "status",
+  "name": "Status",
+  "icon": "ListTodo",
+  "entry": "index.html",
+  "contributions": ["thread.app"],
+  "capabilities": ["data", "message"]
+}
+```
+
+- `id` must match the directory name and `^[A-Za-z0-9_-]+$`.
+- `entry` is resolved relative to `assets/`. Use `index.html` for an
+  interactive dashboard, or `index.md` for a static document (Markdown apps do
+  **not** get `window.bb`).
+- `icon` is a built-in icon name. To use a custom image instead, drop a
+  top-level `logo.svg` / `logo.png` / `logo.jpg` and omit `icon`; with neither,
+  apps fall back to the `GridView` icon.
+- `capabilities`: `data` injects `window.bb.data`, `message` injects
+  `window.bb.message`. List only what the app uses.
+
+---
+
+## Migration steps
+
+### 1. Create the app directory
+
+```bash
+APP="$BB_THREAD_STORAGE/apps/status"
+mkdir -p "$APP/assets" "$APP/data"
+```
+
+### 2. Move the markup into `assets/`
+
+- `STATUS.html`            → `apps/status/assets/index.html`
+- `STATUS/index.html` (+ its CSS/JS/images/fonts) → `apps/status/assets/` (keep the same relative structure; everything under `assets/` is served)
+- `STATUS.md`              → `apps/status/assets/index.md` (set `entry` to `index.md`; remember a Markdown entry is static)
+
+### 3. Migrate the state
+
+The default convention is a **single `data/state.json` blob**. If your old
+dashboard used a few `STATUS-data/*.json` keys, consolidate them:
+
+```bash
+# Example: fold STATUS-data/prs.json + STATUS-data/workers.json into one blob.
+jq -n \
+  --slurpfile prs     "$BB_THREAD_STORAGE/STATUS-data/prs.json" \
+  --slurpfile workers "$BB_THREAD_STORAGE/STATUS-data/workers.json" \
+  '{ prs: $prs[0], workers: $workers[0] }' \
+  > "$BB_THREAD_STORAGE/apps/status/data/state.json"
+```
+
+Or, if you prefer to keep separate keys, each old `STATUS-data/<key>.json`
+becomes `apps/status/data/<key>.json` (nested paths like `data/tasks/123` are
+also allowed — see `bb guide app` for the path rules).
+
+### 4. Update the in-page JavaScript
+
+Replace the old globals (HTML entries only):
+
+| Old | New |
+| --- | --- |
+| `window.bbStatusState.get(key)` | `await window.bb.data.read(path)` |
+| `window.bbStatusState.set(key, value)` | `await window.bb.data.write(path, value)` |
+| `window.bbStatusState.delete(key)` | `await window.bb.data.delete(path)` |
+| `window.bbStatusState.list()` | `await window.bb.data.list(prefix)` |
+| `window.bbStatusState.on(key, cb)` | `window.bb.data.onChange(prefix, cb)` |
+| `window.bbStatusState.on("*", cb)` | `window.bb.data.onChange("", cb)` |
+| `window.bbThreadTell(text)` | `await window.bb.message(text)` |
+
+Notes:
+- All `window.bb.data` methods are async (return Promises). `read` resolves to
+  the parsed JSON value or `undefined`.
+- `onChange(prefix, cb)` does **subtree** matching: `onChange("tasks")` fires
+  for `tasks` and `tasks/*` but not `tasksfoo`; `onChange("")` watches
+  everything. It **replays** existing matches once on registration, then streams
+  live changes. The callback receives `{ path, value, deleted }`.
+- If you consolidated into a single `state.json`, the common pattern is:
+
+  ```js
+  window.bb.data.read("state.json").then(render);
+  window.bb.data.onChange("state.json", (event) => render(event.value));
+  ```
+- Guard the helpers (`window.bb.data?.…`, `window.bb.message?.(…)`) — they are
+  only present when the matching capability is declared.
+
+### 5. Update how the agent / maintainer writes state
+
+Agents (and any maintainer worker) write app data by writing the files
+**directly on disk** — the daemon watches `data/` and broadcasts changes to open
+clients. Use the same atomic temp-file + rename pattern as before, just to the
+new path:
+
+```bash
+DIR="$BB_THREAD_STORAGE/apps/status/data"
+mkdir -p "$DIR"
+tmp=$(mktemp "$DIR/.state.XXXXXX")
+printf '%s\n' "$NEW_STATE_JSON" > "$tmp" && mv "$tmp" "$DIR/state.json"
+```
+
+(The browser side uses `window.bb.data.write(...)`, which routes through the
+daemon to the same file. Both paths converge on the one watched directory.)
+
+If a long-running maintainer worker used to write `STATUS-data/task_*.json`,
+re-point it at `apps/status/data/…` (a single `state.json` is recommended).
+
+### 6. Remove the old STATUS files
+
+Once the app renders correctly:
+
+```bash
+rm -rf "$BB_THREAD_STORAGE"/STATUS.html \
+       "$BB_THREAD_STORAGE"/STATUS.md \
+       "$BB_THREAD_STORAGE"/STATUS \
+       "$BB_THREAD_STORAGE"/STATUS-data
+```
+
+### 7. Verify
+
+```bash
+bb app list <thread-id>          # should show the `status` app
+bb app open status               # prints the served URL to open in the panel
+```
+
+Or open the thread's secondary panel: the pinned `Status` tab (and the `+`
+launcher) should show the app, and writing `data/state.json` should update it
+live with no reload.
+
+---
+
+## Quick reference
+
+- Full feature docs: `bb guide app` (manifest, `window.bb`, data paths, icons,
+  entry types, the `bb app` CLI).
+- Styling tokens for app HTML are documented there too (`bb guide styling`
+  redirects to the app guide).
+- `bb app new <name>` scaffolds additional apps; `bb app rm <name>` removes one.

From 93073cc9c5cab3eaa5866810fabc5cc79ba50d60 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 22:11:02 -0700
Subject: [PATCH 05/13] apps server: make flat URLs canonical, drop /assets/
 route, clean 404 on unmatched
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace `/api/v1/threads/:id/apps/:appId/assets/*` with the canonical flat
`/api/v1/threads/:id/apps/:appId/*` wildcard → filesystem
`apps/<appId>/assets/<*>`. The `assets/` directory is an internal storage
detail; URLs no longer expose it. Nested paths preserved.

Add an `/api/v1/*` JSON-404 guard so unmatched API URLs return JSON 404
instead of falling through to the bb SPA shell HTML.

Improve the fresh-manager missing-manifest path to return `app_not_provisioned`
with a rebuild hint (root cause was stale binaries, not a real seeding bug).

Update default status template HTML, file-content-urls, migration guide,
bb guide app, tests, and regenerated templates to flat URLs only. No
back-compat alias kept — apps system isn't shipped yet.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../secondary-panel/AppTabContent.test.tsx    |   2 +-
 apps/app/src/lib/file-content-urls.ts         |   2 +-
 apps/server/src/routes/threads/apps.ts        |  64 +++--
 apps/server/src/server.ts                     |   3 +
 apps/server/test/app/static-cache.test.ts     |  15 +-
 .../test/public/public-thread-apps.test.ts    | 235 +++++++++++++++---
 ...blic-threads.manager-and-ownership.test.ts |  15 +-
 docs/migrating-status-to-apps.md              |  54 ++--
 .../src/generated/templates.generated.ts      |   2 +-
 .../templates/src/templates/bb-guide-app.md   |   5 +
 10 files changed, 315 insertions(+), 82 deletions(-)

diff --git a/apps/app/src/components/secondary-panel/AppTabContent.test.tsx b/apps/app/src/components/secondary-panel/AppTabContent.test.tsx
index 048c558e3..70cbfaaf4 100644
--- a/apps/app/src/components/secondary-panel/AppTabContent.test.tsx
+++ b/apps/app/src/components/secondary-panel/AppTabContent.test.tsx
@@ -59,7 +59,7 @@ describe("AppTabContent", () => {
       kind: "text",
       path: "docs/index.md",
       name: "index.md",
-      url: "/api/v1/threads/thr_1/apps/readme/assets/docs/index.md",
+      url: "/api/v1/threads/thr_1/apps/readme/docs/index.md",
       mimeType: "text/markdown",
       content: "# App Notes\n\nStatic content.",
     });
diff --git a/apps/app/src/lib/file-content-urls.ts b/apps/app/src/lib/file-content-urls.ts
index 31a87fcfe..13ee9726b 100644
--- a/apps/app/src/lib/file-content-urls.ts
+++ b/apps/app/src/lib/file-content-urls.ts
@@ -51,7 +51,7 @@ export function buildThreadAppAssetUrl(
 ): string {
   return `/api/v1/threads/${encodeURIComponent(
     threadId,
-  )}/apps/${encodeURIComponent(appId)}/assets/${encodePathSegments(path)}`;
+  )}/apps/${encodeURIComponent(appId)}/${encodePathSegments(path)}`;
 }
 
 export function buildThreadAppAssetBaseUrl(
diff --git a/apps/server/src/routes/threads/apps.ts b/apps/server/src/routes/threads/apps.ts
index 5df68e93c..93af88e16 100644
--- a/apps/server/src/routes/threads/apps.ts
+++ b/apps/server/src/routes/threads/apps.ts
@@ -124,6 +124,11 @@ interface CreateInjectedAppHtmlResponseArgs {
   threadId: string;
 }
 
+interface AppAssetRouteSegmentArgs {
+  appId: string;
+  threadId: string;
+}
+
 type AppAssetPath = SafeRelativeRoutePath;
 
 interface LogoResolution {
@@ -165,7 +170,6 @@ const HTML_ENTRY_MAX_BYTES = 5 * 1024 * 1024;
 const LOGO_MAX_BYTES = 1024 * 1024;
 const LOGO_EXTENSIONS = ["svg", "png", "jpg", "jpeg"] as const;
 const APP_ROUTE_DATA_SEGMENT = "/data/";
-const APP_ROUTE_ASSETS_SEGMENT = "/assets/";
 
 function sha256(bytes: Buffer): string {
   return createHash("sha256").update(bytes).digest("hex");
@@ -201,7 +205,13 @@ function parseAppDataRoutePath(rawPath: string): AppDataPath {
   );
 }
 
-function parseOptionalAppDataPrefix(rawPrefix: string | undefined): AppDataPath | "" {
+function appAssetRouteSegment(args: AppAssetRouteSegmentArgs): string {
+  return `/threads/${encodeURIComponent(args.threadId)}/apps/${encodeURIComponent(args.appId)}/`;
+}
+
+function parseOptionalAppDataPrefix(
+  rawPrefix: string | undefined,
+): AppDataPath | "" {
   if (rawPrefix === undefined || rawPrefix === "") {
     return "";
   }
@@ -489,7 +499,24 @@ async function buildAppDetail(
   deps: AppDeps,
   args: AppDetailArgs,
 ): Promise<AppDetail> {
-  const manifest = await readAppManifest(deps, args);
+  let manifest: AppManifest;
+  try {
+    manifest = await readAppManifest(deps, args);
+  } catch (error) {
+    if (
+      error instanceof ApiError &&
+      error.status === 404 &&
+      error.body.code === "ENOENT" &&
+      error.body.message.includes(MANIFEST_FILE_NAME)
+    ) {
+      throw new ApiError(
+        404,
+        "app_not_provisioned",
+        `App "${args.appId}" is not provisioned yet; missing ${MANIFEST_FILE_NAME}. Restart bb from a current build if this manager was created before app seeding was available.`,
+      );
+    }
+    throw error;
+  }
   return buildAppSummary(deps, {
     ...args,
     manifest,
@@ -711,8 +738,7 @@ async function serveAppIcon(
     path: logoPath,
     dotfiles: "deny",
   });
-  const contentType =
-    mimeTypes.lookup(logoPath) || "application/octet-stream";
+  const contentType = mimeTypes.lookup(logoPath) || "application/octet-stream";
   return new Response(decodeDaemonFileContent(result), {
     status: 200,
     headers: {
@@ -1115,18 +1141,6 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
     ),
   );
 
-  app.get("/threads/:id/apps/:appId/assets/*", async (context) =>
-    serveAppAsset(
-      deps,
-      context.req.param("id"),
-      context.req.param("appId"),
-      extractRoutePath({
-        requestUrl: context.req.url,
-        routeSegment: APP_ROUTE_ASSETS_SEGMENT,
-      }),
-    ),
-  );
-
   app.get("/threads/:id/apps/:appId/icon", async (context) =>
     serveAppIcon(deps, context.req.param("id"), context.req.param("appId")),
   );
@@ -1202,4 +1216,20 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
     response.headers.set("cache-control", NO_STORE_CACHE_CONTROL);
     return response;
   });
+
+  // Keep this flat asset wildcard last among GET app routes so typed app
+  // endpoints such as /data/* and /icon keep their route ownership.
+  app.get("/threads/:id/apps/:appId/*", async (context) => {
+    const threadId = context.req.param("id");
+    const appId = context.req.param("appId");
+    return serveAppAsset(
+      deps,
+      threadId,
+      appId,
+      extractRoutePath({
+        requestUrl: context.req.url,
+        routeSegment: appAssetRouteSegment({ threadId, appId }),
+      }),
+    );
+  });
 }
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index cd3f4dbe2..bafc06f35 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -255,6 +255,9 @@ export function createApp(
   registerManagerTemplateRoutes(publicApi, deps);
   registerDevelopmentOnlyReplayRoutes(publicApi, deps);
   app.route("/api/v1", publicApi);
+  app.use("/api/v1/*", () => {
+    throw new ApiError(404, "not_found", "Not found");
+  });
 
   const internalApi = new Hono();
   registerInternalHostRoutes(internalApi, deps);
diff --git a/apps/server/test/app/static-cache.test.ts b/apps/server/test/app/static-cache.test.ts
index 171cf93ab..ed13996e5 100644
--- a/apps/server/test/app/static-cache.test.ts
+++ b/apps/server/test/app/static-cache.test.ts
@@ -11,7 +11,7 @@ describe("production static cache headers", () => {
     await mkdir(join(staticDir, "assets"), { recursive: true });
     await writeFile(
       join(staticDir, "index.html"),
-      "<!doctype html><script type=\"module\" src=\"/assets/index-test.js\"></script>",
+      '<!doctype html><script type="module" src="/assets/index-test.js"></script>',
     );
     await writeFile(
       join(staticDir, "assets", "index-test.js"),
@@ -33,6 +33,19 @@ describe("production static cache headers", () => {
       expect(assetResponse.headers.get("cache-control")).toBe(
         "public, max-age=31536000, immutable",
       );
+
+      const apiMissResponse = await serverApp.app.request(
+        "/api/v1/does-not-exist.js",
+      );
+      const apiMissBody = await apiMissResponse.text();
+      expect(apiMissResponse.status).toBe(404);
+      expect(apiMissResponse.headers.get("content-type")).toBe(
+        "application/json",
+      );
+      expect(apiMissBody).not.toContain("index-test.js");
+      expect(JSON.parse(apiMissBody)).toMatchObject({
+        code: "not_found",
+      });
     } finally {
       await serverApp.closeWebSockets();
       await harness.cleanup();
diff --git a/apps/server/test/public/public-thread-apps.test.ts b/apps/server/test/public/public-thread-apps.test.ts
index 67cf3e726..495014bfd 100644
--- a/apps/server/test/public/public-thread-apps.test.ts
+++ b/apps/server/test/public/public-thread-apps.test.ts
@@ -1,4 +1,7 @@
 import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import type { HostDaemonCommand } from "@bb/host-daemon-contract";
 import {
   appDataListResponseSchema,
@@ -16,6 +19,7 @@ import {
   type QueuedCommand,
 } from "../helpers/commands.js";
 import { readJson } from "../helpers/json.js";
+import { createApp } from "../../src/server.js";
 import type { TestAppHarness } from "../helpers/test-app.js";
 import {
   seedEnvironment,
@@ -145,7 +149,9 @@ function requireWriteFileRelativeCommand(
   throw new Error("Expected host.write_file_relative command");
 }
 
-async function reportManifestRead(args: ManifestReadArgs): Promise<QueuedCommand> {
+async function reportManifestRead(
+  args: ManifestReadArgs,
+): Promise<QueuedCommand> {
   const queued = args.afterCursor
     ? await waitForQueuedCommandAfter(
         args.harness,
@@ -227,11 +233,42 @@ describe("public thread app routes", () => {
     }
   });
 
+  it("returns a provisioned-app error when app detail is missing manifest.json", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status`,
+      );
+      const manifestCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(fixture, "status") &&
+          command.path === "manifest.json",
+      );
+      await reportQueuedCommandError(harness, manifestCommand, {
+        errorCode: "ENOENT",
+        errorMessage: "Path does not exist: manifest.json",
+      });
+
+      const response = await request;
+      expect(response.status).toBe(404);
+      await expect(readJson(response)).resolves.toMatchObject({
+        code: "app_not_provisioned",
+        message: expect.stringContaining("missing manifest.json"),
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
   it("serves HTML app entries with capability-scoped window.bb injection", async () => {
     const harness = await createTestAppHarness();
     try {
       const fixture = seedManagerThreadStorage(harness);
-      const html = "<!doctype html><html><head></head><body>Status</body></html>";
+      const html =
+        "<!doctype html><html><head></head><body>Status</body></html>";
       const request = harness.app.request(
         `/api/v1/threads/${fixture.threadId}/apps/status/`,
       );
@@ -286,6 +323,122 @@ describe("public thread app routes", () => {
     }
   });
 
+  it("serves flat app asset URLs from the internal assets directory", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/index-Cd7sCqsN.js`,
+      );
+      const assetCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appAssetsRoot(fixture, "status") &&
+          command.path === "index-Cd7sCqsN.js",
+      );
+      expect(assetCommand.command).toMatchObject({ dotfiles: "deny" });
+      await reportQueuedCommandSuccess(
+        harness,
+        assetCommand,
+        readFileResult({
+          path: "index-Cd7sCqsN.js",
+          content: "console.log('status');",
+          mimeType: "application/javascript",
+        }),
+      );
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe(
+        "application/javascript",
+      );
+      expect(response.headers.get("x-content-type-options")).toBe("nosniff");
+      await expect(response.text()).resolves.toBe("console.log('status');");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("serves nested flat app asset URLs without collapsing path segments", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/chunks/index-Cd7sCqsN.js`,
+      );
+      const assetCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appAssetsRoot(fixture, "status") &&
+          command.path === "chunks/index-Cd7sCqsN.js",
+      );
+      await reportQueuedCommandSuccess(
+        harness,
+        assetCommand,
+        readFileResult({
+          path: "chunks/index-Cd7sCqsN.js",
+          content: "export const status = true;",
+          mimeType: "application/javascript",
+        }),
+      );
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe(
+        "application/javascript",
+      );
+      await expect(response.text()).resolves.toBe(
+        "export const status = true;",
+      );
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("returns JSON 404 for missing flat app assets instead of the outer SPA shell", async () => {
+    const staticDir = await mkdtemp(path.join(tmpdir(), "bb-apps-static-"));
+    await writeFile(
+      path.join(staticDir, "index.html"),
+      '<!doctype html><html lang="en" class="bb-app-shell-root"><head><title>bb</title></head><body>shell</body></html>',
+      "utf8",
+    );
+    const harness = await createTestAppHarness();
+    const serverApp = createApp(harness.deps, { staticDir });
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = serverApp.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/status/missing.js`,
+      );
+      const assetCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appAssetsRoot(fixture, "status") &&
+          command.path === "missing.js",
+      );
+      await reportQueuedCommandError(harness, assetCommand, {
+        errorCode: "ENOENT",
+        errorMessage: "Path does not exist: missing.js",
+      });
+
+      const response = await request;
+      const body = await response.text();
+      expect(response.status).toBe(404);
+      expect(response.headers.get("content-type")).toBe("application/json");
+      expect(body).not.toContain("bb-app-shell-root");
+      expect(JSON.parse(body)).toMatchObject({
+        code: "ENOENT",
+        message: "Path does not exist: missing.js",
+      });
+    } finally {
+      await serverApp.closeWebSockets();
+      await harness.cleanup();
+      await rm(staticDir, { recursive: true, force: true });
+    }
+  });
+
   it("proxies app data list, read, write, and delete through generic daemon file commands", async () => {
     const harness = await createTestAppHarness();
     try {
@@ -343,7 +496,9 @@ describe("public thread app routes", () => {
       });
       const listResponse = await listRequest;
       expect(listResponse.status).toBe(200);
-      expect(appDataListResponseSchema.parse(await readJson(listResponse))).toEqual({
+      expect(
+        appDataListResponseSchema.parse(await readJson(listResponse)),
+      ).toEqual({
         entries: [
           {
             path: "state.json",
@@ -396,15 +551,15 @@ describe("public thread app routes", () => {
       });
       const readResponse = await readRequest;
       expect(readResponse.status).toBe(200);
-      expect(appDataReadResponseSchema.parse(await readJson(readResponse))).toEqual(
-        {
-          path: "state.json",
-          value: { workers: [] },
-          version: sha256Text(stateJson),
-          sizeBytes: Buffer.byteLength(stateJson),
-          modifiedAtMs: 2345,
-        },
-      );
+      expect(
+        appDataReadResponseSchema.parse(await readJson(readResponse)),
+      ).toEqual({
+        path: "state.json",
+        value: { workers: [] },
+        version: sha256Text(stateJson),
+        sizeBytes: Buffer.byteLength(stateJson),
+        modifiedAtMs: 2345,
+      });
 
       const nextValue = { workers: [{ id: "worker-1" }] };
       const nextJson = `${JSON.stringify(nextValue, null, 2)}\n`;
@@ -444,15 +599,15 @@ describe("public thread app routes", () => {
       });
       const writeResponse = await writeRequest;
       expect(writeResponse.status).toBe(200);
-      expect(appDataReadResponseSchema.parse(await readJson(writeResponse))).toEqual(
-        {
-          path: "state.json",
-          value: nextValue,
-          version: sha256Text(nextJson),
-          sizeBytes: Buffer.byteLength(nextJson),
-          modifiedAtMs: 3456,
-        },
-      );
+      expect(
+        appDataReadResponseSchema.parse(await readJson(writeResponse)),
+      ).toEqual({
+        path: "state.json",
+        value: nextValue,
+        version: sha256Text(nextJson),
+        sizeBytes: Buffer.byteLength(nextJson),
+        modifiedAtMs: 3456,
+      });
 
       const deleteRequest = harness.app.request(
         `/api/v1/threads/${fixture.threadId}/apps/status/data/state.json`,
@@ -591,24 +746,26 @@ describe("public thread app routes", () => {
 
       const response = await request;
       expect(response.status).toBe(200);
-      expect(appDataListResponseSchema.parse(await readJson(response))).toEqual({
-        entries: [
-          {
-            path: "tasks/nested/two.json",
-            value: { title: "Two" },
-            version: sha256Text(twoJson),
-            sizeBytes: Buffer.byteLength(twoJson),
-            modifiedAtMs: 2222,
-          },
-          {
-            path: "tasks/one.json",
-            value: { title: "One" },
-            version: sha256Text(oneJson),
-            sizeBytes: Buffer.byteLength(oneJson),
-            modifiedAtMs: 1111,
-          },
-        ],
-      });
+      expect(appDataListResponseSchema.parse(await readJson(response))).toEqual(
+        {
+          entries: [
+            {
+              path: "tasks/nested/two.json",
+              value: { title: "Two" },
+              version: sha256Text(twoJson),
+              sizeBytes: Buffer.byteLength(twoJson),
+              modifiedAtMs: 2222,
+            },
+            {
+              path: "tasks/one.json",
+              value: { title: "One" },
+              version: sha256Text(oneJson),
+              sizeBytes: Buffer.byteLength(oneJson),
+              modifiedAtMs: 1111,
+            },
+          ],
+        },
+      );
     } finally {
       await harness.cleanup();
     }
diff --git a/apps/server/test/public/public-threads.manager-and-ownership.test.ts b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
index dc6f0801d..afe32a30b 100644
--- a/apps/server/test/public/public-threads.manager-and-ownership.test.ts
+++ b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
@@ -1116,9 +1116,22 @@ describe("public thread manager and ownership routes", () => {
         ({ command }) =>
           command.type === "thread.start" && command.threadId === thread.id,
       );
+      const storagePath = path.join(dataDir, "thread-storage", thread.id);
       await expect(
-        stat(path.join(dataDir, "thread-storage", thread.id, "PREFERENCES.md")),
+        stat(path.join(storagePath, "PREFERENCES.md")),
       ).rejects.toThrow();
+      await expect(
+        readFile(path.join(storagePath, "apps/status/manifest.json"), "utf8"),
+      ).resolves.toContain('"id": "status"');
+      await expect(
+        readFile(
+          path.join(storagePath, "apps/status/assets/index.html"),
+          "utf8",
+        ),
+      ).resolves.toContain("<title>Status</title>");
+      await expect(
+        readFile(path.join(storagePath, "apps/status/data/state.json"), "utf8"),
+      ).resolves.toContain('"landingMode": "pr"');
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
diff --git a/docs/migrating-status-to-apps.md b/docs/migrating-status-to-apps.md
index 47968c188..30017b87d 100644
--- a/docs/migrating-status-to-apps.md
+++ b/docs/migrating-status-to-apps.md
@@ -16,15 +16,15 @@ mechanical migration.
 
 ## What changed
 
-| Legacy STATUS | New Apps |
-| --- | --- |
-| `STATUS/index.html`, `STATUS.html`, or `STATUS.md` in the thread-storage root | `apps/<id>/assets/<entry>` (entry is HTML or Markdown) |
-| One implicit status surface per thread | Any number of apps; the dashboard is just the app with id `status` |
-| `STATUS-data/<key>.json` (flat keys, `^[A-Za-z0-9_-]{1,80}$`) | `apps/<id>/data/<path>` (nested paths allowed; default: a single `data/state.json`) |
-| `window.bbStatusState` (`get`/`set`/`delete`/`list`/`on`) | `window.bb.data` (`read`/`write`/`delete`/`list`/`onChange`) |
-| `window.bbThreadTell(text)` | `window.bb.message(text)` |
-| Served at `/api/v1/threads/<id>/status/` | Served at `/api/v1/threads/<id>/apps/<id>/` |
-| Globals always injected | Injected only for **HTML** entries, gated by manifest `capabilities`; **Markdown** entries are static (no `window.bb`) |
+| Legacy STATUS                                                                 | New Apps                                                                                                               |
+| ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `STATUS/index.html`, `STATUS.html`, or `STATUS.md` in the thread-storage root | `apps/<id>/assets/<entry>` on disk, served at `/api/v1/threads/<thread-id>/apps/<id>/<entry>`                          |
+| One implicit status surface per thread                                        | Any number of apps; the dashboard is just the app with id `status`                                                     |
+| `STATUS-data/<key>.json` (flat keys, `^[A-Za-z0-9_-]{1,80}$`)                 | `apps/<id>/data/<path>` (nested paths allowed; default: a single `data/state.json`)                                    |
+| `window.bbStatusState` (`get`/`set`/`delete`/`list`/`on`)                     | `window.bb.data` (`read`/`write`/`delete`/`list`/`onChange`)                                                           |
+| `window.bbThreadTell(text)`                                                   | `window.bb.message(text)`                                                                                              |
+| Served at `/api/v1/threads/<id>/status/`                                      | Served at `/api/v1/threads/<id>/apps/<id>/`                                                                            |
+| Globals always injected                                                       | Injected only for **HTML** entries, gated by manifest `capabilities`; **Markdown** entries are static (no `window.bb`) |
 
 ---
 
@@ -35,7 +35,7 @@ mechanical migration.
   apps/
     status/
       manifest.json     # metadata — NOT served
-      assets/           # the public web root
+      assets/           # internal storage for browser files
         index.html      # (or index.md)
       data/             # file-based key/value store
         state.json      # default: keep all state in one blob
@@ -66,6 +66,11 @@ mechanical migration.
 - `capabilities`: `data` injects `window.bb.data`, `message` injects
   `window.bb.message`. List only what the app uses.
 
+Browser files under `assets/` are served from the flat app URL. For example,
+`apps/status/assets/index-Cd7sCqsN.js` is requested as
+`/api/v1/threads/<thread-id>/apps/status/index-Cd7sCqsN.js`; do not include an
+`assets/` segment in HTML references.
+
 ---
 
 ## Migration steps
@@ -79,9 +84,14 @@ mkdir -p "$APP/assets" "$APP/data"
 
 ### 2. Move the markup into `assets/`
 
-- `STATUS.html`            → `apps/status/assets/index.html`
-- `STATUS/index.html` (+ its CSS/JS/images/fonts) → `apps/status/assets/` (keep the same relative structure; everything under `assets/` is served)
-- `STATUS.md`              → `apps/status/assets/index.md` (set `entry` to `index.md`; remember a Markdown entry is static)
+- `STATUS.html` → `apps/status/assets/index.html`
+- `STATUS/index.html` (+ its CSS/JS/images/fonts) → `apps/status/assets/` (keep the same relative structure; everything under `assets/` is served from the flat app URL)
+- `STATUS.md` → `apps/status/assets/index.md` (set `entry` to `index.md`; remember a Markdown entry is static)
+
+Use flat relative HTML references, such as `<script type="module"
+src="./index-abc.js"></script>` or `<link rel="stylesheet"
+href="./style.css">`. If you build with Vite, set `build.assetsDir = ""` so
+emitted CSS/JS/assets sit alongside `index.html` inside `assets/`.
 
 ### 3. Migrate the state
 
@@ -105,17 +115,18 @@ also allowed — see `bb guide app` for the path rules).
 
 Replace the old globals (HTML entries only):
 
-| Old | New |
-| --- | --- |
-| `window.bbStatusState.get(key)` | `await window.bb.data.read(path)` |
+| Old                                    | New                                       |
+| -------------------------------------- | ----------------------------------------- |
+| `window.bbStatusState.get(key)`        | `await window.bb.data.read(path)`         |
 | `window.bbStatusState.set(key, value)` | `await window.bb.data.write(path, value)` |
-| `window.bbStatusState.delete(key)` | `await window.bb.data.delete(path)` |
-| `window.bbStatusState.list()` | `await window.bb.data.list(prefix)` |
-| `window.bbStatusState.on(key, cb)` | `window.bb.data.onChange(prefix, cb)` |
-| `window.bbStatusState.on("*", cb)` | `window.bb.data.onChange("", cb)` |
-| `window.bbThreadTell(text)` | `await window.bb.message(text)` |
+| `window.bbStatusState.delete(key)`     | `await window.bb.data.delete(path)`       |
+| `window.bbStatusState.list()`          | `await window.bb.data.list(prefix)`       |
+| `window.bbStatusState.on(key, cb)`     | `window.bb.data.onChange(prefix, cb)`     |
+| `window.bbStatusState.on("*", cb)`     | `window.bb.data.onChange("", cb)`         |
+| `window.bbThreadTell(text)`            | `await window.bb.message(text)`           |
 
 Notes:
+
 - All `window.bb.data` methods are async (return Promises). `read` resolves to
   the parsed JSON value or `undefined`.
 - `onChange(prefix, cb)` does **subtree** matching: `onChange("tasks")` fires
@@ -128,6 +139,7 @@ Notes:
   window.bb.data.read("state.json").then(render);
   window.bb.data.onChange("state.json", (event) => render(event.value));
   ```
+
 - Guard the helpers (`window.bb.data?.…`, `window.bb.message?.(…)`) — they are
   only present when the matching capability is declared.
 
diff --git a/packages/templates/src/generated/templates.generated.ts b/packages/templates/src/generated/templates.generated.ts
index 15b1f81bb..616516dee 100644
--- a/packages/templates/src/generated/templates.generated.ts
+++ b/packages/templates/src/generated/templates.generated.ts
@@ -18,7 +18,7 @@ export const templateDefinitions = [
   },
   {
     "id": "bbGuideApp",
-    "body": "Apps\n\nApps are the supported way to build dashboards, control panels, and other\ninteractive surfaces inside thread storage. A manager's primary status surface\nis the built-in `status` app. Keep that app current instead of creating legacy\ntop-level status files.\n\nStorage layout:\n\n```text\n$BB_THREAD_STORAGE/\n  apps/\n    status/\n      manifest.json\n      assets/\n        index.html\n      data/\n        state.json\n```\n\nEach app is rooted at `apps/<id>/`. The manifest lives at\n`apps/<id>/manifest.json`, browser files live under `apps/<id>/assets/`, and\ndurable JSON state lives under `apps/<id>/data/`. The `status` app should keep\nits primary shared state in `apps/status/data/state.json`.\n\nManifest:\n\n```json\n{\n  \"manifestVersion\": 1,\n  \"id\": \"status\",\n  \"name\": \"Status\",\n  \"icon\": \"ListTodo\",\n  \"entry\": \"index.html\",\n  \"contributions\": [\"thread.app\"],\n  \"capabilities\": [\"data\", \"message\"]\n}\n```\n\n`id` uses letters, numbers, underscores, and hyphens. `entry` is relative to\n`assets/`. HTML entries load in an app iframe and receive the `window.bb`\nbridge according to `capabilities`; Markdown entries render as static documents\nand do not receive `window.bb`. `capabilities` controls which `window.bb`\nhelpers are injected for HTML entries: `data` enables `window.bb.data`, and\n`message` enables `window.bb.message`.\n\nThe icon is optional and uses a built-in icon name. Icon resolution order is:\n\n1. `manifest.icon`, when present, as a built-in icon.\n2. A custom top-level `logo.svg`, `logo.png`, `logo.jpg`, or `logo.jpeg` in the\n   app root, up to 1 MB.\n3. The built-in `GridView` fallback.\n\nCLI:\n\n```bash\nbb app list --self\nbb app new \"Review Board\" --id review-board --template blank --self\nbb app new \"Status\" --id status --template status --self\nbb app open status --self\nbb app rm review-board --self --yes\n```\n\nPass a thread id instead of `--self` to target another thread. `bb app open`\nprints the app URL. `--json` is available for scripts.\n\nAgent writes:\n\nWrite app data directly to `apps/<id>/data/<path>` using a temp file in the\nsame directory and then `mv` into place. Same-directory rename is atomic on\nmacOS and Linux, and bb broadcasts the committed app-data change.\n\n```bash\ndir=\"$BB_THREAD_STORAGE/apps/status/data\"\nmkdir -p \"$dir\"\ntmp=$(mktemp \"$dir/.state.XXXXXX\")\nprintf '%s\\n' '{\"tasks\":[],\"updatedAt\":\"2026-05-28T00:00:00Z\"}' > \"$tmp\" &&\n  mv \"$tmp\" \"$dir/state.json\"\n```\n\nData paths are relative to the app's `data/` directory. They must not start or\nend with `/`, must not contain backslashes, dot-prefixed segments, `.` or `..`,\nand may be nested up to eight path segments. Each segment may use letters,\nnumbers, dots, underscores, and hyphens.\n\nBrowser API:\n\n```ts\nwindow.bb.appId\nawait window.bb.data?.read(\"state.json\")\nawait window.bb.data?.write(\"state.json\", { tasks: [] })\nawait window.bb.data?.delete(\"state.json\")\nconst entries = await window.bb.data?.list(\"\")\nconst unsubscribe = window.bb.data?.onChange(\"\", (event) => {\n  console.log(event.path, event.value, event.deleted)\n})\nawait window.bb.message?.(\"Please review the current blockers.\")\n```\n\n`window.bb.data` reads and writes JSON values. `onChange(prefix, callback)`\nmatches a single data file when `prefix` equals that path and matches a subtree\nwhen the changed path is below `prefix + \"/\"`; `\"\"` matches all app data.\nRegistering a listener immediately replays existing matching data, and bb\nreplays again after reconnects or app-data resync hints. Later filesystem\nwrites, browser writes, and deletes are delivered after that replay.\n`window.bb.message(text)` sends a normal follow-up message to the thread that\nowns the app.\n\nMinimal status app pattern:\n\n```html\n<main>\n  <h1>Current work</h1>\n  <ul id=\"tasks\"></ul>\n</main>\n<script>\nconst list = document.querySelector(\"#tasks\");\n\nfunction render(state) {\n  const tasks = state?.tasks ?? [];\n  list.replaceChildren(\n    ...tasks.map((task) => {\n      const item = document.createElement(\"li\");\n      item.textContent = `${task.title} - ${task.state}`;\n      return item;\n    }),\n  );\n}\n\nwindow.bb.data?.read(\"state.json\").then(render);\nwindow.bb.data?.onChange(\"state.json\", (event) => render(event.value));\n</script>\n```\n\nStyling:\n\nMake app UI quiet, dense, and consistent with bb unless the user asks for a\ndifferent direction. Use Tailwind for layout utilities if helpful, and use the\nbb-style tokens below for colors, fonts, borders, radius, and shadows. Apps\nrender in iframes, so external resources such as Google Fonts, Tailwind CDN,\nremote images, and stylesheets load normally.\n\n```html\n<script src=\"https://cdn.tailwindcss.com\"></script>\n<link rel=\"preconnect\" href=\"https://fonts.googleapis.com\">\n<link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin>\n<link href=\"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap\" rel=\"stylesheet\">\n<style>\n:root {\n  color-scheme: light;\n  --background: oklch(0.9551 0 0);\n  --foreground: oklch(0.3211 0 0);\n  --card: oklch(0.9702 0 0);\n  --muted: oklch(0.8853 0 0);\n  --muted-foreground: oklch(0.5103 0 0);\n  --border: oklch(0.8576 0 0);\n  --accent: oklch(0.9 0 0);\n  --success: oklch(0.7 0.15 155);\n  --warning: oklch(0.7 0.16 50);\n  --destructive: oklch(0.5594 0.19 25.8625);\n  --radius: 0.5rem;\n  --font-sans: \"Inter\", ui-sans-serif, system-ui, sans-serif;\n  --font-mono: \"Fira Code\", ui-monospace, SFMono-Regular, monospace;\n}\n@media (prefers-color-scheme: dark) {\n  :root {\n    color-scheme: dark;\n    --background: oklch(0.2178 0 0);\n    --foreground: oklch(0.8853 0 0);\n    --card: oklch(0.2435 0 0);\n    --muted: oklch(0.31 0 0);\n    --muted-foreground: oklch(0.7058 0 0);\n    --border: oklch(0.34 0 0);\n    --accent: oklch(0.32 0 0);\n  }\n}\nbody {\n  margin: 0;\n  background: var(--background);\n  color: var(--foreground);\n  font-family: var(--font-sans);\n  font-size: 13px;\n}\n.panel {\n  border: 1px solid var(--border);\n  border-radius: var(--radius);\n  background: var(--card);\n}\n</style>\n```\n\nKeep one canonical app for each concept. For manager progress, update the\n`status` app instead of creating parallel views. Use additional apps only when\nthey are distinct tools or dashboards.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide manager-templates\n  bb guide async",
+    "body": "Apps\n\nApps are the supported way to build dashboards, control panels, and other\ninteractive surfaces inside thread storage. A manager's primary status surface\nis the built-in `status` app. Keep that app current instead of creating legacy\ntop-level status files.\n\nStorage layout:\n\n```text\n$BB_THREAD_STORAGE/\n  apps/\n    status/\n      manifest.json\n      assets/\n        index.html\n      data/\n        state.json\n```\n\nEach app is rooted at `apps/<id>/`. The manifest lives at\n`apps/<id>/manifest.json`, browser files live under `apps/<id>/assets/`, and\ndurable JSON state lives under `apps/<id>/data/`. The `status` app should keep\nits primary shared state in `apps/status/data/state.json`.\n\nManifest:\n\n```json\n{\n  \"manifestVersion\": 1,\n  \"id\": \"status\",\n  \"name\": \"Status\",\n  \"icon\": \"ListTodo\",\n  \"entry\": \"index.html\",\n  \"contributions\": [\"thread.app\"],\n  \"capabilities\": [\"data\", \"message\"]\n}\n```\n\n`id` uses letters, numbers, underscores, and hyphens. `entry` is relative to\n`assets/`. HTML entries load in an app iframe and receive the `window.bb`\nbridge according to `capabilities`; Markdown entries render as static documents\nand do not receive `window.bb`. `capabilities` controls which `window.bb`\nhelpers are injected for HTML entries: `data` enables `window.bb.data`, and\n`message` enables `window.bb.message`.\n\nThe served app URL is flat: `/api/v1/threads/<thread-id>/apps/<id>/<file>`\nmaps to `apps/<id>/assets/<file>` on disk. HTML should use flat relative refs\nlike `./index-abc.js`, not `./assets/index-abc.js`. For Vite builds, set\n`build.assetsDir = \"\"` so emitted files sit alongside `index.html`.\n\nThe icon is optional and uses a built-in icon name. Icon resolution order is:\n\n1. `manifest.icon`, when present, as a built-in icon.\n2. A custom top-level `logo.svg`, `logo.png`, `logo.jpg`, or `logo.jpeg` in the\n   app root, up to 1 MB.\n3. The built-in `GridView` fallback.\n\nCLI:\n\n```bash\nbb app list --self\nbb app new \"Review Board\" --id review-board --template blank --self\nbb app new \"Status\" --id status --template status --self\nbb app open status --self\nbb app rm review-board --self --yes\n```\n\nPass a thread id instead of `--self` to target another thread. `bb app open`\nprints the app URL. `--json` is available for scripts.\n\nAgent writes:\n\nWrite app data directly to `apps/<id>/data/<path>` using a temp file in the\nsame directory and then `mv` into place. Same-directory rename is atomic on\nmacOS and Linux, and bb broadcasts the committed app-data change.\n\n```bash\ndir=\"$BB_THREAD_STORAGE/apps/status/data\"\nmkdir -p \"$dir\"\ntmp=$(mktemp \"$dir/.state.XXXXXX\")\nprintf '%s\\n' '{\"tasks\":[],\"updatedAt\":\"2026-05-28T00:00:00Z\"}' > \"$tmp\" &&\n  mv \"$tmp\" \"$dir/state.json\"\n```\n\nData paths are relative to the app's `data/` directory. They must not start or\nend with `/`, must not contain backslashes, dot-prefixed segments, `.` or `..`,\nand may be nested up to eight path segments. Each segment may use letters,\nnumbers, dots, underscores, and hyphens.\n\nBrowser API:\n\n```ts\nwindow.bb.appId\nawait window.bb.data?.read(\"state.json\")\nawait window.bb.data?.write(\"state.json\", { tasks: [] })\nawait window.bb.data?.delete(\"state.json\")\nconst entries = await window.bb.data?.list(\"\")\nconst unsubscribe = window.bb.data?.onChange(\"\", (event) => {\n  console.log(event.path, event.value, event.deleted)\n})\nawait window.bb.message?.(\"Please review the current blockers.\")\n```\n\n`window.bb.data` reads and writes JSON values. `onChange(prefix, callback)`\nmatches a single data file when `prefix` equals that path and matches a subtree\nwhen the changed path is below `prefix + \"/\"`; `\"\"` matches all app data.\nRegistering a listener immediately replays existing matching data, and bb\nreplays again after reconnects or app-data resync hints. Later filesystem\nwrites, browser writes, and deletes are delivered after that replay.\n`window.bb.message(text)` sends a normal follow-up message to the thread that\nowns the app.\n\nMinimal status app pattern:\n\n```html\n<main>\n  <h1>Current work</h1>\n  <ul id=\"tasks\"></ul>\n</main>\n<script>\nconst list = document.querySelector(\"#tasks\");\n\nfunction render(state) {\n  const tasks = state?.tasks ?? [];\n  list.replaceChildren(\n    ...tasks.map((task) => {\n      const item = document.createElement(\"li\");\n      item.textContent = `${task.title} - ${task.state}`;\n      return item;\n    }),\n  );\n}\n\nwindow.bb.data?.read(\"state.json\").then(render);\nwindow.bb.data?.onChange(\"state.json\", (event) => render(event.value));\n</script>\n```\n\nStyling:\n\nMake app UI quiet, dense, and consistent with bb unless the user asks for a\ndifferent direction. Use Tailwind for layout utilities if helpful, and use the\nbb-style tokens below for colors, fonts, borders, radius, and shadows. Apps\nrender in iframes, so external resources such as Google Fonts, Tailwind CDN,\nremote images, and stylesheets load normally.\n\n```html\n<script src=\"https://cdn.tailwindcss.com\"></script>\n<link rel=\"preconnect\" href=\"https://fonts.googleapis.com\">\n<link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin>\n<link href=\"https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap\" rel=\"stylesheet\">\n<style>\n:root {\n  color-scheme: light;\n  --background: oklch(0.9551 0 0);\n  --foreground: oklch(0.3211 0 0);\n  --card: oklch(0.9702 0 0);\n  --muted: oklch(0.8853 0 0);\n  --muted-foreground: oklch(0.5103 0 0);\n  --border: oklch(0.8576 0 0);\n  --accent: oklch(0.9 0 0);\n  --success: oklch(0.7 0.15 155);\n  --warning: oklch(0.7 0.16 50);\n  --destructive: oklch(0.5594 0.19 25.8625);\n  --radius: 0.5rem;\n  --font-sans: \"Inter\", ui-sans-serif, system-ui, sans-serif;\n  --font-mono: \"Fira Code\", ui-monospace, SFMono-Regular, monospace;\n}\n@media (prefers-color-scheme: dark) {\n  :root {\n    color-scheme: dark;\n    --background: oklch(0.2178 0 0);\n    --foreground: oklch(0.8853 0 0);\n    --card: oklch(0.2435 0 0);\n    --muted: oklch(0.31 0 0);\n    --muted-foreground: oklch(0.7058 0 0);\n    --border: oklch(0.34 0 0);\n    --accent: oklch(0.32 0 0);\n  }\n}\nbody {\n  margin: 0;\n  background: var(--background);\n  color: var(--foreground);\n  font-family: var(--font-sans);\n  font-size: 13px;\n}\n.panel {\n  border: 1px solid var(--border);\n  border-radius: var(--radius);\n  background: var(--card);\n}\n</style>\n```\n\nKeep one canonical app for each concept. For manager progress, update the\n`status` app instead of creating parallel views. Use additional apps only when\nthey are distinct tools or dashboards.\n\nRelated guides:\n\n  bb guide overview\n  bb guide managers\n  bb guide manager-templates\n  bb guide async",
     "fileName": "bb-guide-app.md",
     "kind": "instruction",
     "title": "bb Guide - Apps",
diff --git a/packages/templates/src/templates/bb-guide-app.md b/packages/templates/src/templates/bb-guide-app.md
index aa4f9a42b..671bfd3ed 100644
--- a/packages/templates/src/templates/bb-guide-app.md
+++ b/packages/templates/src/templates/bb-guide-app.md
@@ -51,6 +51,11 @@ and do not receive `window.bb`. `capabilities` controls which `window.bb`
 helpers are injected for HTML entries: `data` enables `window.bb.data`, and
 `message` enables `window.bb.message`.
 
+The served app URL is flat: `/api/v1/threads/<thread-id>/apps/<id>/<file>`
+maps to `apps/<id>/assets/<file>` on disk. HTML should use flat relative refs
+like `./index-abc.js`, not `./assets/index-abc.js`. For Vite builds, set
+`build.assetsDir = ""` so emitted files sit alongside `index.html`.
+
 The icon is optional and uses a built-in icon name. Icon resolution order is:
 
 1. `manifest.icon`, when present, as a built-in icon.

From 9215976fb8079eb26b13c35fe42c8bbca1fa3770 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 23:34:27 -0700
Subject: [PATCH 06/13] server: always overlay bundled apps/status
 manager-template seed

seedManagerThreadStorage previously early-returned after copying from
a user-authored manager template, skipping the bundled apps/status
fallback entirely. Fresh managers with any user template on disk would
404 on apps/status because the bundled manifest never got seeded.

Now the bundled set (apps/status/{manifest.json, assets/index.html,
data/state.json}) is always overlaid on top of any user-template copy,
regardless of which template is active. User-authored files still win
because they are copied first and the bundled overlay uses
writeFile(..., flag: "wx") which refuses to overwrite. Missing
non-default templates still warn but no longer skip the seed.

Tests refactored around expectBundledStatusAppSeeded() helper; added
"user-authored files win over the bundled overlay at the same path"
case asserting both behaviors.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../threads/manager-storage-templates.ts      |  48 ++++----
 .../threads/manager-storage-templates.test.ts | 111 ++++++++++++------
 2 files changed, 100 insertions(+), 59 deletions(-)

diff --git a/apps/server/src/services/threads/manager-storage-templates.ts b/apps/server/src/services/threads/manager-storage-templates.ts
index 628c917c0..be1035217 100644
--- a/apps/server/src/services/threads/manager-storage-templates.ts
+++ b/apps/server/src/services/threads/manager-storage-templates.ts
@@ -88,8 +88,11 @@ interface ManagerTemplateSetPathArgs extends ManagerTemplateRootPathArgs {
 
 type CopyTemplateFilesResult = "copied" | "missing";
 
-// Built-in defaults stay in the server bundle. They are copied only as a
-// seed-time fallback when the user has not authored manager-templates/default.
+// Built-in defaults stay in the server bundle. They are always overlaid on top
+// of any user-authored template copy so newly-provisioned threads have a
+// working status surface even if the user's template omits these files.
+// User-authored files win because they are copied first and the overlay uses
+// the `wx` flag, which refuses to overwrite existing destinations.
 const BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET: BuiltInManagerTemplateSet = {
   name: DEFAULT_MANAGER_TEMPLATE_NAME,
   files: [
@@ -289,7 +292,7 @@ async function copyBuiltInTemplateFiles(
       threadId: args.threadId,
       threadStoragePath: args.threadStoragePath,
     },
-    "Seeded manager storage from built-in template fallback",
+    "Overlaid bundled apps/status seed onto manager storage",
   );
 }
 
@@ -316,27 +319,26 @@ export async function seedManagerThreadStorage(
     threadId: args.threadId,
     threadStoragePath: args.threadStoragePath,
   });
-  if (copyResult === "copied") {
-    return;
-  }
 
-  if (templateName === BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET.name) {
-    await copyBuiltInTemplateFiles({
-      files: BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET.files,
-      logger: deps.logger,
-      templateName,
-      threadId: args.threadId,
-      threadStoragePath: args.threadStoragePath,
-    });
-    return;
+  if (
+    copyResult === "missing" &&
+    templateName !== DEFAULT_MANAGER_TEMPLATE_NAME
+  ) {
+    deps.logger.warn(
+      {
+        templateName,
+        templateDirPath,
+        threadId: args.threadId,
+      },
+      "Manager template directory is missing; overlaying bundled seed only",
+    );
   }
 
-  deps.logger.warn(
-    {
-      templateName,
-      templateDirPath,
-      threadId: args.threadId,
-    },
-    "Manager template directory is missing; skipping storage seed",
-  );
+  await copyBuiltInTemplateFiles({
+    files: BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET.files,
+    logger: deps.logger,
+    templateName,
+    threadId: args.threadId,
+    threadStoragePath: args.threadStoragePath,
+  });
 }
diff --git a/apps/server/test/threads/manager-storage-templates.test.ts b/apps/server/test/threads/manager-storage-templates.test.ts
index 2530080fa..1cb817e47 100644
--- a/apps/server/test/threads/manager-storage-templates.test.ts
+++ b/apps/server/test/threads/manager-storage-templates.test.ts
@@ -1,7 +1,6 @@
 import {
   mkdir,
   mkdtemp,
-  readdir,
   readFile,
   rm,
   stat,
@@ -86,6 +85,29 @@ async function readBundledStatusAppFile(relativePath: string): Promise<string> {
   );
 }
 
+async function expectBundledStatusAppSeeded(
+  threadStoragePath: string,
+): Promise<void> {
+  await expect(
+    readFile(
+      path.join(threadStoragePath, "apps/status/manifest.json"),
+      "utf8",
+    ),
+  ).resolves.toBe(await readBundledStatusAppFile("manifest.json"));
+  await expect(
+    readFile(
+      path.join(threadStoragePath, "apps/status/assets/index.html"),
+      "utf8",
+    ),
+  ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
+  await expect(
+    readFile(
+      path.join(threadStoragePath, "apps/status/data/state.json"),
+      "utf8",
+    ),
+  ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
+}
+
 async function writeManagerTemplateSet(
   args: WriteManagerTemplateSetArgs,
 ): Promise<void> {
@@ -157,24 +179,7 @@ describe("manager storage templates", () => {
         threadId: "thr-default-fallback",
       });
 
-      await expect(
-        readFile(
-          path.join(threadStoragePath, "apps/status/manifest.json"),
-          "utf8",
-        ),
-      ).resolves.toBe(await readBundledStatusAppFile("manifest.json"));
-      await expect(
-        readFile(
-          path.join(threadStoragePath, "apps/status/assets/index.html"),
-          "utf8",
-        ),
-      ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
-      await expect(
-        readFile(
-          path.join(threadStoragePath, "apps/status/data/state.json"),
-          "utf8",
-        ),
-      ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
+      await expectBundledStatusAppSeeded(threadStoragePath);
       await expect(
         stat(managerTemplateRootPath({ dataDir })),
       ).rejects.toThrow();
@@ -184,16 +189,14 @@ describe("manager storage templates", () => {
     }
   });
 
-  it("seeds user-authored default files without bundled fallback", async () => {
+  it("overlays the bundled status app on top of user-authored default files", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     try {
       await writeManagerTemplateSet({
         dataDir,
         name: DEFAULT_MANAGER_TEMPLATE_NAME,
         files: {
-          "apps/custom/data/state.json": "{}\n",
-          "apps/custom/manifest.json": "{}\n",
-          "apps/custom/assets/index.html": "<h1>Custom</h1>\n",
+          "USER.md": "user notes\n",
         },
       });
 
@@ -205,25 +208,60 @@ describe("manager storage templates", () => {
         threadId: "thr-user-default",
       });
 
+      await expect(
+        readFile(path.join(threadStoragePath, "USER.md"), "utf8"),
+      ).resolves.toBe("user notes\n");
+      await expectBundledStatusAppSeeded(threadStoragePath);
+    } finally {
+      await harness.cleanup();
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("user-authored files win over the bundled overlay at the same path", async () => {
+    const { dataDir, harness, hostId } = await createSeedHarness();
+    try {
+      await writeManagerTemplateSet({
+        dataDir,
+        name: DEFAULT_MANAGER_TEMPLATE_NAME,
+        files: {
+          "apps/status/manifest.json": '{"user":true}\n',
+        },
+      });
+
+      const threadStoragePath = await seedStorage({
+        dataDir,
+        explicitTemplateName: null,
+        harness,
+        hostId,
+        threadId: "thr-user-overrides",
+      });
+
       await expect(
         readFile(
-          path.join(threadStoragePath, "apps/custom/data/state.json"),
+          path.join(threadStoragePath, "apps/status/manifest.json"),
           "utf8",
         ),
-      ).resolves.toBe("{}\n");
+      ).resolves.toBe('{"user":true}\n');
+      await expect(
+        readFile(
+          path.join(threadStoragePath, "apps/status/assets/index.html"),
+          "utf8",
+        ),
+      ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
       await expect(
         readFile(
-          path.join(threadStoragePath, "apps/custom/assets/index.html"),
+          path.join(threadStoragePath, "apps/status/data/state.json"),
           "utf8",
         ),
-      ).resolves.toBe("<h1>Custom</h1>\n");
+      ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
     }
   });
 
-  it("does not mix bundled files into an existing empty default template directory", async () => {
+  it("overlays the bundled status app even when the default template directory is empty", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     try {
       await writeManagerTemplateSet({
@@ -240,14 +278,14 @@ describe("manager storage templates", () => {
         threadId: "thr-empty-default",
       });
 
-      await expect(readdir(threadStoragePath)).resolves.toEqual([]);
+      await expectBundledStatusAppSeeded(threadStoragePath);
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
     }
   });
 
-  it("warns and skips seeding when active points to a missing non-default template", async () => {
+  it("warns and still overlays bundled status when active points to a missing non-default template", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     const logger = {
       ...testLogger,
@@ -269,13 +307,13 @@ describe("manager storage templates", () => {
         threadId: "thr-missing-active",
       });
 
-      await expect(stat(threadStoragePath)).rejects.toThrow();
+      await expectBundledStatusAppSeeded(threadStoragePath);
       expect(logger.warn).toHaveBeenCalledWith(
         expect.objectContaining({
           templateName: MINE_MANAGER_TEMPLATE_NAME,
           threadId: "thr-missing-active",
         }),
-        "Manager template directory is missing; skipping storage seed",
+        "Manager template directory is missing; overlaying bundled seed only",
       );
     } finally {
       await harness.cleanup();
@@ -283,7 +321,7 @@ describe("manager storage templates", () => {
     }
   });
 
-  it("warns and skips seeding when an explicit non-default template is missing", async () => {
+  it("warns and still overlays bundled status when an explicit non-default template is missing", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     const logger = {
       ...testLogger,
@@ -300,13 +338,13 @@ describe("manager storage templates", () => {
         threadId: "thr-missing-explicit",
       });
 
-      await expect(stat(threadStoragePath)).rejects.toThrow();
+      await expectBundledStatusAppSeeded(threadStoragePath);
       expect(logger.warn).toHaveBeenCalledWith(
         expect.objectContaining({
           templateName: MINE_MANAGER_TEMPLATE_NAME,
           threadId: "thr-missing-explicit",
         }),
-        "Manager template directory is missing; skipping storage seed",
+        "Manager template directory is missing; overlaying bundled seed only",
       );
     } finally {
       await harness.cleanup();
@@ -314,7 +352,7 @@ describe("manager storage templates", () => {
     }
   });
 
-  it("seeds from the active non-default template when that directory exists", async () => {
+  it("seeds from the active non-default template and overlays bundled status when that directory exists", async () => {
     const { dataDir, harness, hostId } = await createSeedHarness();
     try {
       await writeActiveManagerTemplate({
@@ -350,6 +388,7 @@ describe("manager storage templates", () => {
           "utf8",
         ),
       ).resolves.toBe("{}\n");
+      await expectBundledStatusAppSeeded(threadStoragePath);
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });

From dee6d3639e33134ff80ca5300e13c4028fe9ed36 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Wed, 27 May 2026 23:46:21 -0700
Subject: [PATCH 07/13] =?UTF-8?q?app:=20add=20Create=20App=E2=80=A6=20butt?=
 =?UTF-8?q?on=20to=20the=20New=20Tab=20launcher?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Full-width button below the search input in the secondary-panel New
Tab. Clicking it prefills the thread composer's draft via
usePromptDraftStorage.setDraft (text + clears attachments — full
replacement, not just text), focuses the composer with the [NAME]
placeholder selected, and dismisses the New Tab panel.

Replacing a non-empty draft prompts a browser confirm; cancel
preserves the existing draft (text + attachments), accept replaces
both. Reuses the existing prompt-draft store; no parallel state.
Plumbs a stable textareaId from ThreadDetailPromptArea through
FollowUpPromptBox so the button can focus the composer reliably.

Prefill template references `bb guide app`, the apps/<id>/
{manifest.json, assets/index.html, data/state.json} layout, and the
window.bb.data / window.bb.message browser APIs.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../promptbox/FollowUpPromptBox.tsx           |  3 +
 .../secondary-panel/NewTabFileSearch.tsx      | 74 +++++++++++++++-
 .../secondary-panel/NewTabPage.test.tsx       | 84 ++++++++++++++++++-
 .../thread-detail/ThreadDetailPromptArea.tsx  |  4 +
 .../views/thread-detail/ThreadDetailView.tsx  | 33 +++++++-
 5 files changed, 190 insertions(+), 8 deletions(-)

diff --git a/apps/app/src/components/promptbox/FollowUpPromptBox.tsx b/apps/app/src/components/promptbox/FollowUpPromptBox.tsx
index 5518ac894..363bb1013 100644
--- a/apps/app/src/components/promptbox/FollowUpPromptBox.tsx
+++ b/apps/app/src/components/promptbox/FollowUpPromptBox.tsx
@@ -119,6 +119,7 @@ type ContextWindowUsage = ComponentProps<
 >["usage"];
 
 export interface FollowUpPromptBoxProps {
+  id?: string;
   attachments: AttachmentsConfig;
   /**
    * Slot for the stack of context cards above the prompt input — today
@@ -151,6 +152,7 @@ export interface FollowUpPromptBoxProps {
 }
 
 export const FollowUpPromptBox = memo(function FollowUpPromptBox({
+  id,
   attachments,
   stack,
   composer,
@@ -225,6 +227,7 @@ export const FollowUpPromptBox = memo(function FollowUpPromptBox({
           {stack}
         </div>
         <PromptBoxWithScrollAnchor
+          id={id}
           promptBoxRef={promptBoxRef}
           voice={voice}
           minHeight={elasticTextareaMinHeight}
diff --git a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
index 999da636e..b87c327bc 100644
--- a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
@@ -7,6 +7,7 @@ import {
   type KeyboardEvent,
 } from "react";
 import type { ThreadType } from "@bb/domain";
+import { Button } from "@/components/ui/button.js";
 import { Icon } from "@/components/ui/icon.js";
 import { Input } from "@/components/ui/input.js";
 import { TruncateStart } from "@/components/ui/truncate-start.js";
@@ -15,8 +16,26 @@ import {
   useFileSearchSuggestions,
   type FileSearchSuggestion,
 } from "@/hooks/useFileSearchSuggestions";
+import { usePromptDraftStorage } from "@/hooks/usePromptDraftStorage";
 import type { FileSearchSelection } from "./useThreadFileTabs";
 import { cn } from "@/lib/utils";
+import { isPromptDraftEmpty, type PromptDraftState } from "@/lib/prompt-draft";
+
+export const CREATE_APP_PROMPT_TEMPLATE = `Create a new bb app called "[NAME]" that [DESCRIBE WHAT IT SHOULD DO].
+
+Use the bb apps system. Run \`bb guide app\` for the full reference. Layout:
+- apps/<id>/manifest.json — { manifestVersion: 1, id, name, icon | logo.svg, entry, contributions: ["thread.app"], capabilities: ["data"?, "message"?] }
+- apps/<id>/assets/index.html — self-contained inline HTML/CSS/JS/SVG so no build step is needed
+- apps/<id>/data/state.json — initial state if the app uses window.bb.data
+
+In the page, use window.bb.data for live state (read / write / delete / list / onChange; onChange replays + streams) and window.bb.message(text) to send the thread a prompt. Guard with window.bb?.data?.… because capabilities are advisory.
+
+Make the app self-contained and aesthetically polished: design tokens, useful animation only, and accessible UI.`;
+
+const CREATE_APP_PROMPT_DRAFT = {
+  text: CREATE_APP_PROMPT_TEMPLATE,
+  attachments: [],
+} satisfies PromptDraftState;
 
 export interface NewTabFileSearchProps {
   projectId: string | undefined;
@@ -26,6 +45,7 @@ export interface NewTabFileSearchProps {
   focusRequest: number;
   initialQuery?: string;
   onSelect: (selection: FileSearchSelection) => void;
+  onCreateAppPromptPrefill?: CreateAppPromptPrefillHandler;
 }
 
 interface FileSearchResultRowProps {
@@ -61,6 +81,7 @@ interface SplitPathResult {
 type SearchInputKeyDownHandler = (
   event: KeyboardEvent<HTMLInputElement>,
 ) => void;
+type CreateAppPromptPrefillHandler = () => void;
 type FileSearchSource = FileSearchSuggestion["source"];
 type FileSearchSectionKind = "apps" | "files";
 
@@ -286,12 +307,19 @@ export function NewTabFileSearch({
   focusRequest,
   initialQuery = "",
   onSelect,
+  onCreateAppPromptPrefill,
 }: NewTabFileSearchProps) {
   const inputRef = useRef<HTMLInputElement>(null);
   const [query, setQuery] = useState(initialQuery);
   const [activeIndex, setActiveIndex] = useState(-1);
+  const promptDraft = usePromptDraftStorage({
+    projectId,
+    threadId: currentThreadId.length > 0 ? currentThreadId : null,
+  });
   const trimmedQuery = query.trim();
   const hasQuery = trimmedQuery.length > 0;
+  const canPrefillCreateAppPrompt =
+    promptDraft.storageKey !== null && currentThreadId.length > 0;
   const { suggestions, isLoading, isError, isDebouncing, isUnavailable } =
     useFileSearchSuggestions({
       projectId,
@@ -362,6 +390,30 @@ export function NewTabFileSearch({
     [onSelect],
   );
 
+  const handleCreateAppPromptPrefill = useCallback(() => {
+    if (!canPrefillCreateAppPrompt) {
+      return;
+    }
+
+    const currentDraft = promptDraft.getCurrent();
+    if (
+      !isPromptDraftEmpty(currentDraft) &&
+      !window.confirm(
+        "Replace the current composer draft with a Create App prompt?",
+      )
+    ) {
+      return;
+    }
+
+    promptDraft.setDraft(CREATE_APP_PROMPT_DRAFT);
+    onCreateAppPromptPrefill?.();
+  }, [
+    canPrefillCreateAppPrompt,
+    onCreateAppPromptPrefill,
+    promptDraft.getCurrent,
+    promptDraft.setDraft,
+  ]);
+
   const handleInputKeyDown = useCallback<SearchInputKeyDownHandler>(
     (event) => {
       if (visualSuggestions.length === 0) {
@@ -422,6 +474,23 @@ export function NewTabFileSearch({
         ) : null}
       </div>
 
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        className="h-8 w-full justify-start px-2.5 text-xs"
+        disabled={!canPrefillCreateAppPrompt}
+        onClick={handleCreateAppPromptPrefill}
+        title={
+          canPrefillCreateAppPrompt
+            ? "Prefill the composer with a new-app prompt"
+            : "Composer is unavailable"
+        }
+      >
+        <Icon name="Plus" className="size-3.5" aria-hidden />
+        <span>Create App…</span>
+      </Button>
+
       {isUnavailable ? (
         <FileSearchMessage
           iconName="FileQuestion"
@@ -434,10 +503,7 @@ export function NewTabFileSearch({
           className="min-h-0 flex-1 overflow-y-auto pb-1"
         >
           {sections.map((section, sectionIndex) => (
-            <div
-              key={section.kind}
-              className={cn(sectionIndex > 0 && "mt-2")}
-            >
+            <div key={section.kind} className={cn(sectionIndex > 0 && "mt-2")}>
               <div
                 className={cn(
                   "sticky top-0 z-10 bg-background px-2 pb-1 text-xs text-muted-foreground",
diff --git a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
index 976a27434..8f94dce87 100644
--- a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
@@ -3,9 +3,15 @@
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import type { AppSummary, WorkspacePathEntry } from "@bb/server-contract";
 import * as api from "@/lib/api";
+import {
+  parsePromptDraftStorage,
+  serializePromptDraftStorage,
+  type PromptDraftState,
+} from "@/lib/prompt-draft";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createQueryClientTestHarness } from "@/test/queryClientTestHarness";
 import { NewTabPage } from "./NewTabPage";
+import { CREATE_APP_PROMPT_TEMPLATE } from "./NewTabFileSearch";
 import type { FileSearchSelection } from "./useThreadFileTabs";
 
 vi.mock("@/lib/api", async (importOriginal) => {
@@ -35,9 +41,12 @@ interface RenderNewTabPageArgs {
   projectId?: string;
   currentThreadId?: string;
   currentThreadType?: "manager" | "standard";
+  onCreateAppPromptPrefill?: CreateAppPromptPrefillHandler;
   onSelect?: (selection: FileSearchSelection) => void;
 }
 
+type CreateAppPromptPrefillHandler = () => void;
+
 function getPathName(pathValue: string): string {
   return pathValue.split("/").at(-1) ?? pathValue;
 }
@@ -69,6 +78,37 @@ const STATUS_APP: AppSummary = {
   icon: { kind: "builtin", name: "ListTodo" },
 };
 
+const THREAD_DRAFT_STORAGE_KEY = "bb.promptbox.contents-proj-1-thr-standard-3";
+
+const DRAFT_WITH_ATTACHMENT = {
+  text: "Keep this draft",
+  attachments: [
+    {
+      type: "localFile",
+      path: "/tmp/spec.md",
+      name: "spec.md",
+      sizeBytes: 42,
+      mimeType: "text/markdown",
+    },
+  ],
+} satisfies PromptDraftState;
+
+function getStoredThreadDraft(): PromptDraftState {
+  return parsePromptDraftStorage(
+    window.localStorage.getItem(THREAD_DRAFT_STORAGE_KEY),
+  );
+}
+
+function setStoredThreadDraft(draft: PromptDraftState): void {
+  const serialized = serializePromptDraftStorage(draft);
+  if (serialized === null) {
+    window.localStorage.removeItem(THREAD_DRAFT_STORAGE_KEY);
+    return;
+  }
+
+  window.localStorage.setItem(THREAD_DRAFT_STORAGE_KEY, serialized);
+}
+
 function renderNewTabPage(args: RenderNewTabPageArgs = {}) {
   const { wrapper } = createQueryClientTestHarness();
   const onSelect: (selection: FileSearchSelection) => void =
@@ -82,6 +122,7 @@ function renderNewTabPage(args: RenderNewTabPageArgs = {}) {
         currentThreadId={args.currentThreadId ?? "thr-standard"}
         currentThreadType={args.currentThreadType ?? "standard"}
         focusRequest={0}
+        onCreateAppPromptPrefill={args.onCreateAppPromptPrefill}
         onSelect={onSelect}
       />,
       { wrapper },
@@ -91,6 +132,8 @@ function renderNewTabPage(args: RenderNewTabPageArgs = {}) {
 
 afterEach(() => {
   cleanup();
+  window.localStorage.clear();
+  vi.restoreAllMocks();
   vi.clearAllMocks();
 });
 
@@ -117,9 +160,7 @@ describe("NewTabPage", () => {
     expect(await screen.findByText("app.ts")).toBeTruthy();
     expect(await screen.findByText(/src/u)).toBeTruthy();
     expect(screen.queryByText("Manager Storage")).toBeNull();
-    fireEvent.click(
-      await screen.findByRole("option", { name: /app\.ts/u }),
-    );
+    fireEvent.click(await screen.findByRole("option", { name: /app\.ts/u }));
 
     expect(onSelect).toHaveBeenCalledWith({
       source: "workspace",
@@ -143,6 +184,43 @@ describe("NewTabPage", () => {
     });
   });
 
+  it("prefills the composer draft with the create-app prompt", () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
+    renderNewTabPage({ projectId: "proj-1" });
+
+    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+
+    expect(getStoredThreadDraft()).toEqual({
+      text: CREATE_APP_PROMPT_TEMPLATE,
+      attachments: [],
+    });
+  });
+
+  it("leaves a non-empty composer draft unchanged when replacement is canceled", () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
+    vi.spyOn(window, "confirm").mockReturnValue(false);
+    setStoredThreadDraft(DRAFT_WITH_ATTACHMENT);
+    renderNewTabPage({ projectId: "proj-1" });
+
+    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+
+    expect(getStoredThreadDraft()).toEqual(DRAFT_WITH_ATTACHMENT);
+  });
+
+  it("replaces non-empty composer text and attachments after confirmation", () => {
+    vi.mocked(api.listThreadApps).mockResolvedValue([]);
+    vi.spyOn(window, "confirm").mockReturnValue(true);
+    setStoredThreadDraft(DRAFT_WITH_ATTACHMENT);
+    renderNewTabPage({ projectId: "proj-1" });
+
+    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+
+    expect(getStoredThreadDraft()).toEqual({
+      text: CREATE_APP_PROMPT_TEMPLATE,
+      attachments: [],
+    });
+  });
+
   it("selects a manager thread-storage result with the keyboard", async () => {
     vi.mocked(api.listThreadApps).mockResolvedValue([]);
     vi.mocked(api.searchProjectPaths).mockResolvedValue(
diff --git a/apps/app/src/views/thread-detail/ThreadDetailPromptArea.tsx b/apps/app/src/views/thread-detail/ThreadDetailPromptArea.tsx
index b6cdb2498..cc62ced2b 100644
--- a/apps/app/src/views/thread-detail/ThreadDetailPromptArea.tsx
+++ b/apps/app/src/views/thread-detail/ThreadDetailPromptArea.tsx
@@ -65,6 +65,9 @@ type ComposerQueryRefetchOnMount = boolean | "always";
 
 const ignorePromptBannerFileClick = () => {};
 
+export const THREAD_DETAIL_COMPOSER_TEXTAREA_ID =
+  "thread-detail-follow-up-composer";
+
 interface ThreadDetailPromptAreaProps {
   canUseGitUi: boolean;
   composerQueriesEnabled: boolean;
@@ -852,6 +855,7 @@ export function ThreadDetailPromptArea({
 
   return (
     <FollowUpPromptBox
+      id={THREAD_DETAIL_COMPOSER_TEXTAREA_ID}
       attachments={attachmentsConfig}
       stack={promptStack}
       composer={composerConfig}
diff --git a/apps/app/src/views/thread-detail/ThreadDetailView.tsx b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
index 589e94f41..d1642df32 100644
--- a/apps/app/src/views/thread-detail/ThreadDetailView.tsx
+++ b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
@@ -64,7 +64,10 @@ import { getThreadRoutePath } from "@/lib/app-route-paths";
 import { useGitDiffPanel } from "@/components/secondary-panel/git-diff/useGitDiffPanel";
 import { useThreadDetailTurnSummaryRows } from "./turn-summary/useThreadDetailTurnSummaryRows";
 import { ThreadDetailHeader } from "./ThreadDetailHeader";
-import { ThreadDetailPromptArea } from "./ThreadDetailPromptArea";
+import {
+  ThreadDetailPromptArea,
+  THREAD_DETAIL_COMPOSER_TEXTAREA_ID,
+} from "./ThreadDetailPromptArea";
 import {
   type ContextBannerMergeBaseConfig,
   isThreadDisplayStatusBannerActive,
@@ -138,6 +141,28 @@ type MergeBasePickerOpenChangeHandler = NonNullable<
 >;
 type SecondaryPanelChangeHandler = (panel: ThreadSecondaryPanelTab) => void;
 
+function focusThreadDetailComposer(): void {
+  window.requestAnimationFrame(() => {
+    const composer = document.getElementById(
+      THREAD_DETAIL_COMPOSER_TEXTAREA_ID,
+    );
+    if (!(composer instanceof HTMLTextAreaElement)) {
+      return;
+    }
+
+    composer.focus();
+    const namePlaceholderStart = composer.value.indexOf("[NAME]");
+    if (namePlaceholderStart >= 0) {
+      const nameSelectionStart = namePlaceholderStart + 1;
+      const nameSelectionEnd = nameSelectionStart + "NAME".length;
+      composer.setSelectionRange(nameSelectionStart, nameSelectionEnd);
+      return;
+    }
+
+    composer.setSelectionRange(0, 0);
+  });
+}
+
 function buildHostConnectionNotice(
   thread: ThreadWithRuntime,
 ): HostConnectionNotice | null {
@@ -481,6 +506,11 @@ export function ThreadDetailView() {
     openNewTab();
     setNewTabFocusRequest((current) => current + 1);
   }, [openNewTab]);
+  const handleCreateAppPromptPrefill = useCallback(() => {
+    closeNewTab();
+    closeSecondaryPanel();
+    focusThreadDetailComposer();
+  }, [closeNewTab, closeSecondaryPanel]);
   const handleTerminalPanelResize = useCallback(
     (sizePercent: number) => {
       const panelHeightPercent = Math.round(sizePercent);
@@ -1121,6 +1151,7 @@ export function ThreadDetailView() {
       currentThreadId={thread.id}
       currentThreadType={thread.type}
       focusRequest={newTabFocusRequest}
+      onCreateAppPromptPrefill={handleCreateAppPromptPrefill}
       onSelect={selectFileSearchResult}
     />
   ) : activeAppId ? (

From d4ba3d78fb220c310b8268c85ab756c4f6010c25 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 08:48:06 -0700
Subject: [PATCH 08/13] app: polish New Tab launcher and rework Create App
 prompt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Visual: bigger app rows with rounded tile-style icon container, name
+ id caption, uppercase tracking-wider section headers ("APPS",
"FILES"), token-driven hover/active/focus states that work in dark
mode. Create App moves from a full-width outline button below the
search to a dotted "+ Create App" tile at the end of the Apps list,
mirroring app rows with a "Describe an idea, the manager builds it"
hint line. The Apps section now always renders so the tile is
reachable immediately on open.

Prompt: prefilled template drops the [NAME] / [DESCRIBE…] placeholders
in favor of an end-of-text cursor landing. All apps-system context
lives at the top (manifest layout, window.bb usage), with a single
line pointing at `bb app new` for default styling, and a trailing
`What I want:` blank line where the user starts typing. Composer
cursor parks at end of text — no placeholder hunt.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../secondary-panel/NewTabFileSearch.tsx      | 391 ++++++++++++------
 .../secondary-panel/NewTabPage.test.tsx       |  16 +-
 .../views/thread-detail/ThreadDetailView.tsx  |  11 +-
 3 files changed, 289 insertions(+), 129 deletions(-)

diff --git a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
index b87c327bc..99dee3125 100644
--- a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
@@ -7,13 +7,14 @@ import {
   type KeyboardEvent,
 } from "react";
 import type { ThreadType } from "@bb/domain";
-import { Button } from "@/components/ui/button.js";
 import { Icon } from "@/components/ui/icon.js";
 import { Input } from "@/components/ui/input.js";
 import { TruncateStart } from "@/components/ui/truncate-start.js";
 import { ResolvedAppIcon } from "./AppIcon";
 import {
   useFileSearchSuggestions,
+  type AppSearchSuggestion,
+  type FilePathSearchSuggestion,
   type FileSearchSuggestion,
 } from "@/hooks/useFileSearchSuggestions";
 import { usePromptDraftStorage } from "@/hooks/usePromptDraftStorage";
@@ -21,16 +22,20 @@ import type { FileSearchSelection } from "./useThreadFileTabs";
 import { cn } from "@/lib/utils";
 import { isPromptDraftEmpty, type PromptDraftState } from "@/lib/prompt-draft";
 
-export const CREATE_APP_PROMPT_TEMPLATE = `Create a new bb app called "[NAME]" that [DESCRIBE WHAT IT SHOULD DO].
+export const CREATE_APP_PROMPT_TEMPLATE = `You are creating a new bb app for this thread.
 
-Use the bb apps system. Run \`bb guide app\` for the full reference. Layout:
+Apps system reference — run \`bb guide app\` for full detail. Layout:
 - apps/<id>/manifest.json — { manifestVersion: 1, id, name, icon | logo.svg, entry, contributions: ["thread.app"], capabilities: ["data"?, "message"?] }
-- apps/<id>/assets/index.html — self-contained inline HTML/CSS/JS/SVG so no build step is needed
+- apps/<id>/assets/index.html — self-contained inline HTML/CSS/JS/SVG (no build step needed)
 - apps/<id>/data/state.json — initial state if the app uses window.bb.data
 
-In the page, use window.bb.data for live state (read / write / delete / list / onChange; onChange replays + streams) and window.bb.message(text) to send the thread a prompt. Guard with window.bb?.data?.… because capabilities are advisory.
+In the page, use window.bb.data for live state (read / write / delete / list / onChange; onChange replays + streams) and window.bb.message(text) to send the thread a prompt. Guard with \`window.bb?.data?.…\` since capabilities are advisory.
 
-Make the app self-contained and aesthetically polished: design tokens, useful animation only, and accessible UI.`;
+Scaffold with \`bb app new\` — the default styling is wired up already, so build on top of it and keep the UI polished, accessible, and dense like the rest of bb.
+
+What I want:
+
+`;
 
 const CREATE_APP_PROMPT_DRAFT = {
   text: CREATE_APP_PROMPT_TEMPLATE,
@@ -48,12 +53,20 @@ export interface NewTabFileSearchProps {
   onCreateAppPromptPrefill?: CreateAppPromptPrefillHandler;
 }
 
-interface FileSearchResultRowProps {
+interface AppResultRowProps {
   id: string;
-  suggestion: FileSearchSuggestion;
+  suggestion: AppSearchSuggestion;
+  isActive: boolean;
+  onActivate: () => void;
+  onSelect: (suggestion: AppSearchSuggestion) => void;
+}
+
+interface FileResultRowProps {
+  id: string;
+  suggestion: FilePathSearchSuggestion;
   isActive: boolean;
   onActivate: () => void;
-  onSelect: (suggestion: FileSearchSuggestion) => void;
+  onSelect: (suggestion: FilePathSearchSuggestion) => void;
 }
 
 interface FileSearchMessageProps {
@@ -96,6 +109,11 @@ interface GroupFileSearchSectionsArgs {
   availableSources: readonly FileSearchSource[];
 }
 
+interface CreateAppTileProps {
+  disabled: boolean;
+  onClick: () => void;
+}
+
 const FILE_SEARCH_LIMIT = 20;
 const FILE_SEARCH_SECTION_ORDER: readonly FileSearchSectionKind[] = [
   "apps",
@@ -113,6 +131,11 @@ const FILE_SEARCH_SOURCE_LABELS = {
   "thread-storage": "Manager Storage",
 } satisfies Record<FileSearchSource, string>;
 
+const SECTION_HEADER_CLASS =
+  "sticky top-0 z-10 bg-background px-1 pb-2 text-xs font-medium uppercase tracking-wider text-subtle-foreground";
+const LAUNCHER_TILE_BASE_CLASS =
+  "group flex w-full min-w-0 items-center gap-3 rounded-md px-2 py-2 text-left transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring";
+
 function getAvailableFileSearchSources({
   projectId,
   currentThreadId,
@@ -226,45 +249,96 @@ function FileSearchMessage({
   );
 }
 
-function FileSearchResultRow({
+function AppResultRow({
   id,
   suggestion,
   isActive,
   onActivate,
   onSelect,
-}: FileSearchResultRowProps) {
+}: AppResultRowProps) {
   const handleSelect = useCallback(() => {
     onSelect(suggestion);
   }, [onSelect, suggestion]);
+  const showAppId = suggestion.appId !== suggestion.name;
 
-  if (suggestion.entryKind === "app") {
-    return (
-      <button
-        type="button"
-        id={id}
-        role="option"
-        aria-selected={isActive}
-        onClick={handleSelect}
-        onMouseEnter={onActivate}
-        title={getFileSearchResultTitle(suggestion)}
-        className={cn(
-          "w-full scroll-mt-7 rounded px-2 py-1.5 text-left text-xs transition-colors",
-          isActive ? "bg-state-active" : "hover:bg-state-hover",
-        )}
-      >
-        <div className="flex min-w-0 items-center gap-1.5">
-          <ResolvedAppIcon icon={suggestion.app.icon} className="size-3.5" />
-          <span className="truncate">{suggestion.name}</span>
-          {suggestion.appId !== suggestion.name ? (
-            <TruncateStart className="text-muted-foreground [flex-shrink:9999]">
-              {suggestion.appId}
-            </TruncateStart>
-          ) : null}
-        </div>
-      </button>
-    );
-  }
+  return (
+    <button
+      type="button"
+      id={id}
+      role="option"
+      aria-selected={isActive}
+      onClick={handleSelect}
+      onMouseEnter={onActivate}
+      title={getFileSearchResultTitle(suggestion)}
+      className={cn(
+        LAUNCHER_TILE_BASE_CLASS,
+        "scroll-mt-7",
+        isActive ? "bg-state-active" : "hover:bg-state-hover",
+      )}
+    >
+      <span className="flex size-9 shrink-0 items-center justify-center overflow-hidden rounded-md border border-border-hairline bg-surface-raised">
+        <ResolvedAppIcon
+          icon={suggestion.app.icon}
+          className="size-5 text-foreground"
+        />
+      </span>
+      <span className="flex min-w-0 flex-1 flex-col">
+        <span className="truncate text-sm font-medium text-foreground">
+          {suggestion.name}
+        </span>
+        {showAppId ? (
+          <span className="truncate text-xs text-muted-foreground">
+            {suggestion.appId}
+          </span>
+        ) : null}
+      </span>
+    </button>
+  );
+}
+
+function CreateAppTile({ disabled, onClick }: CreateAppTileProps) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      title={
+        disabled
+          ? "Composer is unavailable"
+          : "Prefill the composer with a new-app prompt"
+      }
+      className={cn(
+        LAUNCHER_TILE_BASE_CLASS,
+        "border border-dashed border-border text-muted-foreground",
+        "hover:border-border-hairline hover:bg-state-hover hover:text-foreground",
+        "disabled:pointer-events-none disabled:opacity-50",
+      )}
+    >
+      <span className="flex size-9 shrink-0 items-center justify-center rounded-md border border-dashed border-border bg-surface-raised text-muted-foreground group-hover:text-foreground">
+        <Icon name="Plus" className="size-4" aria-hidden />
+      </span>
+      <span className="flex min-w-0 flex-1 flex-col">
+        <span className="truncate text-sm font-medium text-foreground">
+          Create App…
+        </span>
+        <span className="truncate text-xs text-muted-foreground">
+          Describe an idea, the manager builds it
+        </span>
+      </span>
+    </button>
+  );
+}
 
+function FileResultRow({
+  id,
+  suggestion,
+  isActive,
+  onActivate,
+  onSelect,
+}: FileResultRowProps) {
+  const handleSelect = useCallback(() => {
+    onSelect(suggestion);
+  }, [onSelect, suggestion]);
   const { directory } = splitPath(suggestion.path);
   const secondaryDirectory = directory || null;
 
@@ -278,7 +352,7 @@ function FileSearchResultRow({
       onMouseEnter={onActivate}
       title={getFileSearchResultTitle(suggestion)}
       className={cn(
-        "w-full scroll-mt-7 rounded px-2 py-1.5 text-left text-xs transition-colors",
+        "w-full scroll-mt-7 rounded px-2 py-1.5 text-left text-xs transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
         isActive ? "bg-state-active" : "hover:bg-state-hover",
       )}
     >
@@ -342,6 +416,11 @@ export function NewTabFileSearch({
     () => groupFileSearchSections({ availableSources, suggestions }),
     [availableSources, suggestions],
   );
+  const hasAppsSection = sections.some((section) => section.kind === "apps");
+  const showAppsSectionShell =
+    !isUnavailable &&
+    canPrefillCreateAppPrompt &&
+    (!hasQuery || hasAppsSection);
   const visualSuggestions = useMemo(
     () =>
       sections.flatMap((section) =>
@@ -372,22 +451,29 @@ export function NewTabFileSearch({
     setActiveIndex(visualSuggestions.length > 0 ? 0 : -1);
   }, [visualSuggestions]);
 
+  const handleAppSelect = useCallback(
+    (suggestion: AppSearchSuggestion) => {
+      onSelect({ source: "app", appId: suggestion.appId });
+    },
+    [onSelect],
+  );
+
+  const handleFileSelect = useCallback(
+    (suggestion: FilePathSearchSuggestion) => {
+      onSelect({ source: suggestion.source, path: suggestion.path });
+    },
+    [onSelect],
+  );
+
   const handleSuggestionSelect = useCallback(
     (suggestion: FileSearchSuggestion) => {
       if (suggestion.entryKind === "app") {
-        onSelect({
-          source: "app",
-          appId: suggestion.appId,
-        });
+        handleAppSelect(suggestion);
         return;
       }
-
-      onSelect({
-        source: suggestion.source,
-        path: suggestion.path,
-      });
+      handleFileSelect(suggestion);
     },
-    [onSelect],
+    [handleAppSelect, handleFileSelect],
   );
 
   const handleCreateAppPromptPrefill = useCallback(() => {
@@ -443,7 +529,7 @@ export function NewTabFileSearch({
   );
 
   return (
-    <div className="flex min-h-0 flex-1 flex-col gap-2">
+    <div className="flex min-h-0 flex-1 flex-col gap-3">
       <div className="relative">
         <Icon
           name="Search"
@@ -474,84 +560,155 @@ export function NewTabFileSearch({
         ) : null}
       </div>
 
-      <Button
-        type="button"
-        variant="outline"
-        size="sm"
-        className="h-8 w-full justify-start px-2.5 text-xs"
-        disabled={!canPrefillCreateAppPrompt}
-        onClick={handleCreateAppPromptPrefill}
-        title={
-          canPrefillCreateAppPrompt
-            ? "Prefill the composer with a new-app prompt"
-            : "Composer is unavailable"
-        }
-      >
-        <Icon name="Plus" className="size-3.5" aria-hidden />
-        <span>Create App…</span>
-      </Button>
-
       {isUnavailable ? (
         <FileSearchMessage
           iconName="FileQuestion"
           message="No searchable app or file source is available."
         />
-      ) : sections.length > 0 ? (
-        <div
-          role="listbox"
-          aria-label="App and file search results"
-          className="min-h-0 flex-1 overflow-y-auto pb-1"
-        >
-          {sections.map((section, sectionIndex) => (
-            <div key={section.kind} className={cn(sectionIndex > 0 && "mt-2")}>
-              <div
-                className={cn(
-                  "sticky top-0 z-10 bg-background px-2 pb-1 text-xs text-muted-foreground",
-                  sectionIndex === 0 ? "pt-0" : "pt-1.5",
-                )}
-              >
-                {section.label}
-              </div>
-              <div className="flex flex-col gap-px">
-                {section.items.map(({ suggestion, index }) => (
-                  <FileSearchResultRow
-                    key={`${suggestion.source}:${
-                      suggestion.entryKind === "app"
-                        ? suggestion.appId
-                        : suggestion.path
-                    }`}
+      ) : (
+        <NewTabResults
+          activeIndex={activeIndex}
+          canCreateApp={canPrefillCreateAppPrompt}
+          hasQuery={hasQuery}
+          isError={isError}
+          isLoading={isLoading}
+          onActivateIndex={setActiveIndex}
+          onAppSelect={handleAppSelect}
+          onCreateApp={handleCreateAppPromptPrefill}
+          onFileSelect={handleFileSelect}
+          sections={sections}
+          showAppsSectionShell={showAppsSectionShell}
+        />
+      )}
+    </div>
+  );
+}
+
+interface NewTabResultsProps {
+  activeIndex: number;
+  canCreateApp: boolean;
+  hasQuery: boolean;
+  isError: boolean;
+  isLoading: boolean;
+  onActivateIndex: (index: number) => void;
+  onAppSelect: (suggestion: AppSearchSuggestion) => void;
+  onCreateApp: () => void;
+  onFileSelect: (suggestion: FilePathSearchSuggestion) => void;
+  sections: readonly FileSearchSection[];
+  showAppsSectionShell: boolean;
+}
+
+function NewTabResults({
+  activeIndex,
+  canCreateApp,
+  hasQuery,
+  isError,
+  isLoading,
+  onActivateIndex,
+  onAppSelect,
+  onCreateApp,
+  onFileSelect,
+  sections,
+  showAppsSectionShell,
+}: NewTabResultsProps) {
+  const appsSection = sections.find((section) => section.kind === "apps");
+  const filesSection = sections.find((section) => section.kind === "files");
+  const showAppsSection = showAppsSectionShell || appsSection !== undefined;
+  const showFilesSection = filesSection !== undefined;
+  const showLoading = isLoading && !showFilesSection;
+  const showError = isError && !showFilesSection && !showLoading;
+  const showEmptyMessage =
+    !showAppsSection && !showFilesSection && !showLoading && !showError;
+
+  if (showEmptyMessage) {
+    return (
+      <FileSearchMessage
+        iconName={hasQuery ? "FileQuestion" : "File"}
+        message={
+          hasQuery
+            ? "No apps or files match."
+            : "Type to search apps and files."
+        }
+      />
+    );
+  }
+
+  return (
+    <div className="min-h-0 flex-1 overflow-y-auto pb-1">
+      {showAppsSection ? (
+        <section>
+          <div className={cn(SECTION_HEADER_CLASS, "pt-0")}>
+            {FILE_SEARCH_SECTION_LABELS.apps}
+          </div>
+          {appsSection && appsSection.items.length > 0 ? (
+            <div
+              role="listbox"
+              aria-label={FILE_SEARCH_SECTION_LABELS.apps}
+              className="flex flex-col gap-px"
+            >
+              {appsSection.items.map(({ suggestion, index }) =>
+                suggestion.entryKind === "app" ? (
+                  <AppResultRow
+                    key={`app:${suggestion.appId}`}
                     id={getFileSearchResultId(suggestion)}
                     suggestion={suggestion}
                     isActive={index === activeIndex}
-                    onActivate={() => setActiveIndex(index)}
-                    onSelect={handleSuggestionSelect}
+                    onActivate={() => onActivateIndex(index)}
+                    onSelect={onAppSelect}
                   />
-                ))}
-              </div>
+                ) : null,
+              )}
+            </div>
+          ) : null}
+          {canCreateApp ? (
+            <div
+              className={cn(
+                appsSection && appsSection.items.length > 0 && "mt-px",
+              )}
+            >
+              <CreateAppTile disabled={false} onClick={onCreateApp} />
             </div>
-          ))}
+          ) : null}
+        </section>
+      ) : null}
+
+      {showFilesSection && filesSection ? (
+        <section className={cn(showAppsSection && "mt-3")}>
+          <div className={cn(SECTION_HEADER_CLASS, showAppsSection && "pt-2")}>
+            {FILE_SEARCH_SECTION_LABELS.files}
+          </div>
+          <div
+            role="listbox"
+            aria-label={FILE_SEARCH_SECTION_LABELS.files}
+            className="flex flex-col gap-px"
+          >
+            {filesSection.items.map(({ suggestion, index }) =>
+              suggestion.entryKind === "file" ? (
+                <FileResultRow
+                  key={`${suggestion.source}:${suggestion.path}`}
+                  id={getFileSearchResultId(suggestion)}
+                  suggestion={suggestion}
+                  isActive={index === activeIndex}
+                  onActivate={() => onActivateIndex(index)}
+                  onSelect={onFileSelect}
+                />
+              ) : null,
+            )}
+          </div>
+        </section>
+      ) : showLoading || showError ? (
+        <div className={cn(showAppsSection && "mt-3")}>
+          <FileSearchMessage
+            iconName={showError ? "AlertCircle" : "Spinner"}
+            iconClassName={showLoading ? "animate-spin" : undefined}
+            message={
+              showError
+                ? "App and file search failed."
+                : "Searching apps and files..."
+            }
+          />
         </div>
-      ) : isError ? (
-        <FileSearchMessage
-          iconName="AlertCircle"
-          message="App and file search failed."
-        />
-      ) : isLoading ? (
-        <FileSearchMessage
-          iconName="Spinner"
-          iconClassName="animate-spin"
-          message="Searching apps and files..."
-        />
-      ) : (
-        <FileSearchMessage
-          iconName={hasQuery ? "FileQuestion" : "File"}
-          message={
-            hasQuery
-              ? "No apps or files match."
-              : "Type to search apps and files."
-          }
-        />
-      )}
+      ) : null}
     </div>
   );
 }
diff --git a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
index 8f94dce87..875cfd1de 100644
--- a/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabPage.test.tsx
@@ -188,7 +188,7 @@ describe("NewTabPage", () => {
     vi.mocked(api.listThreadApps).mockResolvedValue([]);
     renderNewTabPage({ projectId: "proj-1" });
 
-    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+    fireEvent.click(screen.getByRole("button", { name: /Create App/u }));
 
     expect(getStoredThreadDraft()).toEqual({
       text: CREATE_APP_PROMPT_TEMPLATE,
@@ -196,13 +196,23 @@ describe("NewTabPage", () => {
     });
   });
 
+  it("structures the create-app prompt with no placeholders and ends ready for the user", () => {
+    expect(CREATE_APP_PROMPT_TEMPLATE).not.toMatch(/\[NAME\]/u);
+    expect(CREATE_APP_PROMPT_TEMPLATE).not.toMatch(
+      /\[DESCRIBE WHAT IT SHOULD DO\]/u,
+    );
+    expect(CREATE_APP_PROMPT_TEMPLATE).toContain("bb guide app");
+    expect(CREATE_APP_PROMPT_TEMPLATE).toContain("window.bb.data");
+    expect(CREATE_APP_PROMPT_TEMPLATE.endsWith("What I want:\n\n")).toBe(true);
+  });
+
   it("leaves a non-empty composer draft unchanged when replacement is canceled", () => {
     vi.mocked(api.listThreadApps).mockResolvedValue([]);
     vi.spyOn(window, "confirm").mockReturnValue(false);
     setStoredThreadDraft(DRAFT_WITH_ATTACHMENT);
     renderNewTabPage({ projectId: "proj-1" });
 
-    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+    fireEvent.click(screen.getByRole("button", { name: /Create App/u }));
 
     expect(getStoredThreadDraft()).toEqual(DRAFT_WITH_ATTACHMENT);
   });
@@ -213,7 +223,7 @@ describe("NewTabPage", () => {
     setStoredThreadDraft(DRAFT_WITH_ATTACHMENT);
     renderNewTabPage({ projectId: "proj-1" });
 
-    fireEvent.click(screen.getByRole("button", { name: "Create App…" }));
+    fireEvent.click(screen.getByRole("button", { name: /Create App/u }));
 
     expect(getStoredThreadDraft()).toEqual({
       text: CREATE_APP_PROMPT_TEMPLATE,
diff --git a/apps/app/src/views/thread-detail/ThreadDetailView.tsx b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
index d1642df32..cf792954c 100644
--- a/apps/app/src/views/thread-detail/ThreadDetailView.tsx
+++ b/apps/app/src/views/thread-detail/ThreadDetailView.tsx
@@ -151,15 +151,8 @@ function focusThreadDetailComposer(): void {
     }
 
     composer.focus();
-    const namePlaceholderStart = composer.value.indexOf("[NAME]");
-    if (namePlaceholderStart >= 0) {
-      const nameSelectionStart = namePlaceholderStart + 1;
-      const nameSelectionEnd = nameSelectionStart + "NAME".length;
-      composer.setSelectionRange(nameSelectionStart, nameSelectionEnd);
-      return;
-    }
-
-    composer.setSelectionRange(0, 0);
+    const cursor = composer.value.length;
+    composer.setSelectionRange(cursor, cursor);
   });
 }
 

From e981e6435c0f4fca6caef37b057f722fdd0d924d Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 10:50:09 -0700
Subject: [PATCH 09/13] server(apps): bb-styled blank scaffold for `bb app new`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The blank template now scaffolds a bb-native HTML surface instead of
a barebones one-line demo. New apps get the bb default styling head
verbatim from `bb guide styling` (Google Fonts links for Inter +
Fira Code, the full `:root` oklch token block, dark-mode overrides,
body / .panel defaults), with scaffold-only classes (header chip,
title, timestamp slot, section title, task-list rows, pills) layered
strictly after the guide block. Visual structure mirrors the status
task-list dashboard at a stripped-down plain-HTML scale, with a
placeholder line — "Ask your agent to customize the status app how
you please." — inviting the user to ask their agent to build on top.

Name interpolation goes through a shared escapeHtmlText helper now
extracted into @bb/domain and reused from the previous module-local
copies in apps/desktop (local-view, log-viewer). XSS test covers
`<script>`, `&`, `"`, and `'` in the app name.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 apps/desktop/package.json                     |   1 +
 apps/desktop/src/local-view.ts                |  29 +-
 apps/desktop/src/log-viewer.ts                |  25 +-
 apps/server/src/routes/threads/apps.ts        | 230 +++++++++++++--
 .../test/public/public-thread-apps.test.ts    | 265 ++++++++++++++++++
 packages/domain/src/html-escape.ts            |  14 +
 packages/domain/src/index.ts                  |   2 +
 pnpm-lock.yaml                                |   3 +
 8 files changed, 507 insertions(+), 62 deletions(-)
 create mode 100644 packages/domain/src/html-escape.ts

diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index a9a86c50b..fcc0b8e13 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "@bb/config": "workspace:*",
+    "@bb/domain": "workspace:*",
     "@bb/server-contract": "workspace:*",
     "@bb/tsconfig": "workspace:*",
     "@types/node": "^24.9.0",
diff --git a/apps/desktop/src/local-view.ts b/apps/desktop/src/local-view.ts
index 253c80107..6143957e3 100644
--- a/apps/desktop/src/local-view.ts
+++ b/apps/desktop/src/local-view.ts
@@ -1,4 +1,5 @@
 import { stripVTControlCharacters } from "node:util";
+import { escapeHtmlText } from "@bb/domain";
 
 export type LocalViewModel = LoadingViewModel | StartupErrorViewModel;
 
@@ -19,24 +20,6 @@ export interface CreateLocalViewUrlArgs {
   viewModel: LocalViewModel;
 }
 
-function escapeHtml(value: string): string {
-  return value.replace(/[&<>"']/gu, (character) => {
-    if (character === "&") {
-      return "&amp;";
-    }
-    if (character === "<") {
-      return "&lt;";
-    }
-    if (character === ">") {
-      return "&gt;";
-    }
-    if (character === '"') {
-      return "&quot;";
-    }
-    return "&#39;";
-  });
-}
-
 function formatPlainLogText(value: string): string {
   return stripVTControlCharacters(value).replace(/\r\n?/gu, "\n");
 }
@@ -45,8 +28,8 @@ function renderLoadingView(viewModel: LoadingViewModel): string {
   return `
     <main class="shell">
       <div class="spinner"></div>
-      <h1>${escapeHtml(viewModel.title)}</h1>
-      <p>${escapeHtml(viewModel.message)}</p>
+      <h1>${escapeHtmlText(viewModel.title)}</h1>
+      <p>${escapeHtmlText(viewModel.message)}</p>
     </main>
   `;
 }
@@ -54,11 +37,11 @@ function renderLoadingView(viewModel: LoadingViewModel): string {
 function renderErrorView(viewModel: StartupErrorViewModel): string {
   const logText = formatPlainLogText(viewModel.logText);
   const logs =
-    logText.trim().length > 0 ? `<pre>${escapeHtml(logText)}</pre>` : "";
+    logText.trim().length > 0 ? `<pre>${escapeHtmlText(logText)}</pre>` : "";
   return `
     <main class="shell shell-error">
-      <h1>${escapeHtml(viewModel.title)}</h1>
-      <p>${escapeHtml(viewModel.details)}</p>
+      <h1>${escapeHtmlText(viewModel.title)}</h1>
+      <p>${escapeHtmlText(viewModel.details)}</p>
       ${logs}
     </main>
   `;
diff --git a/apps/desktop/src/log-viewer.ts b/apps/desktop/src/log-viewer.ts
index 9fb526fb1..5e397c39d 100644
--- a/apps/desktop/src/log-viewer.ts
+++ b/apps/desktop/src/log-viewer.ts
@@ -2,6 +2,7 @@ import { spawn, type ChildProcess } from "node:child_process";
 import { mkdir, readdir, stat } from "node:fs/promises";
 import { watch, type FSWatcher } from "node:fs";
 import { join } from "node:path";
+import { escapeHtmlText } from "@bb/domain";
 import {
   LOG_VIEWER_VISIBLE_LINE_LIMIT,
   type LogViewerComponent,
@@ -50,10 +51,6 @@ export interface LogLineBuffer {
   stop(): void;
 }
 
-interface EscapeHtmlArgs {
-  value: string;
-}
-
 interface ParseLogFileCandidateArgs {
   component: LogViewerComponent;
   fileName: string;
@@ -114,24 +111,6 @@ interface LogLineBufferState {
   visibleLines: LogViewerLine[];
 }
 
-function escapeHtml(args: EscapeHtmlArgs): string {
-  return args.value.replace(/[&<>"']/gu, (character) => {
-    if (character === "&") {
-      return "&amp;";
-    }
-    if (character === "<") {
-      return "&lt;";
-    }
-    if (character === ">") {
-      return "&gt;";
-    }
-    if (character === '"') {
-      return "&quot;";
-    }
-    return "&#39;";
-  });
-}
-
 export function createLogLineBuffer(
   args: CreateLogLineBufferArgs,
 ): LogLineBuffer {
@@ -210,7 +189,7 @@ export function createLogLineBuffer(
 }
 
 export function createLogViewerViewUrl(args: CreateLogViewerViewUrlArgs): string {
-  const escapedLogDir = escapeHtml({ value: args.logDir });
+  const escapedLogDir = escapeHtmlText(args.logDir);
   const html = `<!doctype html>
 <html>
 <head>
diff --git a/apps/server/src/routes/threads/apps.ts b/apps/server/src/routes/threads/apps.ts
index 93af88e16..2f5432a5c 100644
--- a/apps/server/src/routes/threads/apps.ts
+++ b/apps/server/src/routes/threads/apps.ts
@@ -10,7 +10,12 @@ import {
   type HostDaemonCommand,
   type HostDaemonCommandResult,
 } from "@bb/host-daemon-contract";
-import { appDataPathSchema, appIdSchema, jsonValueSchema } from "@bb/domain";
+import {
+  appDataPathSchema,
+  appIdSchema,
+  escapeHtmlText,
+  jsonValueSchema,
+} from "@bb/domain";
 import type { AppDataPath, AppId, JsonValue } from "@bb/domain";
 import {
   appDataListQuerySchema,
@@ -171,6 +176,210 @@ const LOGO_MAX_BYTES = 1024 * 1024;
 const LOGO_EXTENSIONS = ["svg", "png", "jpg", "jpeg"] as const;
 const APP_ROUTE_DATA_SEGMENT = "/data/";
 
+const BLANK_APP_NAME_PLACEHOLDER = "__BB_APP_NAME__";
+
+// First <style> block: the bb default styling head copied verbatim from
+// `bb guide styling` (packages/templates/src/templates/bb-guide-app.md). Keep
+// this in sync with that guide so the scaffold and the documented tokens never
+// drift.
+const BB_DEFAULT_STYLING_HEAD = `<script src="https://cdn.tailwindcss.com"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
+    <style>
+    :root {
+      color-scheme: light;
+      --background: oklch(0.9551 0 0);
+      --foreground: oklch(0.3211 0 0);
+      --card: oklch(0.9702 0 0);
+      --muted: oklch(0.8853 0 0);
+      --muted-foreground: oklch(0.5103 0 0);
+      --border: oklch(0.8576 0 0);
+      --accent: oklch(0.9 0 0);
+      --success: oklch(0.7 0.15 155);
+      --warning: oklch(0.7 0.16 50);
+      --destructive: oklch(0.5594 0.19 25.8625);
+      --radius: 0.5rem;
+      --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
+      --font-mono: "Fira Code", ui-monospace, SFMono-Regular, monospace;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        color-scheme: dark;
+        --background: oklch(0.2178 0 0);
+        --foreground: oklch(0.8853 0 0);
+        --card: oklch(0.2435 0 0);
+        --muted: oklch(0.31 0 0);
+        --muted-foreground: oklch(0.7058 0 0);
+        --border: oklch(0.34 0 0);
+        --accent: oklch(0.32 0 0);
+      }
+    }
+    body {
+      margin: 0;
+      background: var(--background);
+      color: var(--foreground);
+      font-family: var(--font-sans);
+      font-size: 13px;
+    }
+    .panel {
+      border: 1px solid var(--border);
+      border-radius: var(--radius);
+      background: var(--card);
+    }
+    </style>`;
+
+// Second <style> block: scaffold-only classes layered on top of the guide
+// tokens. Keep this strictly additive; do not redefine variables or guide
+// classes here.
+const BLANK_APP_SCAFFOLD_EXTRA_STYLES = `<style>
+      * { box-sizing: border-box; }
+      body {
+        padding: 16px 16px 20px;
+        line-height: 1.45;
+        -webkit-font-smoothing: antialiased;
+      }
+      .panel { padding: 14px 16px; }
+      .header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding-bottom: 10px;
+        border-bottom: 1px solid var(--border);
+        margin-bottom: 16px;
+      }
+      .brand {
+        width: 20px;
+        height: 20px;
+        border: 1px solid var(--border);
+        background: var(--card);
+        border-radius: calc(var(--radius) - 4px);
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        font-family: var(--font-mono);
+        font-weight: 500;
+        font-size: 10px;
+      }
+      .title {
+        font-size: 13px;
+        font-weight: 600;
+        flex: 1;
+        min-width: 0;
+        letter-spacing: -0.005em;
+      }
+      .ts {
+        font-family: var(--font-mono);
+        font-size: 10px;
+        color: var(--muted-foreground);
+      }
+      .placeholder {
+        margin: 0 0 14px;
+        color: var(--muted-foreground);
+        font-size: 13px;
+      }
+      .section { margin-top: 14px; }
+      .sect-ttl {
+        font-size: 10.5px;
+        font-weight: 600;
+        letter-spacing: 0.06em;
+        text-transform: uppercase;
+        color: var(--muted-foreground);
+        margin-bottom: 8px;
+      }
+      .row {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 9px 12px;
+        background: var(--card);
+        border: 1px solid var(--border);
+        border-radius: var(--radius);
+      }
+      .row + .row { margin-top: 6px; }
+      .label {
+        font-family: var(--font-mono);
+        font-size: 10.5px;
+        color: var(--muted-foreground);
+        white-space: nowrap;
+      }
+      .name {
+        flex: 1;
+        min-width: 0;
+        font-size: 13px;
+        font-weight: 500;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+      .pill {
+        display: inline-flex;
+        align-items: center;
+        font-family: var(--font-mono);
+        font-size: 9.5px;
+        font-weight: 500;
+        line-height: 1;
+        padding: 3px 7px;
+        border-radius: 999px;
+        border: 1px solid var(--border);
+        background: var(--background);
+        color: var(--muted-foreground);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        white-space: nowrap;
+        flex-shrink: 0;
+      }
+    </style>`;
+
+// Blank-template scaffold rendered into apps/<id>/assets/index.html. Composes
+// the documented bb default styling head with a scaffold-only style block and
+// the task-list visual vocabulary borrowed from the bundled status app, so new
+// apps start out looking bb-native rather than like bare HTML.
+const BLANK_APP_INDEX_HTML_TEMPLATE = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${BLANK_APP_NAME_PLACEHOLDER}</title>
+    ${BB_DEFAULT_STYLING_HEAD}
+    ${BLANK_APP_SCAFFOLD_EXTRA_STYLES}
+  </head>
+  <body>
+    <header class="header">
+      <span class="brand">bb</span>
+      <span class="title">${BLANK_APP_NAME_PLACEHOLDER}</span>
+      <span class="ts" id="bb-app-id">&mdash;</span>
+    </header>
+
+    <main class="panel">
+      <p class="placeholder">
+        Ask your agent to customize the status app how you please.
+      </p>
+
+      <section class="section">
+        <div class="sect-ttl">Example tasks</div>
+        <div class="row">
+          <span class="label">implementing</span>
+          <span class="name">Sample task title</span>
+          <span class="pill">in progress</span>
+        </div>
+        <div class="row">
+          <span class="label">blocked</span>
+          <span class="name">Another sample row</span>
+          <span class="pill">blocked</span>
+        </div>
+      </section>
+    </main>
+
+    <script>
+      if (window.bb && window.bb.appId) {
+        document.getElementById("bb-app-id").textContent = window.bb.appId;
+      }
+    </script>
+  </body>
+</html>
+`;
+
 function sha256(bytes: Buffer): string {
   return createHash("sha256").update(bytes).digest("hex");
 }
@@ -924,21 +1133,10 @@ function createTemplateManifest(
 }
 
 function blankIndexHtml(name: string): string {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>${name}</title>
-  </head>
-  <body>
-    <main id="app"></main>
-    <script>
-      document.getElementById("app").textContent = window.bb ? window.bb.appId : ${JSON.stringify(name)};
-    </script>
-  </body>
-</html>
-`;
+  return BLANK_APP_INDEX_HTML_TEMPLATE.replaceAll(
+    BLANK_APP_NAME_PLACEHOLDER,
+    escapeHtmlText(name),
+  );
 }
 
 async function templateFilesForRequest(
diff --git a/apps/server/test/public/public-thread-apps.test.ts b/apps/server/test/public/public-thread-apps.test.ts
index 495014bfd..2fb77f74a 100644
--- a/apps/server/test/public/public-thread-apps.test.ts
+++ b/apps/server/test/public/public-thread-apps.test.ts
@@ -1005,4 +1005,269 @@ describe("public thread app routes", () => {
       await harness.cleanup();
     }
   });
+
+  it("scaffolds blank-template apps with the bb-styled index.html", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            id: "blank-demo",
+            name: "Blank Demo",
+            template: "blank",
+          }),
+        },
+      );
+      const existingCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(fixture, "blank-demo") &&
+          command.path === "manifest.json",
+      );
+      await reportQueuedCommandError(harness, existingCommand, {
+        errorCode: "ENOENT",
+        errorMessage: "Path does not exist: manifest.json",
+      });
+
+      const manifestWrite = await waitForQueuedCommandAfter(
+        harness,
+        existingCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "blank-demo") &&
+          command.path === "manifest.json",
+      );
+      const manifestWriteCommand =
+        requireWriteFileRelativeCommand(manifestWrite);
+      await reportQueuedCommandSuccess(harness, manifestWrite, {
+        path: "manifest.json",
+        hash: sha256Text(manifestWriteCommand.command.content),
+        modifiedAtMs: 1000,
+        sizeBytes: Buffer.byteLength(manifestWriteCommand.command.content),
+      });
+
+      const htmlWrite = await waitForQueuedCommandAfter(
+        harness,
+        manifestWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "blank-demo") &&
+          command.path === "assets/index.html",
+      );
+      const htmlWriteCommand = requireWriteFileRelativeCommand(htmlWrite);
+      const html = htmlWriteCommand.command.content;
+      // bb design tokens come through verbatim from `bb guide styling`.
+      expect(html).toContain('--font-sans: "Inter"');
+      expect(html).toContain("oklch(0.9551 0 0)");
+      expect(html).toContain("@media (prefers-color-scheme: dark)");
+      // Placeholder copy invites the user to extend the scaffold via their agent.
+      expect(html).toContain(
+        "Ask your agent to customize the status app how you please.",
+      );
+      // Task-list row vocabulary is present so the scaffold looks bb-native.
+      expect(html).toContain('class="row"');
+      expect(html).toContain('class="pill"');
+      // App name is interpolated into the visible title.
+      expect(html).toContain("<title>Blank Demo</title>");
+      await reportQueuedCommandSuccess(harness, htmlWrite, {
+        path: "assets/index.html",
+        hash: sha256Text(html),
+        modifiedAtMs: 1001,
+        sizeBytes: Buffer.byteLength(html),
+      });
+
+      const stateWrite = await waitForQueuedCommandAfter(
+        harness,
+        htmlWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "blank-demo") &&
+          command.path === "data/state.json",
+      );
+      const stateWriteCommand = requireWriteFileRelativeCommand(stateWrite);
+      await reportQueuedCommandSuccess(harness, stateWrite, {
+        path: "data/state.json",
+        hash: sha256Text(stateWriteCommand.command.content),
+        modifiedAtMs: 1002,
+        sizeBytes: Buffer.byteLength(stateWriteCommand.command.content),
+      });
+
+      const manifestRead = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "blank-demo",
+        afterCursor: stateWrite.row.cursor,
+        manifest: {
+          manifestVersion: 1,
+          id: "blank-demo",
+          name: "Blank Demo",
+          entry: "index.html",
+          contributions: ["thread.app"],
+          capabilities: ["data", "message"],
+        },
+      });
+
+      // No icon in manifest -> server probes the app root for a logo file.
+      const logoListCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestRead.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === appRoot(fixture, "blank-demo"),
+      );
+      await reportQueuedCommandSuccess(harness, logoListCommand, {
+        paths: [],
+        truncated: false,
+      });
+
+      const response = await request;
+      expect(response.status).toBe(201);
+      expect(appDetailSchema.parse(await readJson(response))).toMatchObject({
+        id: "blank-demo",
+        name: "Blank Demo",
+        entry: { kind: "html", path: "index.html" },
+        icon: { kind: "builtin", name: "GridView" },
+        capabilities: ["data", "message"],
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("HTML-escapes the app name in the blank scaffold to block XSS", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const maliciousName = `<script>alert(1)</script> & "q" 'a'`;
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            id: "xss-demo",
+            name: maliciousName,
+            template: "blank",
+          }),
+        },
+      );
+      const existingCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.read_file_relative" &&
+          command.rootPath === appRoot(fixture, "xss-demo") &&
+          command.path === "manifest.json",
+      );
+      await reportQueuedCommandError(harness, existingCommand, {
+        errorCode: "ENOENT",
+        errorMessage: "Path does not exist: manifest.json",
+      });
+
+      const manifestWrite = await waitForQueuedCommandAfter(
+        harness,
+        existingCommand.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "xss-demo") &&
+          command.path === "manifest.json",
+      );
+      const manifestWriteCommand =
+        requireWriteFileRelativeCommand(manifestWrite);
+      await reportQueuedCommandSuccess(harness, manifestWrite, {
+        path: "manifest.json",
+        hash: sha256Text(manifestWriteCommand.command.content),
+        modifiedAtMs: 2000,
+        sizeBytes: Buffer.byteLength(manifestWriteCommand.command.content),
+      });
+
+      const htmlWrite = await waitForQueuedCommandAfter(
+        harness,
+        manifestWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "xss-demo") &&
+          command.path === "assets/index.html",
+      );
+      const htmlWriteCommand = requireWriteFileRelativeCommand(htmlWrite);
+      const html = htmlWriteCommand.command.content;
+
+      // Raw special characters from the name must never reach the rendered
+      // HTML where they would be interpreted as markup.
+      expect(html).not.toContain("<script>alert(1)</script>");
+      expect(html).not.toContain('name & "q"');
+      expect(html).not.toContain("'a'");
+      // Each special char in the name is replaced with its entity form.
+      expect(html).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+      expect(html).toContain("&amp;");
+      expect(html).toContain("&quot;q&quot;");
+      expect(html).toContain("&#39;a&#39;");
+      // The escaped name shows up in both the <title> and the visible header.
+      const escapedName =
+        "&lt;script&gt;alert(1)&lt;/script&gt; &amp; &quot;q&quot; &#39;a&#39;";
+      expect(html).toContain(`<title>${escapedName}</title>`);
+      expect(html).toContain(
+        `<span class="title">${escapedName}</span>`,
+      );
+
+      await reportQueuedCommandSuccess(harness, htmlWrite, {
+        path: "assets/index.html",
+        hash: sha256Text(html),
+        modifiedAtMs: 2001,
+        sizeBytes: Buffer.byteLength(html),
+      });
+
+      const stateWrite = await waitForQueuedCommandAfter(
+        harness,
+        htmlWrite.row.cursor,
+        ({ command }) =>
+          command.type === "host.write_file_relative" &&
+          command.rootPath === appRoot(fixture, "xss-demo") &&
+          command.path === "data/state.json",
+      );
+      const stateWriteCommand = requireWriteFileRelativeCommand(stateWrite);
+      await reportQueuedCommandSuccess(harness, stateWrite, {
+        path: "data/state.json",
+        hash: sha256Text(stateWriteCommand.command.content),
+        modifiedAtMs: 2002,
+        sizeBytes: Buffer.byteLength(stateWriteCommand.command.content),
+      });
+
+      const manifestRead = await reportManifestRead({
+        harness,
+        fixture,
+        appId: "xss-demo",
+        afterCursor: stateWrite.row.cursor,
+        manifest: {
+          manifestVersion: 1,
+          id: "xss-demo",
+          name: maliciousName,
+          entry: "index.html",
+          contributions: ["thread.app"],
+          capabilities: ["data", "message"],
+        },
+      });
+
+      const logoListCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestRead.row.cursor,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === appRoot(fixture, "xss-demo"),
+      );
+      await reportQueuedCommandSuccess(harness, logoListCommand, {
+        paths: [],
+        truncated: false,
+      });
+
+      const response = await request;
+      expect(response.status).toBe(201);
+    } finally {
+      await harness.cleanup();
+    }
+  });
 });
diff --git a/packages/domain/src/html-escape.ts b/packages/domain/src/html-escape.ts
new file mode 100644
index 000000000..2b620effc
--- /dev/null
+++ b/packages/domain/src/html-escape.ts
@@ -0,0 +1,14 @@
+const HTML_ESCAPE_REPLACEMENTS: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+export function escapeHtmlText(value: string): string {
+  return value.replace(
+    /[&<>"']/gu,
+    (character) => HTML_ESCAPE_REPLACEMENTS[character] ?? character,
+  );
+}
diff --git a/packages/domain/src/index.ts b/packages/domain/src/index.ts
index 6774ff618..a94b77830 100644
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -534,6 +534,8 @@ export type {
 
 export { toPositiveNumber } from "./number-utils.js";
 
+export { escapeHtmlText } from "./html-escape.js";
+
 export { activeThinkingSchema } from "./active-thinking.js";
 export type { ActiveThinking } from "./active-thinking.js";
 
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ca5c250df..df0ff935e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -314,6 +314,9 @@ importers:
       '@bb/config':
         specifier: workspace:*
         version: link:../../packages/config
+      '@bb/domain':
+        specifier: workspace:*
+        version: link:../../packages/domain
       '@bb/server-contract':
         specifier: workspace:*
         version: link:../../packages/server-contract

From feb94067841d0b1511d40777ff0571d306f07aa1 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 12:17:38 -0700
Subject: [PATCH 10/13] app: unify New Tab launcher tile rhythm

Three small visual fixes to the secondary-panel New Tab launcher:

1. Unified the icon containers across Pet / Status / Create App tiles
   via shared LAUNCHER_TILE_ICON_CLASS constants. All three now share
   a size-9 raised frame with a size-5 glyph; the only intentional
   variant is the dashed inner border on Create App. The frame stays
   constant, only the asset varies.

2. Hide redundant id captions when the app id matches a slugified
   display name. `pet` / `status` captions disappear; when the id
   genuinely differs from the name, the caption renders in font-mono
   so it visibly reads as a developer identifier.

3. Drop the duplicate `title` tooltip on Create App (body hint stays)
   and the dead `disabled` prop on CreateAppTile.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../secondary-panel/NewTabFileSearch.tsx      | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
index 99dee3125..564610410 100644
--- a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
@@ -110,7 +110,6 @@ interface GroupFileSearchSectionsArgs {
 }
 
 interface CreateAppTileProps {
-  disabled: boolean;
   onClick: () => void;
 }
 
@@ -135,6 +134,18 @@ const SECTION_HEADER_CLASS =
   "sticky top-0 z-10 bg-background px-1 pb-2 text-xs font-medium uppercase tracking-wider text-subtle-foreground";
 const LAUNCHER_TILE_BASE_CLASS =
   "group flex w-full min-w-0 items-center gap-3 rounded-md px-2 py-2 text-left transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring";
+const LAUNCHER_TILE_ICON_CLASS =
+  "flex size-9 shrink-0 items-center justify-center overflow-hidden rounded-md border border-border-hairline bg-surface-raised";
+const LAUNCHER_TILE_ICON_CLASS_DASHED =
+  "flex size-9 shrink-0 items-center justify-center rounded-md border border-dashed border-border bg-surface-raised text-muted-foreground group-hover:text-foreground";
+
+function slugifyAppName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
 
 function getAvailableFileSearchSources({
   projectId,
@@ -259,7 +270,7 @@ function AppResultRow({
   const handleSelect = useCallback(() => {
     onSelect(suggestion);
   }, [onSelect, suggestion]);
-  const showAppId = suggestion.appId !== suggestion.name;
+  const showAppId = suggestion.appId !== slugifyAppName(suggestion.name);
 
   return (
     <button
@@ -276,7 +287,7 @@ function AppResultRow({
         isActive ? "bg-state-active" : "hover:bg-state-hover",
       )}
     >
-      <span className="flex size-9 shrink-0 items-center justify-center overflow-hidden rounded-md border border-border-hairline bg-surface-raised">
+      <span className={LAUNCHER_TILE_ICON_CLASS}>
         <ResolvedAppIcon
           icon={suggestion.app.icon}
           className="size-5 text-foreground"
@@ -287,7 +298,7 @@ function AppResultRow({
           {suggestion.name}
         </span>
         {showAppId ? (
-          <span className="truncate text-xs text-muted-foreground">
+          <span className="truncate font-mono text-xs text-muted-foreground">
             {suggestion.appId}
           </span>
         ) : null}
@@ -296,26 +307,15 @@ function AppResultRow({
   );
 }
 
-function CreateAppTile({ disabled, onClick }: CreateAppTileProps) {
+function CreateAppTile({ onClick }: CreateAppTileProps) {
   return (
     <button
       type="button"
       onClick={onClick}
-      disabled={disabled}
-      title={
-        disabled
-          ? "Composer is unavailable"
-          : "Prefill the composer with a new-app prompt"
-      }
-      className={cn(
-        LAUNCHER_TILE_BASE_CLASS,
-        "border border-dashed border-border text-muted-foreground",
-        "hover:border-border-hairline hover:bg-state-hover hover:text-foreground",
-        "disabled:pointer-events-none disabled:opacity-50",
-      )}
+      className={cn(LAUNCHER_TILE_BASE_CLASS, "hover:bg-state-hover")}
     >
-      <span className="flex size-9 shrink-0 items-center justify-center rounded-md border border-dashed border-border bg-surface-raised text-muted-foreground group-hover:text-foreground">
-        <Icon name="Plus" className="size-4" aria-hidden />
+      <span className={LAUNCHER_TILE_ICON_CLASS_DASHED}>
+        <Icon name="Plus" className="size-5" aria-hidden />
       </span>
       <span className="flex min-w-0 flex-1 flex-col">
         <span className="truncate text-sm font-medium text-foreground">
@@ -666,7 +666,7 @@ function NewTabResults({
                 appsSection && appsSection.items.length > 0 && "mt-px",
               )}
             >
-              <CreateAppTile disabled={false} onClick={onCreateApp} />
+              <CreateAppTile onClick={onCreateApp} />
             </div>
           ) : null}
         </section>

From 24e7924e5da72dc24c6f48039fcb23271db7c487 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 14:12:11 -0700
Subject: [PATCH 11/13] server(apps): bb-styled generic default status app +
 scaffold dedup

The default status app shipped to fresh managers was hard-coded to a
PR/worker-review workflow (PULL REQUESTS + WORKERS + "Message the
manager" sections, a `pr` landing-mode chip). That assumed one
specific routine; a brand-new bb user has neither. Replace with a
bb-styled generic starting-point dashboard that matches the
`bb app new --template blank` output and invites customization:

  "Ask your agent to customize the status app how you please."

Mechanism: extract buildBlankAppIndexHtml({ name }) into a new
apps/server/src/services/threads/blank-app-scaffold.ts. Both
`bb app new --template blank` and `--template status` paths plus the
bundled manager-template overlay now generate index.html through one
generator (only the manifest icon differs). Delete the static
default-template/apps/status/{assets/index.html, data/state.json}
that pinned the old PR-review content.

User-authored manager templates still win over the bundled seed via
the existing flag:"wx" overlay semantics.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 apps/server/src/routes/threads/apps.ts        | 250 +---------------
 .../services/threads/blank-app-scaffold.ts    | 220 ++++++++++++++
 .../apps/status/assets/index.html             | 273 ------------------
 .../apps/status/data/state.json               |   7 -
 .../threads/manager-storage-templates.ts      |  16 +-
 ...blic-threads.manager-and-ownership.test.ts |   2 +-
 .../threads/manager-storage-templates.test.ts |  18 +-
 7 files changed, 252 insertions(+), 534 deletions(-)
 create mode 100644 apps/server/src/services/threads/blank-app-scaffold.ts
 delete mode 100644 apps/server/src/services/threads/default-template/apps/status/assets/index.html
 delete mode 100644 apps/server/src/services/threads/default-template/apps/status/data/state.json

diff --git a/apps/server/src/routes/threads/apps.ts b/apps/server/src/routes/threads/apps.ts
index 2f5432a5c..60b9cb390 100644
--- a/apps/server/src/routes/threads/apps.ts
+++ b/apps/server/src/routes/threads/apps.ts
@@ -1,8 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import mimeTypes from "mime-types";
 import type { Hono } from "hono";
 import {
@@ -13,7 +11,6 @@ import {
 import {
   appDataPathSchema,
   appIdSchema,
-  escapeHtmlText,
   jsonValueSchema,
 } from "@bb/domain";
 import type { AppDataPath, AppId, JsonValue } from "@bb/domain";
@@ -49,6 +46,7 @@ import { requirePublicThread } from "../../services/lib/entity-lookup.js";
 import { requireThreadCommandEnvironment } from "../../services/threads/thread-command-environment.js";
 import { sendThreadMessage } from "../../services/threads/thread-send.js";
 import { injectAppClientScript } from "../../services/threads/app-client-script.js";
+import { buildBlankAppIndexHtml } from "../../services/threads/blank-app-scaffold.js";
 import {
   extractRoutePath,
   parseSafeRelativeRoutePath,
@@ -176,210 +174,6 @@ const LOGO_MAX_BYTES = 1024 * 1024;
 const LOGO_EXTENSIONS = ["svg", "png", "jpg", "jpeg"] as const;
 const APP_ROUTE_DATA_SEGMENT = "/data/";
 
-const BLANK_APP_NAME_PLACEHOLDER = "__BB_APP_NAME__";
-
-// First <style> block: the bb default styling head copied verbatim from
-// `bb guide styling` (packages/templates/src/templates/bb-guide-app.md). Keep
-// this in sync with that guide so the scaffold and the documented tokens never
-// drift.
-const BB_DEFAULT_STYLING_HEAD = `<script src="https://cdn.tailwindcss.com"></script>
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
-    <style>
-    :root {
-      color-scheme: light;
-      --background: oklch(0.9551 0 0);
-      --foreground: oklch(0.3211 0 0);
-      --card: oklch(0.9702 0 0);
-      --muted: oklch(0.8853 0 0);
-      --muted-foreground: oklch(0.5103 0 0);
-      --border: oklch(0.8576 0 0);
-      --accent: oklch(0.9 0 0);
-      --success: oklch(0.7 0.15 155);
-      --warning: oklch(0.7 0.16 50);
-      --destructive: oklch(0.5594 0.19 25.8625);
-      --radius: 0.5rem;
-      --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
-      --font-mono: "Fira Code", ui-monospace, SFMono-Regular, monospace;
-    }
-    @media (prefers-color-scheme: dark) {
-      :root {
-        color-scheme: dark;
-        --background: oklch(0.2178 0 0);
-        --foreground: oklch(0.8853 0 0);
-        --card: oklch(0.2435 0 0);
-        --muted: oklch(0.31 0 0);
-        --muted-foreground: oklch(0.7058 0 0);
-        --border: oklch(0.34 0 0);
-        --accent: oklch(0.32 0 0);
-      }
-    }
-    body {
-      margin: 0;
-      background: var(--background);
-      color: var(--foreground);
-      font-family: var(--font-sans);
-      font-size: 13px;
-    }
-    .panel {
-      border: 1px solid var(--border);
-      border-radius: var(--radius);
-      background: var(--card);
-    }
-    </style>`;
-
-// Second <style> block: scaffold-only classes layered on top of the guide
-// tokens. Keep this strictly additive; do not redefine variables or guide
-// classes here.
-const BLANK_APP_SCAFFOLD_EXTRA_STYLES = `<style>
-      * { box-sizing: border-box; }
-      body {
-        padding: 16px 16px 20px;
-        line-height: 1.45;
-        -webkit-font-smoothing: antialiased;
-      }
-      .panel { padding: 14px 16px; }
-      .header {
-        display: flex;
-        align-items: center;
-        gap: 8px;
-        padding-bottom: 10px;
-        border-bottom: 1px solid var(--border);
-        margin-bottom: 16px;
-      }
-      .brand {
-        width: 20px;
-        height: 20px;
-        border: 1px solid var(--border);
-        background: var(--card);
-        border-radius: calc(var(--radius) - 4px);
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        font-family: var(--font-mono);
-        font-weight: 500;
-        font-size: 10px;
-      }
-      .title {
-        font-size: 13px;
-        font-weight: 600;
-        flex: 1;
-        min-width: 0;
-        letter-spacing: -0.005em;
-      }
-      .ts {
-        font-family: var(--font-mono);
-        font-size: 10px;
-        color: var(--muted-foreground);
-      }
-      .placeholder {
-        margin: 0 0 14px;
-        color: var(--muted-foreground);
-        font-size: 13px;
-      }
-      .section { margin-top: 14px; }
-      .sect-ttl {
-        font-size: 10.5px;
-        font-weight: 600;
-        letter-spacing: 0.06em;
-        text-transform: uppercase;
-        color: var(--muted-foreground);
-        margin-bottom: 8px;
-      }
-      .row {
-        display: flex;
-        align-items: center;
-        gap: 10px;
-        padding: 9px 12px;
-        background: var(--card);
-        border: 1px solid var(--border);
-        border-radius: var(--radius);
-      }
-      .row + .row { margin-top: 6px; }
-      .label {
-        font-family: var(--font-mono);
-        font-size: 10.5px;
-        color: var(--muted-foreground);
-        white-space: nowrap;
-      }
-      .name {
-        flex: 1;
-        min-width: 0;
-        font-size: 13px;
-        font-weight: 500;
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-      }
-      .pill {
-        display: inline-flex;
-        align-items: center;
-        font-family: var(--font-mono);
-        font-size: 9.5px;
-        font-weight: 500;
-        line-height: 1;
-        padding: 3px 7px;
-        border-radius: 999px;
-        border: 1px solid var(--border);
-        background: var(--background);
-        color: var(--muted-foreground);
-        text-transform: uppercase;
-        letter-spacing: 0.05em;
-        white-space: nowrap;
-        flex-shrink: 0;
-      }
-    </style>`;
-
-// Blank-template scaffold rendered into apps/<id>/assets/index.html. Composes
-// the documented bb default styling head with a scaffold-only style block and
-// the task-list visual vocabulary borrowed from the bundled status app, so new
-// apps start out looking bb-native rather than like bare HTML.
-const BLANK_APP_INDEX_HTML_TEMPLATE = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${BLANK_APP_NAME_PLACEHOLDER}</title>
-    ${BB_DEFAULT_STYLING_HEAD}
-    ${BLANK_APP_SCAFFOLD_EXTRA_STYLES}
-  </head>
-  <body>
-    <header class="header">
-      <span class="brand">bb</span>
-      <span class="title">${BLANK_APP_NAME_PLACEHOLDER}</span>
-      <span class="ts" id="bb-app-id">&mdash;</span>
-    </header>
-
-    <main class="panel">
-      <p class="placeholder">
-        Ask your agent to customize the status app how you please.
-      </p>
-
-      <section class="section">
-        <div class="sect-ttl">Example tasks</div>
-        <div class="row">
-          <span class="label">implementing</span>
-          <span class="name">Sample task title</span>
-          <span class="pill">in progress</span>
-        </div>
-        <div class="row">
-          <span class="label">blocked</span>
-          <span class="name">Another sample row</span>
-          <span class="pill">blocked</span>
-        </div>
-      </section>
-    </main>
-
-    <script>
-      if (window.bb && window.bb.appId) {
-        document.getElementById("bb-app-id").textContent = window.bb.appId;
-      }
-    </script>
-  </body>
-</html>
-`;
-
 function sha256(bytes: Buffer): string {
   return createHash("sha256").update(bytes).digest("hex");
 }
@@ -1132,42 +926,10 @@ function createTemplateManifest(
   return manifest;
 }
 
-function blankIndexHtml(name: string): string {
-  return BLANK_APP_INDEX_HTML_TEMPLATE.replaceAll(
-    BLANK_APP_NAME_PLACEHOLDER,
-    escapeHtmlText(name),
-  );
-}
-
-async function templateFilesForRequest(
+function templateFilesForRequest(
   request: CreateThreadAppRequest,
-): Promise<TemplateFile[]> {
+): TemplateFile[] {
   const manifest = createTemplateManifest(request, request.template);
-  if (request.template === "blank") {
-    return [
-      {
-        path: MANIFEST_FILE_NAME,
-        content: canonicalizeJson(manifest),
-      },
-      {
-        path: "assets/index.html",
-        content: blankIndexHtml(request.name),
-      },
-      {
-        path: "data/state.json",
-        content: canonicalizeJson({}),
-      },
-    ];
-  }
-
-  const templateDir = path.join(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "../../services/threads/default-template/apps/status",
-  );
-  const [indexHtml, stateJson] = await Promise.all([
-    readFile(path.join(templateDir, "assets/index.html"), "utf8"),
-    readFile(path.join(templateDir, "data/state.json"), "utf8"),
-  ]);
   return [
     {
       path: MANIFEST_FILE_NAME,
@@ -1175,11 +937,11 @@ async function templateFilesForRequest(
     },
     {
       path: "assets/index.html",
-      content: indexHtml,
+      content: buildBlankAppIndexHtml({ name: request.name }),
     },
     {
       path: "data/state.json",
-      content: stateJson,
+      content: canonicalizeJson({}),
     },
   ];
 }
@@ -1200,7 +962,7 @@ async function scaffoldApp(
     }
   }
 
-  const files = await templateFilesForRequest(args.request);
+  const files = templateFilesForRequest(args.request);
   for (const file of files) {
     await queueHostCommand(deps, {
       hostId: args.target.hostId,
diff --git a/apps/server/src/services/threads/blank-app-scaffold.ts b/apps/server/src/services/threads/blank-app-scaffold.ts
new file mode 100644
index 000000000..e47d6d256
--- /dev/null
+++ b/apps/server/src/services/threads/blank-app-scaffold.ts
@@ -0,0 +1,220 @@
+import { escapeHtmlText } from "@bb/domain";
+
+interface BuildBlankAppIndexHtmlArgs {
+  name: string;
+}
+
+const BLANK_APP_NAME_PLACEHOLDER = "__BB_APP_NAME__";
+
+// First <style> block: the bb default styling head copied verbatim from
+// `bb guide styling` (packages/templates/src/templates/bb-guide-app.md). Keep
+// this in sync with that guide so the scaffold and the documented tokens never
+// drift.
+const BB_DEFAULT_STYLING_HEAD = `<script src="https://cdn.tailwindcss.com"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
+    <style>
+    :root {
+      color-scheme: light;
+      --background: oklch(0.9551 0 0);
+      --foreground: oklch(0.3211 0 0);
+      --card: oklch(0.9702 0 0);
+      --muted: oklch(0.8853 0 0);
+      --muted-foreground: oklch(0.5103 0 0);
+      --border: oklch(0.8576 0 0);
+      --accent: oklch(0.9 0 0);
+      --success: oklch(0.7 0.15 155);
+      --warning: oklch(0.7 0.16 50);
+      --destructive: oklch(0.5594 0.19 25.8625);
+      --radius: 0.5rem;
+      --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
+      --font-mono: "Fira Code", ui-monospace, SFMono-Regular, monospace;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        color-scheme: dark;
+        --background: oklch(0.2178 0 0);
+        --foreground: oklch(0.8853 0 0);
+        --card: oklch(0.2435 0 0);
+        --muted: oklch(0.31 0 0);
+        --muted-foreground: oklch(0.7058 0 0);
+        --border: oklch(0.34 0 0);
+        --accent: oklch(0.32 0 0);
+      }
+    }
+    body {
+      margin: 0;
+      background: var(--background);
+      color: var(--foreground);
+      font-family: var(--font-sans);
+      font-size: 13px;
+    }
+    .panel {
+      border: 1px solid var(--border);
+      border-radius: var(--radius);
+      background: var(--card);
+    }
+    </style>`;
+
+// Second <style> block: scaffold-only classes layered on top of the guide
+// tokens. Keep this strictly additive; do not redefine variables or guide
+// classes here.
+const BLANK_APP_SCAFFOLD_EXTRA_STYLES = `<style>
+      * { box-sizing: border-box; }
+      body {
+        padding: 16px 16px 20px;
+        line-height: 1.45;
+        -webkit-font-smoothing: antialiased;
+      }
+      .panel { padding: 14px 16px; }
+      .header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding-bottom: 10px;
+        border-bottom: 1px solid var(--border);
+        margin-bottom: 16px;
+      }
+      .brand {
+        width: 20px;
+        height: 20px;
+        border: 1px solid var(--border);
+        background: var(--card);
+        border-radius: calc(var(--radius) - 4px);
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        font-family: var(--font-mono);
+        font-weight: 500;
+        font-size: 10px;
+      }
+      .title {
+        font-size: 13px;
+        font-weight: 600;
+        flex: 1;
+        min-width: 0;
+        letter-spacing: -0.005em;
+      }
+      .ts {
+        font-family: var(--font-mono);
+        font-size: 10px;
+        color: var(--muted-foreground);
+      }
+      .placeholder {
+        margin: 0 0 14px;
+        color: var(--muted-foreground);
+        font-size: 13px;
+      }
+      .section { margin-top: 14px; }
+      .sect-ttl {
+        font-size: 10.5px;
+        font-weight: 600;
+        letter-spacing: 0.06em;
+        text-transform: uppercase;
+        color: var(--muted-foreground);
+        margin-bottom: 8px;
+      }
+      .row {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 9px 12px;
+        background: var(--card);
+        border: 1px solid var(--border);
+        border-radius: var(--radius);
+      }
+      .row + .row { margin-top: 6px; }
+      .label {
+        font-family: var(--font-mono);
+        font-size: 10.5px;
+        color: var(--muted-foreground);
+        white-space: nowrap;
+      }
+      .name {
+        flex: 1;
+        min-width: 0;
+        font-size: 13px;
+        font-weight: 500;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+      .pill {
+        display: inline-flex;
+        align-items: center;
+        font-family: var(--font-mono);
+        font-size: 9.5px;
+        font-weight: 500;
+        line-height: 1;
+        padding: 3px 7px;
+        border-radius: 999px;
+        border: 1px solid var(--border);
+        background: var(--background);
+        color: var(--muted-foreground);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        white-space: nowrap;
+        flex-shrink: 0;
+      }
+    </style>`;
+
+// Blank-template scaffold rendered into apps/<id>/assets/index.html. Composes
+// the documented bb default styling head with a scaffold-only style block and
+// the task-list visual vocabulary borrowed from the bundled status app, so new
+// apps start out looking bb-native rather than like bare HTML. The same
+// scaffold powers both `bb app new` (any name) and the bundled default status
+// app seeded into every manager thread (name="Status").
+const BLANK_APP_INDEX_HTML_TEMPLATE = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${BLANK_APP_NAME_PLACEHOLDER}</title>
+    ${BB_DEFAULT_STYLING_HEAD}
+    ${BLANK_APP_SCAFFOLD_EXTRA_STYLES}
+  </head>
+  <body>
+    <header class="header">
+      <span class="brand">bb</span>
+      <span class="title">${BLANK_APP_NAME_PLACEHOLDER}</span>
+      <span class="ts" id="bb-app-id">&mdash;</span>
+    </header>
+
+    <main class="panel">
+      <p class="placeholder">
+        Ask your agent to customize the status app how you please.
+      </p>
+
+      <section class="section">
+        <div class="sect-ttl">Example tasks</div>
+        <div class="row">
+          <span class="label">implementing</span>
+          <span class="name">Sample task title</span>
+          <span class="pill">in progress</span>
+        </div>
+        <div class="row">
+          <span class="label">blocked</span>
+          <span class="name">Another sample row</span>
+          <span class="pill">blocked</span>
+        </div>
+      </section>
+    </main>
+
+    <script>
+      if (window.bb && window.bb.appId) {
+        document.getElementById("bb-app-id").textContent = window.bb.appId;
+      }
+    </script>
+  </body>
+</html>
+`;
+
+export function buildBlankAppIndexHtml(
+  args: BuildBlankAppIndexHtmlArgs,
+): string {
+  return BLANK_APP_INDEX_HTML_TEMPLATE.replaceAll(
+    BLANK_APP_NAME_PLACEHOLDER,
+    escapeHtmlText(args.name),
+  );
+}
diff --git a/apps/server/src/services/threads/default-template/apps/status/assets/index.html b/apps/server/src/services/threads/default-template/apps/status/assets/index.html
deleted file mode 100644
index 2df721196..000000000
--- a/apps/server/src/services/threads/default-template/apps/status/assets/index.html
+++ /dev/null
@@ -1,273 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Status</title>
-    <style>
-      :root {
-        color-scheme: light dark;
-        --bg: #f8fafc;
-        --panel: #ffffff;
-        --text: #111827;
-        --muted: #6b7280;
-        --border: #d1d5db;
-        --accent: #2563eb;
-        --soft: #eff6ff;
-        --ok: #047857;
-        --warn: #b45309;
-      }
-
-      @media (prefers-color-scheme: dark) {
-        :root {
-          --bg: #0f172a;
-          --panel: #111827;
-          --text: #f8fafc;
-          --muted: #9ca3af;
-          --border: #374151;
-          --accent: #60a5fa;
-          --soft: #172554;
-          --ok: #34d399;
-          --warn: #fbbf24;
-        }
-      }
-
-      * {
-        box-sizing: border-box;
-      }
-
-      body {
-        margin: 0;
-        min-height: 100vh;
-        background: var(--bg);
-        color: var(--text);
-        font: 13px/1.45 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      }
-
-      main {
-        display: grid;
-        gap: 16px;
-        padding: 16px;
-      }
-
-      header {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        gap: 12px;
-      }
-
-      h1,
-      h2,
-      p {
-        margin: 0;
-      }
-
-      h1 {
-        font-size: 17px;
-        font-weight: 650;
-      }
-
-      h2 {
-        font-size: 12px;
-        font-weight: 650;
-        letter-spacing: 0;
-        text-transform: uppercase;
-        color: var(--muted);
-      }
-
-      .pill {
-        display: inline-flex;
-        align-items: center;
-        min-height: 24px;
-        border: 1px solid var(--border);
-        border-radius: 999px;
-        padding: 2px 9px;
-        background: var(--panel);
-        color: var(--muted);
-        white-space: nowrap;
-      }
-
-      section {
-        display: grid;
-        gap: 8px;
-      }
-
-      .rows {
-        display: grid;
-        gap: 8px;
-      }
-
-      .row {
-        display: grid;
-        gap: 4px;
-        border: 1px solid var(--border);
-        border-radius: 8px;
-        background: var(--panel);
-        padding: 10px;
-      }
-
-      .row-title {
-        font-weight: 600;
-      }
-
-      .row-meta {
-        color: var(--muted);
-        overflow-wrap: anywhere;
-      }
-
-      .empty {
-        border: 1px dashed var(--border);
-        border-radius: 8px;
-        padding: 14px;
-        color: var(--muted);
-      }
-
-      form {
-        display: grid;
-        grid-template-columns: 1fr auto;
-        gap: 8px;
-      }
-
-      textarea {
-        min-height: 38px;
-        max-height: 160px;
-        resize: vertical;
-        border: 1px solid var(--border);
-        border-radius: 8px;
-        padding: 8px 10px;
-        background: var(--panel);
-        color: var(--text);
-        font: inherit;
-      }
-
-      button {
-        border: 1px solid var(--accent);
-        border-radius: 8px;
-        padding: 0 12px;
-        background: var(--accent);
-        color: white;
-        font: inherit;
-        font-weight: 600;
-        cursor: pointer;
-      }
-
-      button:disabled {
-        cursor: default;
-        opacity: 0.55;
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <header>
-        <h1>Status</h1>
-        <span class="pill" id="landing-mode">pr</span>
-      </header>
-
-      <section>
-        <h2>Pull Requests</h2>
-        <div class="rows" id="prs"></div>
-      </section>
-
-      <section>
-        <h2>Workers</h2>
-        <div class="rows" id="workers"></div>
-      </section>
-
-      <form id="message-form">
-        <textarea id="message-text" placeholder="Message the manager"></textarea>
-        <button type="submit">Send</button>
-      </form>
-    </main>
-
-    <script>
-      var state = { prefs: { landingMode: "pr" }, prs: [], workers: [] };
-
-      function text(value) {
-        return value === null || value === undefined ? "" : String(value);
-      }
-
-      function renderRows(element, rows, emptyText, title) {
-        element.textContent = "";
-        if (!Array.isArray(rows) || rows.length === 0) {
-          var empty = document.createElement("div");
-          empty.className = "empty";
-          empty.textContent = emptyText;
-          element.appendChild(empty);
-          return;
-        }
-        rows.forEach(function (row) {
-          var item = document.createElement("article");
-          item.className = "row";
-          var itemTitle = document.createElement("div");
-          itemTitle.className = "row-title";
-          itemTitle.textContent = title(row);
-          var meta = document.createElement("div");
-          meta.className = "row-meta";
-          meta.textContent = [row.state, row.updatedAt, row.threadId, row.url]
-            .map(text)
-            .filter(Boolean)
-            .join(" - ");
-          item.appendChild(itemTitle);
-          if (meta.textContent) item.appendChild(meta);
-          element.appendChild(item);
-        });
-      }
-
-      function render() {
-        document.getElementById("landing-mode").textContent =
-          text(state.prefs && state.prefs.landingMode) || "pr";
-        renderRows(
-          document.getElementById("prs"),
-          state.prs,
-          "No pull requests tracked",
-          function (row) {
-            return row.number ? "#" + row.number + " " + text(row.title) : text(row.title || row.url);
-          }
-        );
-        renderRows(
-          document.getElementById("workers"),
-          state.workers,
-          "No workers tracked",
-          function (row) {
-            return text(row.description || row.threadId);
-          }
-        );
-      }
-
-      function install() {
-        if (!window.bb || !window.bb.data) {
-          render();
-          return;
-        }
-        window.bb.data.onChange("state.json", function (event) {
-          if (!event.deleted && event.value && typeof event.value === "object") {
-            state = event.value;
-          }
-          render();
-        });
-        var form = document.getElementById("message-form");
-        var input = document.getElementById("message-text");
-        form.addEventListener("submit", function (event) {
-          event.preventDefault();
-          var message = input.value.trim();
-          if (!message || !window.bb.message) return;
-          form.querySelector("button").disabled = true;
-          window.bb.message(message).then(
-            function () {
-              input.value = "";
-              form.querySelector("button").disabled = false;
-            },
-            function () {
-              form.querySelector("button").disabled = false;
-            }
-          );
-        });
-      }
-
-      render();
-      install();
-    </script>
-  </body>
-</html>
diff --git a/apps/server/src/services/threads/default-template/apps/status/data/state.json b/apps/server/src/services/threads/default-template/apps/status/data/state.json
deleted file mode 100644
index d339df6c7..000000000
--- a/apps/server/src/services/threads/default-template/apps/status/data/state.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "prefs": {
-    "landingMode": "pr"
-  },
-  "prs": [],
-  "workers": []
-}
diff --git a/apps/server/src/services/threads/manager-storage-templates.ts b/apps/server/src/services/threads/manager-storage-templates.ts
index be1035217..fb7718590 100644
--- a/apps/server/src/services/threads/manager-storage-templates.ts
+++ b/apps/server/src/services/threads/manager-storage-templates.ts
@@ -15,11 +15,18 @@ import {
 } from "@bb/domain";
 import type { LoggedWorkSessionDeps, ServerLogger } from "../../types.js";
 import { ensureHostSessionReadyForWork } from "../hosts/host-lifecycle.js";
+import { buildBlankAppIndexHtml } from "./blank-app-scaffold.js";
 
 export const MANAGER_TEMPLATE_DIR_NAME = "manager-templates";
 export const ACTIVE_MANAGER_TEMPLATE_FILE_NAME = "active";
 export const DEFAULT_MANAGER_TEMPLATE_NAME: ManagerTemplateName = "default";
 
+const BUNDLED_STATUS_APP_NAME = "Status";
+const BUNDLED_STATUS_APP_INDEX_HTML = buildBlankAppIndexHtml({
+  name: BUNDLED_STATUS_APP_NAME,
+});
+const BUNDLED_STATUS_APP_STATE_JSON = "{}\n";
+
 const moduleDir = path.dirname(fileURLToPath(import.meta.url));
 const defaultTemplateAssetDir = path.join(moduleDir, "default-template");
 
@@ -93,6 +100,11 @@ type CopyTemplateFilesResult = "copied" | "missing";
 // working status surface even if the user's template omits these files.
 // User-authored files win because they are copied first and the overlay uses
 // the `wx` flag, which refuses to overwrite existing destinations.
+//
+// The bundled status app shares its index.html with the `bb app new` blank
+// scaffold (via buildBlankAppIndexHtml) so new users open a bb-styled
+// starting-point dashboard they can ask their agent to customize, rather than
+// inheriting any one workflow-specific UI.
 const BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET: BuiltInManagerTemplateSet = {
   name: DEFAULT_MANAGER_TEMPLATE_NAME,
   files: [
@@ -102,11 +114,11 @@ const BUILT_IN_DEFAULT_MANAGER_TEMPLATE_SET: BuiltInManagerTemplateSet = {
     },
     {
       fileName: "apps/status/assets/index.html",
-      content: loadDefaultTemplateAsset("apps/status/assets/index.html"),
+      content: BUNDLED_STATUS_APP_INDEX_HTML,
     },
     {
       fileName: "apps/status/data/state.json",
-      content: loadDefaultTemplateAsset("apps/status/data/state.json"),
+      content: BUNDLED_STATUS_APP_STATE_JSON,
     },
   ],
 };
diff --git a/apps/server/test/public/public-threads.manager-and-ownership.test.ts b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
index afe32a30b..d1ca6830d 100644
--- a/apps/server/test/public/public-threads.manager-and-ownership.test.ts
+++ b/apps/server/test/public/public-threads.manager-and-ownership.test.ts
@@ -1131,7 +1131,7 @@ describe("public thread manager and ownership routes", () => {
       ).resolves.toContain("<title>Status</title>");
       await expect(
         readFile(path.join(storagePath, "apps/status/data/state.json"), "utf8"),
-      ).resolves.toContain('"landingMode": "pr"');
+      ).resolves.toBe("{}\n");
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });
diff --git a/apps/server/test/threads/manager-storage-templates.test.ts b/apps/server/test/threads/manager-storage-templates.test.ts
index 1cb817e47..c2808dc73 100644
--- a/apps/server/test/threads/manager-storage-templates.test.ts
+++ b/apps/server/test/threads/manager-storage-templates.test.ts
@@ -18,6 +18,7 @@ import {
   managerTemplateRootPath,
   seedManagerThreadStorage,
 } from "../../src/services/threads/manager-storage-templates.js";
+import { buildBlankAppIndexHtml } from "../../src/services/threads/blank-app-scaffold.js";
 import type { TestAppHarness } from "../helpers/test-app.js";
 import { seedHost } from "../helpers/seed.js";
 import { createTestAppHarness, testLogger } from "../helpers/test-app.js";
@@ -75,16 +76,19 @@ async function createSeedHarness(): Promise<SeedHarness> {
   };
 }
 
-async function readBundledStatusAppFile(relativePath: string): Promise<string> {
+async function readBundledManifestJson(): Promise<string> {
   return readFile(
     new URL(
-      `../../src/services/threads/default-template/apps/status/${relativePath}`,
+      "../../src/services/threads/default-template/apps/status/manifest.json",
       import.meta.url,
     ),
     "utf8",
   );
 }
 
+const BUNDLED_STATUS_INDEX_HTML = buildBlankAppIndexHtml({ name: "Status" });
+const BUNDLED_STATUS_STATE_JSON = "{}\n";
+
 async function expectBundledStatusAppSeeded(
   threadStoragePath: string,
 ): Promise<void> {
@@ -93,19 +97,19 @@ async function expectBundledStatusAppSeeded(
       path.join(threadStoragePath, "apps/status/manifest.json"),
       "utf8",
     ),
-  ).resolves.toBe(await readBundledStatusAppFile("manifest.json"));
+  ).resolves.toBe(await readBundledManifestJson());
   await expect(
     readFile(
       path.join(threadStoragePath, "apps/status/assets/index.html"),
       "utf8",
     ),
-  ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
+  ).resolves.toBe(BUNDLED_STATUS_INDEX_HTML);
   await expect(
     readFile(
       path.join(threadStoragePath, "apps/status/data/state.json"),
       "utf8",
     ),
-  ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
+  ).resolves.toBe(BUNDLED_STATUS_STATE_JSON);
 }
 
 async function writeManagerTemplateSet(
@@ -248,13 +252,13 @@ describe("manager storage templates", () => {
           path.join(threadStoragePath, "apps/status/assets/index.html"),
           "utf8",
         ),
-      ).resolves.toBe(await readBundledStatusAppFile("assets/index.html"));
+      ).resolves.toBe(BUNDLED_STATUS_INDEX_HTML);
       await expect(
         readFile(
           path.join(threadStoragePath, "apps/status/data/state.json"),
           "utf8",
         ),
-      ).resolves.toBe(await readBundledStatusAppFile("data/state.json"));
+      ).resolves.toBe(BUNDLED_STATUS_STATE_JSON);
     } finally {
       await harness.cleanup();
       await rm(dataDir, { recursive: true, force: true });

From 49ae4450baa13efa0e2fe14ded70ca8129a8d0d7 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 14:22:18 -0700
Subject: [PATCH 12/13] server(apps): skip invalid manifests in list route
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A single invalid app manifest in a thread's apps/ directory used to
fail the entire GET /api/v1/threads/<id>/apps list response with 422,
taking down the whole secondary-panel launcher.

The list route now shares a single readAppManifest parse step with
the detail and serve routes; zod validation failures on an individual
manifest log a structured warning (appId, manifestPath, summarized
issue list at WARN level, full issues at debug) and that app is
skipped in the list response. Detail and serve routes still surface
the failure as a new invalid_manifest 422 error code (added to
@bb/server-contract errors) with a one-line message — full zod issues
stay in the server log, not on the wire.

Tests cover: partial-success list (valid + invalid → 200 with only
the valid summary + logger warned); detail returns invalid_manifest
422; serve returns invalid_manifest 422 (not the SPA shell
fallthrough).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 apps/server/src/routes/threads/apps.ts        | 143 +++++++++++++---
 .../test/public/public-thread-apps.test.ts    | 154 +++++++++++++++++-
 packages/server-contract/src/errors.ts        |   3 +-
 3 files changed, 274 insertions(+), 26 deletions(-)

diff --git a/apps/server/src/routes/threads/apps.ts b/apps/server/src/routes/threads/apps.ts
index 60b9cb390..8e84cba57 100644
--- a/apps/server/src/routes/threads/apps.ts
+++ b/apps/server/src/routes/threads/apps.ts
@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import mimeTypes from "mime-types";
 import type { Hono } from "hono";
+import type { ZodIssue } from "zod";
 import {
   FILE_LIST_LIMIT_MAX,
   type HostDaemonCommand,
@@ -64,6 +65,15 @@ interface AppManifestReadArgs {
   target: ThreadAppsTarget;
 }
 
+interface InvalidAppManifestErrorArgs extends AppManifestReadArgs {
+  issues: AppManifestValidationIssues;
+}
+
+interface LogInvalidAppManifestArgs {
+  error: InvalidAppManifestError;
+  message: string;
+}
+
 interface AppSummaryArgs extends AppManifestReadArgs {
   manifest: AppManifest;
   requestThreadId: string;
@@ -157,6 +167,9 @@ type HostCommandType =
   | "host.delete_file_relative"
   | "host.delete_path_relative";
 
+type AppManifestValidationIssues = readonly ZodIssue[];
+type AppManifestValidationLoggerDeps = Pick<AppDeps, "logger">;
+
 interface QueueHostCommandArgs<TType extends HostCommandType> {
   command: Extract<HostDaemonCommand, { type: TType }>;
   hostId: string;
@@ -173,6 +186,22 @@ const HTML_ENTRY_MAX_BYTES = 5 * 1024 * 1024;
 const LOGO_MAX_BYTES = 1024 * 1024;
 const LOGO_EXTENSIONS = ["svg", "png", "jpg", "jpeg"] as const;
 const APP_ROUTE_DATA_SEGMENT = "/data/";
+const INVALID_APP_MANIFEST_MESSAGE =
+  "App manifest failed validation. Inspect manifest.json or rebuild the app.";
+
+class InvalidAppManifestError extends ApiError {
+  readonly appId: AppId;
+  readonly manifestPath: string;
+  readonly issues: AppManifestValidationIssues;
+
+  constructor(args: InvalidAppManifestErrorArgs) {
+    super(422, "invalid_manifest", INVALID_APP_MANIFEST_MESSAGE);
+    this.name = "InvalidAppManifestError";
+    this.appId = args.appId;
+    this.manifestPath = path.join(appRootPath(args), MANIFEST_FILE_NAME);
+    this.issues = args.issues;
+  }
+}
 
 function sha256(bytes: Buffer): string {
   return createHash("sha256").update(bytes).digest("hex");
@@ -256,6 +285,32 @@ function decodeDaemonTextFile(result: DaemonFileReadResult): string {
   return Buffer.from(decodeDaemonFileContent(result)).toString("utf8");
 }
 
+function summarizeAppManifestValidationIssues(
+  issues: AppManifestValidationIssues,
+): string {
+  return issues
+    .map((issue) => {
+      const issuePath = issue.path.map(String).join(".");
+      return `${issuePath || "<root>"}: ${issue.message}`;
+    })
+    .join("; ");
+}
+
+function logInvalidAppManifest(
+  deps: AppManifestValidationLoggerDeps,
+  args: LogInvalidAppManifestArgs,
+): void {
+  deps.logger.warn(
+    {
+      appId: args.error.appId,
+      manifestPath: args.error.manifestPath,
+      issueSummary: summarizeAppManifestValidationIssues(args.error.issues),
+      issues: args.error.issues,
+    },
+    args.message,
+  );
+}
+
 function remapAppCommandError(error: unknown): never {
   if (!(error instanceof ApiError)) {
     throw error;
@@ -361,7 +416,11 @@ async function readAppManifest(
   }
   const manifest = appManifestSchema.safeParse(parsedJson);
   if (!manifest.success) {
-    throw new ApiError(422, "invalid_request", "Invalid app manifest");
+    throw new InvalidAppManifestError({
+      appId: args.appId,
+      target: args.target,
+      issues: manifest.error.issues,
+    });
   }
   if (manifest.data.id !== args.appId) {
     throw new ApiError(
@@ -373,6 +432,23 @@ async function readAppManifest(
   return manifest.data;
 }
 
+async function readAppManifestForRequest(
+  deps: AppDeps,
+  args: AppManifestReadArgs,
+): Promise<AppManifest> {
+  try {
+    return await readAppManifest(deps, args);
+  } catch (error) {
+    if (error instanceof InvalidAppManifestError) {
+      logInvalidAppManifest(deps, {
+        error,
+        message: "Rejected invalid thread app manifest",
+      });
+    }
+    throw error;
+  }
+}
+
 function entryKindForPath(entryPath: string): AppEntry["kind"] {
   const normalized = entryPath.toLowerCase();
   if (normalized.endsWith(".html")) {
@@ -504,7 +580,7 @@ async function buildAppDetail(
 ): Promise<AppDetail> {
   let manifest: AppManifest;
   try {
-    manifest = await readAppManifest(deps, args);
+    manifest = await readAppManifestForRequest(deps, args);
   } catch (error) {
     if (
       error instanceof ApiError &&
@@ -570,17 +646,37 @@ async function listThreadApps(
     .map((entry) => entry.data)
     .sort((left, right) => left.localeCompare(right));
 
-  return Promise.all(
-    appIds.map(async (appId) => {
+  const summaries: AppSummary[] = [];
+  for (const appId of appIds) {
+    try {
       const manifest = await readAppManifest(deps, { appId, target });
-      return buildAppSummary(deps, {
-        appId,
-        target,
-        manifest,
-        requestThreadId: threadId,
-      });
-    }),
-  );
+      summaries.push(
+        await buildAppSummary(deps, {
+          appId,
+          target,
+          manifest,
+          requestThreadId: threadId,
+        }),
+      );
+    } catch (error) {
+      if (error instanceof InvalidAppManifestError) {
+        logInvalidAppManifest(deps, {
+          error,
+          message: "Skipping invalid thread app manifest",
+        });
+        continue;
+      }
+      throw error;
+    }
+  }
+  return summaries;
+}
+
+async function validateAppManifestForServe(
+  deps: AppDeps,
+  args: AppManifestReadArgs,
+): Promise<void> {
+  await readAppManifestForRequest(deps, args);
 }
 
 function createHtmlResponse(html: string): Response {
@@ -641,7 +737,7 @@ async function serveAppEntry(
 ): Promise<Response> {
   const appId = parseAppId(rawAppId);
   const target = await requireThreadAppsTarget(deps, threadId);
-  const manifest = await readAppManifest(deps, { appId, target });
+  const manifest = await readAppManifestForRequest(deps, { appId, target });
   const entry = await resolveAppEntry(deps, { appId, target, manifest });
   if (entry.kind !== "html") {
     throw new ApiError(404, "invalid_request", "App entry is not HTML");
@@ -685,6 +781,7 @@ async function serveAppAsset(
   const appId = parseAppId(rawAppId);
   const assetPath = parseAppAssetPath(rawPath);
   const target = await requireThreadAppsTarget(deps, threadId);
+  await validateAppManifestForServe(deps, { appId, target });
   try {
     const result = await readAppRelativeFile(deps, {
       appId,
@@ -711,7 +808,7 @@ async function serveAppIcon(
 ): Promise<Response> {
   const appId = parseAppId(rawAppId);
   const target = await requireThreadAppsTarget(deps, threadId);
-  const manifest = await readAppManifest(deps, { appId, target });
+  const manifest = await readAppManifestForRequest(deps, { appId, target });
   if (manifest.icon !== undefined) {
     throw new ApiError(404, "ENOENT", "App uses a built-in icon");
   }
@@ -951,7 +1048,7 @@ async function scaffoldApp(
   args: ScaffoldAppArgs,
 ): Promise<AppDetail> {
   try {
-    await readAppManifest(deps, {
+    await readAppManifestForRequest(deps, {
       appId: args.request.id,
       target: args.target,
     });
@@ -1052,7 +1149,7 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
       );
       const appId = parseAppId(context.req.param("appId"));
       assertAppCapability(
-        await readAppManifest(deps, { appId, target }),
+        await readAppManifestForRequest(deps, { appId, target }),
         "data",
       );
       const dataPath = parseOptionalAppDataPrefix(query.prefix);
@@ -1071,7 +1168,7 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
     appMessageRequestSchema,
     async (context, payload) => {
       const thread = requirePublicThread(deps.db, context.req.param("id"));
-      const manifest = await readAppManifest(deps, {
+      const manifest = await readAppManifestForRequest(deps, {
         appId: parseAppId(context.req.param("appId")),
         target: await requireThreadAppsTarget(deps, thread.id),
       });
@@ -1108,7 +1205,10 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
   get("/threads/:id/apps/:appId/data/*", async (context) => {
     const target = await requireThreadAppsTarget(deps, context.req.param("id"));
     const appId = parseAppId(context.req.param("appId"));
-    assertAppCapability(await readAppManifest(deps, { appId, target }), "data");
+    assertAppCapability(
+      await readAppManifestForRequest(deps, { appId, target }),
+      "data",
+    );
     const dataPath = parseAppDataRoutePath(
       extractRoutePath({
         requestUrl: context.req.url,
@@ -1135,7 +1235,10 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
         context.req.param("id"),
       );
       const appId = parseAppId(context.req.param("appId"));
-      const manifest = await readAppManifest(deps, { appId, target });
+      const manifest = await readAppManifestForRequest(deps, {
+        appId,
+        target,
+      });
       assertAppCapability(manifest, "data");
       const dataPath = parseAppDataRoutePath(
         extractRoutePath({
@@ -1159,7 +1262,7 @@ export function registerThreadAppRoutes(app: Hono, deps: AppDeps): void {
   del("/threads/:id/apps/:appId/data/*", async (context) => {
     const target = await requireThreadAppsTarget(deps, context.req.param("id"));
     const appId = parseAppId(context.req.param("appId"));
-    const manifest = await readAppManifest(deps, { appId, target });
+    const manifest = await readAppManifestForRequest(deps, { appId, target });
     assertAppCapability(manifest, "data");
     const dataPath = parseAppDataRoutePath(
       extractRoutePath({
diff --git a/apps/server/test/public/public-thread-apps.test.ts b/apps/server/test/public/public-thread-apps.test.ts
index 2fb77f74a..eaeeedd58 100644
--- a/apps/server/test/public/public-thread-apps.test.ts
+++ b/apps/server/test/public/public-thread-apps.test.ts
@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import type { JsonValue } from "@bb/domain";
 import type { HostDaemonCommand } from "@bb/host-daemon-contract";
 import {
   appDataListResponseSchema,
@@ -10,7 +11,7 @@ import {
   appSummarySchema,
   type AppManifest,
 } from "@bb/server-contract";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import {
   reportQueuedCommandError,
   reportQueuedCommandSuccess,
@@ -51,7 +52,7 @@ interface ManifestReadArgs {
   afterCursor?: number;
   fixture: ManagerThreadStorageFixture;
   harness: TestAppHarness;
-  manifest: AppManifest;
+  manifest: JsonValue;
 }
 
 type WriteFileRelativeQueuedCommand = QueuedCommand<
@@ -233,6 +234,66 @@ describe("public thread app routes", () => {
     }
   });
 
+  it("skips invalid app manifests when listing app summaries", async () => {
+    const harness = await createTestAppHarness();
+    const warn = vi.spyOn(harness.deps.logger, "warn");
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps`,
+      );
+      const listCommand = await waitForQueuedCommand(
+        harness,
+        ({ command }) =>
+          command.type === "host.list_paths" &&
+          command.path === `${fixture.storageRootPath}/apps`,
+      );
+      await reportQueuedCommandSuccess(harness, listCommand, {
+        paths: [
+          pathEntry({ kind: "directory", path: "broken" }),
+          pathEntry({ kind: "directory", path: "status" }),
+        ],
+        truncated: false,
+      });
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "broken",
+        afterCursor: listCommand.row.cursor,
+        manifest: {
+          ...STATUS_MANIFEST,
+          id: "broken",
+          name: "Broken",
+          icon: "NotAnIcon",
+        },
+      });
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "status",
+        afterCursor: listCommand.row.cursor,
+        manifest: STATUS_MANIFEST,
+      });
+
+      const response = await request;
+      expect(response.status).toBe(200);
+      const apps = appSummarySchema.array().parse(await readJson(response));
+      expect(apps.map((app) => app.id)).toEqual(["status"]);
+      expect(warn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          appId: "broken",
+          manifestPath: `${appRoot(fixture, "broken")}/manifest.json`,
+          issueSummary: expect.stringContaining("icon"),
+          issues: expect.any(Array),
+        }),
+        "Skipping invalid thread app manifest",
+      );
+    } finally {
+      warn.mockRestore();
+      await harness.cleanup();
+    }
+  });
+
   it("returns a provisioned-app error when app detail is missing manifest.json", async () => {
     const harness = await createTestAppHarness();
     try {
@@ -263,6 +324,68 @@ describe("public thread app routes", () => {
     }
   });
 
+  it("returns an invalid-manifest error when app detail manifest validation fails", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/broken`,
+      );
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "broken",
+        manifest: {
+          ...STATUS_MANIFEST,
+          id: "broken",
+          name: "Broken",
+          icon: "NotAnIcon",
+        },
+      });
+
+      const response = await request;
+      expect(response.status).toBe(422);
+      const body = await readJson(response);
+      expect(body).toMatchObject({
+        code: "invalid_manifest",
+        message: expect.stringContaining("failed validation"),
+      });
+      expect(JSON.stringify(body)).not.toContain("NotAnIcon");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("returns an invalid-manifest error before serving app assets", async () => {
+    const harness = await createTestAppHarness();
+    try {
+      const fixture = seedManagerThreadStorage(harness);
+      const request = harness.app.request(
+        `/api/v1/threads/${fixture.threadId}/apps/broken/index.html`,
+      );
+      await reportManifestRead({
+        harness,
+        fixture,
+        appId: "broken",
+        manifest: {
+          ...STATUS_MANIFEST,
+          id: "broken",
+          name: "Broken",
+          icon: "NotAnIcon",
+        },
+      });
+
+      const response = await request;
+      expect(response.status).toBe(422);
+      await expect(readJson(response)).resolves.toMatchObject({
+        code: "invalid_manifest",
+        message: expect.stringContaining("failed validation"),
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
   it("serves HTML app entries with capability-scoped window.bb injection", async () => {
     const harness = await createTestAppHarness();
     try {
@@ -330,8 +453,15 @@ describe("public thread app routes", () => {
       const request = harness.app.request(
         `/api/v1/threads/${fixture.threadId}/apps/status/index-Cd7sCqsN.js`,
       );
-      const assetCommand = await waitForQueuedCommand(
+      const manifestCommand = await reportManifestRead({
         harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const assetCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
         ({ command }) =>
           command.type === "host.read_file_relative" &&
           command.rootPath === appAssetsRoot(fixture, "status") &&
@@ -367,8 +497,15 @@ describe("public thread app routes", () => {
       const request = harness.app.request(
         `/api/v1/threads/${fixture.threadId}/apps/status/chunks/index-Cd7sCqsN.js`,
       );
-      const assetCommand = await waitForQueuedCommand(
+      const manifestCommand = await reportManifestRead({
         harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const assetCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
         ({ command }) =>
           command.type === "host.read_file_relative" &&
           command.rootPath === appAssetsRoot(fixture, "status") &&
@@ -411,8 +548,15 @@ describe("public thread app routes", () => {
       const request = serverApp.app.request(
         `/api/v1/threads/${fixture.threadId}/apps/status/missing.js`,
       );
-      const assetCommand = await waitForQueuedCommand(
+      const manifestCommand = await reportManifestRead({
         harness,
+        fixture,
+        appId: "status",
+        manifest: STATUS_MANIFEST,
+      });
+      const assetCommand = await waitForQueuedCommandAfter(
+        harness,
+        manifestCommand.row.cursor,
         ({ command }) =>
           command.type === "host.read_file_relative" &&
           command.rootPath === appAssetsRoot(fixture, "status") &&
diff --git a/packages/server-contract/src/errors.ts b/packages/server-contract/src/errors.ts
index 4830c51c0..48226b300 100644
--- a/packages/server-contract/src/errors.ts
+++ b/packages/server-contract/src/errors.ts
@@ -5,11 +5,12 @@ import {
   threadStatusSchema,
 } from "@bb/domain";
 
-/** Closed set of well-known error codes emitted by server-side domain logic.
+/** Closed set of well-known error codes emitted by server-side logic.
  *  The base public ApiError envelope keeps `code` open as a string so routes
  *  can return additional route-specific values without widening this enum. */
 export const domainErrorCodeSchema = z.enum([
   "invalid_request",
+  "invalid_manifest",
   "awaiting_user_interaction",
   "thread_not_found",
   "project_not_found",

From 6ea5ff4de51c25ee8b440d9407cb8e0e6c2a77a4 Mon Sep 17 00:00:00 2001
From: Sawyer Hood <sawyerjhood@gmail.com>
Date: Thu, 28 May 2026 14:38:49 -0700
Subject: [PATCH 13/13] app: fix exhaustive-deps lint on Create App handler

useCallback dep list had `promptDraft.getCurrent` / `promptDraft.setDraft`
broken out; react-hooks/exhaustive-deps wants `promptDraft` itself.
Replaced both with the parent object.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/components/secondary-panel/NewTabFileSearch.tsx    | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
index 564610410..a8c3f504a 100644
--- a/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
+++ b/apps/app/src/components/secondary-panel/NewTabFileSearch.tsx
@@ -493,12 +493,7 @@ export function NewTabFileSearch({
 
     promptDraft.setDraft(CREATE_APP_PROMPT_DRAFT);
     onCreateAppPromptPrefill?.();
-  }, [
-    canPrefillCreateAppPrompt,
-    onCreateAppPromptPrefill,
-    promptDraft.getCurrent,
-    promptDraft.setDraft,
-  ]);
+  }, [canPrefillCreateAppPrompt, onCreateAppPromptPrefill, promptDraft]);
 
   const handleInputKeyDown = useCallback<SearchInputKeyDownHandler>(
     (event) => {