@ai-ecoverse/slicc-spectrum 1.1.0 → 1.2.0

package/dist/slicc-dummy.js

@@ -1,7 +1,7 @@
 import {
   Emitter
 } from "./chunk-T5NHW4KC.js";
-import "./chunk-Q4AC2O6Z.js";
+import "./chunk-AXQFWXYZ.js";
 
 // src/dummy/script.ts
 var units = "/workspace/harbor/src/lib/units.ts";
@@ -56,6 +56,18 @@ function edit() {
         await files3.write(units, before + kelvin, agentId);
       }
     },
+    {
+      type: "part",
+      part: {
+        type: "diff",
+        path: units,
+        before: "export function toFahrenheit(celsius: number): number {\n  return Math.round((celsius * 9) / 5 + 32);\n}\n",
+        after: `export function toFahrenheit(celsius: number): number {
+  return Math.round((celsius * 9) / 5 + 32);
+}
+${kelvin}`
+      }
+    },
     {
       type: "text",
       text: "Added `toKelvin()` to `src/lib/units.ts`. It rounds to two decimals, like the API\u2019s other values. The change is in **Changes**, ready for review."
@@ -125,36 +137,110 @@ function chat(prompt) {
     }
   ];
 }
-function script(prompt) {
+function ask() {
+  return [
+    { type: "thinking", text: "Two ways to do this. Ask before picking one." },
+    {
+      type: "part",
+      part: {
+        type: "question",
+        question: {
+          id: `q-${Math.random().toString(36).slice(2, 8)}`,
+          kind: "choice",
+          question: "Where should the cache live once the TTL fix ships?",
+          options: ["Keep it in memory", "Move it to KV", "Decide after the load test"],
+          state: "open"
+        }
+      }
+    }
+  ];
+}
+function look(attachments) {
+  const names = attachments.map((attachment) => attachment.name).join(", ");
+  const images = attachments.filter((attachment) => attachment.kind === "image").length;
+  return [
+    {
+      type: "tool",
+      name: "read_file",
+      title: `Read ${attachments.length === 1 ? "the attachment" : `${attachments.length} attachments`}`,
+      input: names,
+      output: attachments.map(
+        (attachment) => `${attachment.name} (${attachment.mimeType}, ${attachment.size} bytes)`
+      ).join("\n"),
+      paths: [],
+      ticks: 10
+    },
+    {
+      type: "text",
+      text: `Got **${names}**${images ? `, including ${images === 1 ? "an image" : `${images} images`}` : ""}. I\u2019ll keep ${attachments.length === 1 ? "it" : "them"} in mind for the next step.`
+    }
+  ];
+}
+var suggestions = [
+  [/\btests?\b/, "Open a pull request with the fix"],
+  [/\b(fix|edit|add|change)\b/, "Run the tests"],
+  [/\b(open|browse|page|docs)\b/, "Summarize the page"],
+  [/\b(files?|read|show|project)\b/, "Add a Kelvin helper to units.ts"]
+];
+function script(prompt, attachments = []) {
   const text = prompt.toLowerCase();
-  if (/\btests?\b/.test(text)) return test();
-  if (/\b(fix|edit|add|change)\b/.test(text)) return edit();
-  if (/\b(open|browse|page|docs)\b/.test(text)) return browse();
-  if (/\b(files?|read|show|project)\b/.test(text)) return files();
-  return chat(prompt);
+  const suggestion = suggestions.find(([pattern]) => pattern.test(text))?.[1] ?? "Run the tests";
+  if (attachments.length > 0) return { steps: look(attachments), suggestion };
+  if (/\b(ask|choose|decide)\b/.test(text)) return { steps: ask(), suggestion };
+  if (/\btests?\b/.test(text)) return { steps: test(), suggestion };
+  if (/\b(fix|edit|add|change)\b/.test(text)) return { steps: edit(), suggestion };
+  if (/\b(open|browse|page|docs)\b/.test(text)) return { steps: browse(), suggestion };
+  if (/\b(files?|read|show|project)\b/.test(text)) return { steps: files(), suggestion };
+  return { steps: chat(prompt), suggestion };
 }
 
 // src/dummy/agent.ts
 function chunks(text) {
   return text.match(/\S+\s*|\s+/g) ?? [];
 }
+function outgoing(input) {
+  return typeof input === "string" ? { text: input } : input;
+}
 var DummyAgent = class extends Emitter {
   #agents;
   #messages = /* @__PURE__ */ new Map();
+  #queues = /* @__PURE__ */ new Map();
+  #frozen = [];
+  #ice = /* @__PURE__ */ new Map();
+  #suggestions = /* @__PURE__ */ new Map();
   #runs = /* @__PURE__ */ new Map();
   #active;
   #clock;
   #effects;
   #next = 1;
-  constructor(agents2, conversations2, effects, clock2) {
+  constructor(agents2, conversations2, effects, clock2, queues2 = {}, frozen2 = []) {
     super();
     this.#clock = clock2;
     this.#effects = effects;
     this.#agents = agents2.map((agent) => ({ ...agent }));
     for (const agent of this.#agents) {
       this.#messages.set(agent.id, structuredClone([...conversations2[agent.id] ?? []]));
+      this.#queues.set(agent.id, structuredClone([...queues2[agent.id] ?? []]));
     }
     this.#active = this.#agents[0]?.id ?? "";
+    for (const { cone, messages } of frozen2) {
+      this.#frozen.push({ ...cone });
+      this.#ice.set(cone.id, [
+        {
+          agent: {
+            id: cone.id,
+            name: cone.name,
+            kind: "cone",
+            parentId: null,
+            status: "idle",
+            model: cone.model,
+            contextFill: 0.2,
+            unread: 0
+          },
+          messages: structuredClone([...messages])
+        }
+      ]);
+    }
   }
   list() {
     return this.#agents.map((agent) => ({ ...agent }));
@@ -168,6 +254,9 @@ var DummyAgent = class extends Emitter {
   #changed() {
     this.emit("agents", this.list());
   }
+  #id(prefix) {
+    return `${prefix}-${this.#next++}`;
+  }
   select(id) {
     const agent = this.#agent(id);
     if (!agent) return;
@@ -179,6 +268,15 @@ var DummyAgent = class extends Emitter {
   messages(agentId) {
     return [...this.#messages.get(agentId) ?? []];
   }
+  queue(agentId) {
+    return [...this.#queues.get(agentId) ?? []];
+  }
+  busy(agentId) {
+    return this.#runs.has(agentId);
+  }
+  suggestion(agentId) {
+    return this.#suggestions.get(agentId) ?? null;
+  }
   #post(agentId, message) {
     this.#messages.get(agentId)?.push(message);
     this.emit("message", { agentId, message });
@@ -197,17 +295,10 @@ var DummyAgent = class extends Emitter {
       this.emit("message", { agentId, message: reply });
     }
   }
-  async #step(agentId, reply, step, run) {
-    if (step.type !== "tool") {
-      this.#status(agentId, "thinking");
-      const part = { type: step.type, text: "" };
-      reply.parts.push(part);
-      await this.#stream(agentId, reply, part, step.text, run);
-      return;
-    }
+  async #tool(agentId, reply, step, run) {
     this.#status(agentId, "working");
-    const tool = {
-      id: `t-${this.#next++}`,
+    const tool2 = {
+      id: this.#id("t"),
       name: step.name,
       title: step.title,
       input: step.input,
@@ -215,50 +306,263 @@ var DummyAgent = class extends Emitter {
       status: "running",
       paths: step.paths
     };
-    reply.parts.push({ type: "tool", tool });
+    reply.parts.push({ type: "tool", tool: tool2 });
     this.emit("message", { agentId, message: reply });
     await this.#clock.sleep(step.ticks);
-    const done = run.stopped ? { status: "error", output: "Stopped" } : { status: "done", output: step.output };
+    const done = run.stopped ? { status: "cancelled", output: "Stopped" } : { status: "done", output: step.output };
     if (!run.stopped) await step.effect?.({ ...this.#effects, agentId });
-    Object.assign(tool, done);
+    Object.assign(tool2, done);
     this.emit("message", { agentId, message: reply });
   }
-  async send(agentId, text) {
+  async #step(agentId, reply, step, run) {
+    if (step.type === "tool") return this.#tool(agentId, reply, step, run);
+    if (step.type === "part") {
+      await this.#clock.sleep(2);
+      if (run.stopped) return;
+      reply.parts.push(structuredClone(step.part));
+      this.emit("message", { agentId, message: reply });
+      return;
+    }
+    this.#status(agentId, "thinking");
+    const part = { type: step.type, text: "" };
+    reply.parts.push(part);
+    await this.#stream(agentId, reply, part, step.text, run);
+  }
+  #enqueue(agentId, input) {
+    const message = {
+      id: this.#id("q"),
+      role: "user",
+      text: input.text.trim(),
+      createdAt: Date.now(),
+      queued: true,
+      mode: "queue",
+      ...input.attachments?.length ? { attachments: input.attachments } : {}
+    };
+    this.#queues.set(agentId, [...this.queue(agentId), message]);
+    this.emit("messages", agentId);
+  }
+  unqueue(agentId, messageId) {
+    this.#queues.set(
+      agentId,
+      this.queue(agentId).filter((message) => message.id !== messageId)
+    );
+    this.emit("messages", agentId);
+  }
+  async send(agentId, input) {
     const agent = this.#agent(agentId);
-    const prompt = text.trim();
-    if (!agent || !prompt) return;
+    const message = outgoing(input);
+    const prompt = message.text.trim();
+    if (!agent || !prompt && !message.attachments?.length) return;
+    if (this.busy(agentId) && message.mode !== "steer") {
+      this.#enqueue(agentId, message);
+      return;
+    }
     this.stop(agentId);
+    this.#suggestions.delete(agentId);
     const run = { stopped: false };
     this.#runs.set(agentId, run);
     this.#post(agentId, {
-      id: `m-${this.#next++}`,
+      id: this.#id("m"),
       role: "user",
       text: prompt,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      ...message.mode === "steer" ? { mode: "steer" } : {},
+      ...message.attachments?.length ? { attachments: message.attachments } : {}
     });
     const reply = {
-      id: `m-${this.#next++}`,
+      id: this.#id("m"),
       role: "assistant",
       parts: [],
       status: "streaming",
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      model: agent.model
     };
     this.#post(agentId, reply);
-    for (const step of script(prompt)) {
+    const { steps, suggestion } = script(prompt, message.attachments ?? []);
+    for (const step of steps) {
       if (run.stopped) break;
       await this.#step(agentId, reply, step, run);
     }
     reply.status = run.stopped ? "stopped" : "done";
+    reply.usage = {
+      input: 1200 + prompt.length * 4,
+      output: 180 + reply.parts.length * 60,
+      cost: 4e-3
+    };
     if (this.#runs.get(agentId) === run) this.#runs.delete(agentId);
     agent.contextFill = Math.min(0.95, Math.round((agent.contextFill + 0.03) * 100) / 100);
     if (agentId !== this.#active) agent.unread += 1;
+    if (!run.stopped) this.#suggestions.set(agentId, suggestion);
     this.emit("message", { agentId, message: reply });
     agent.status = "idle";
     this.#changed();
+    await this.#drain(agentId);
+  }
+  async #drain(agentId) {
+    if (this.busy(agentId)) return;
+    const [next, ...rest] = this.queue(agentId);
+    if (!next) return;
+    this.#queues.set(agentId, rest);
+    this.emit("messages", agentId);
+    await this.send(agentId, { text: next.text, attachments: next.attachments });
   }
   stop(agentId) {
     const run = this.#runs.get(agentId);
     if (run) run.stopped = true;
+    this.#runs.delete(agentId);
+  }
+  #find(agentId, test2) {
+    return this.#messages.get(agentId)?.find(test2);
+  }
+  answer(agentId, questionId, answer) {
+    const message = this.#find(
+      agentId,
+      (candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part.type === "question" && part.question.id === questionId)
+    );
+    if (!message) return;
+    for (const part of message.parts) {
+      if (part.type === "question" && part.question.id === questionId) {
+        part.question.state = "answered";
+        part.question.answer = answer;
+      }
+    }
+    this.emit("message", { agentId, message });
+  }
+  resolveLick(agentId, messageId, state) {
+    const message = this.#find(agentId, (candidate) => candidate.id === messageId);
+    if (message?.role !== "lick") return;
+    message.state = state;
+    this.emit("message", { agentId, message });
+  }
+  compact(agentId) {
+    const agent = this.#agent(agentId);
+    if (!agent) return;
+    const message = {
+      id: this.#id("m"),
+      role: "system",
+      kind: "compaction",
+      title: "Context compacted",
+      text: "Summarizing the conversation so far\u2026",
+      trigger: "manual",
+      state: "summarizing",
+      createdAt: Date.now()
+    };
+    this.#post(agentId, message);
+    void this.#clock.sleep(20).then(() => {
+      Object.assign(message, {
+        state: "summarized",
+        text: "The earlier conversation was summarized to free up context."
+      });
+      agent.contextFill = 0.06;
+      this.emit("message", { agentId, message });
+      this.#changed();
+    });
+  }
+  clear(agentId) {
+    if (!this.#messages.has(agentId)) return;
+    this.stop(agentId);
+    this.#messages.set(agentId, []);
+    this.#suggestions.delete(agentId);
+    this.emit("messages", agentId);
+  }
+  setModel(agentId, model) {
+    const agent = this.#agent(agentId);
+    if (!agent) return;
+    agent.model = model;
+    this.#changed();
+  }
+  createScoop(parentId, name) {
+    const parent = this.#agent(parentId);
+    const agent = {
+      id: this.#id("scoop"),
+      name,
+      kind: "scoop",
+      parentId: parent?.kind === "cone" ? parent.id : parent?.parentId ?? null,
+      status: "idle",
+      model: parent?.model ?? "claude-haiku-4-5",
+      contextFill: 0,
+      unread: 0
+    };
+    this.#agents.push(agent);
+    this.#messages.set(agent.id, []);
+    if (parent) {
+      this.#post(parentId, {
+        id: this.#id("m"),
+        role: "lick",
+        channel: "scoop-idle",
+        title: name,
+        text: "New scoop, waiting for its first task",
+        createdAt: Date.now()
+      });
+    }
+    this.#changed();
+    return { ...agent };
+  }
+  lick(agentId, channel, title, text, body) {
+    if (!this.#agent(agentId)) return;
+    this.#post(agentId, {
+      id: this.#id("m"),
+      role: "lick",
+      channel,
+      title,
+      text,
+      createdAt: Date.now(),
+      ...body ? { body } : {}
+    });
+  }
+  frozen() {
+    return this.#frozen.map((cone) => ({ ...cone }));
+  }
+  freeze(agentId) {
+    const agent = this.#agent(agentId);
+    if (agent?.kind !== "cone") return;
+    this.stop(agentId);
+    const family = this.#agents.filter(
+      (candidate) => candidate.id === agentId || candidate.parentId === agentId
+    );
+    const messages = this.#messages.get(agentId) ?? [];
+    const first = messages.find((message) => message.role === "user");
+    this.#frozen.unshift({
+      id: agentId,
+      name: agent.name,
+      title: first?.role === "user" ? first.text.slice(0, 80) : agent.name,
+      model: agent.model,
+      messages: messages.length,
+      frozenAt: Date.now()
+    });
+    this.#ice.set(
+      agentId,
+      family.map((member) => ({
+        agent: { ...member, status: "idle" },
+        messages: this.#messages.get(member.id)
+      }))
+    );
+    for (const member of family) this.stop(member.id);
+    this.#agents = this.#agents.filter((candidate) => !family.includes(candidate));
+    for (const member of family) this.#messages.delete(member.id);
+    if (this.#active === agentId) this.#active = this.#agents[0]?.id ?? "";
+    this.emit("frozen", this.frozen());
+    this.emit("active", this.#active);
+    this.#changed();
+  }
+  thaw(id) {
+    const ice = this.#ice.get(id);
+    if (!ice) return null;
+    this.#ice.delete(id);
+    this.#frozen = this.#frozen.filter((cone) => cone.id !== id);
+    for (const { agent, messages } of ice) {
+      this.#agents.push(agent);
+      this.#messages.set(agent.id, messages);
+      this.#queues.set(agent.id, []);
+    }
+    this.emit("frozen", this.frozen());
+    this.select(id);
+    return { ...ice[0].agent };
+  }
+  discard(id) {
+    this.#ice.delete(id);
+    this.#frozen = this.#frozen.filter((cone) => cone.id !== id);
+    this.emit("frozen", this.frozen());
   }
 };
 
@@ -281,6 +585,7 @@ function page(tab) {
 }
 function titleFor(url) {
   const { host, pathname } = new URL(url);
+  if (!host) return "New tab";
   return pathname === "/" ? host : `${host}${pathname}`;
 }
 var DummyBrowser = class extends Emitter {
@@ -365,6 +670,210 @@ function clock(delay) {
   };
 }
 
+// src/dummy/extras.ts
+var day = 864e5;
+var now = Date.UTC(2026, 9, 5, 9, 0);
+function frozenConversation(topic, reply) {
+  return [
+    { id: `f-${topic}-1`, role: "user", text: topic, createdAt: now - 3 * day },
+    {
+      id: `f-${topic}-2`,
+      role: "assistant",
+      status: "done",
+      createdAt: now - 3 * day + 6e4,
+      parts: [{ type: "text", text: reply }]
+    }
+  ];
+}
+var frozen = [
+  {
+    cone: {
+      id: "cone-onboarding",
+      name: "onboarding",
+      title: "Write the onboarding guide for new contributors",
+      model: "claude-sonnet-5-5",
+      messages: 42,
+      frozenAt: now - 2 * day
+    },
+    messages: frozenConversation(
+      "Write the onboarding guide for new contributors",
+      "The guide is in `/workspace/harbor/docs/onboarding.md`, with setup, tests and the release checklist."
+    )
+  },
+  {
+    cone: {
+      id: "cone-kv-spike",
+      name: "kv-spike",
+      title: "Spike: can the cache move to KV without a cold start?",
+      model: "claude-opus-5-5",
+      messages: 118,
+      frozenAt: now - 6 * day
+    },
+    messages: frozenConversation(
+      "Spike: can the cache move to KV without a cold start?",
+      "Yes, with a 5-minute in-memory layer in front. Reads from KV add 12 ms at the 95th percentile."
+    )
+  },
+  {
+    cone: {
+      id: "cone-q3-report",
+      name: "q3-report",
+      title: "Summarize Q3 uptime and incidents",
+      model: "claude-haiku-4-5",
+      messages: 17,
+      frozenAt: now - 21 * day
+    },
+    messages: frozenConversation(
+      "Summarize Q3 uptime and incidents",
+      "Uptime 99.96%. Two incidents: an expired certificate and an upstream outage."
+    )
+  }
+];
+var memories = [
+  {
+    id: "mem-1",
+    scope: "global",
+    section: "Preferences",
+    title: "Lead with the result",
+    body: "Keep replies short. Lead with the result, then the evidence.",
+    tag: "feedback",
+    updatedAt: now - 5 * day
+  },
+  {
+    id: "mem-2",
+    scope: "global",
+    section: "Preferences",
+    title: "Tests before \u201Cfixed\u201D",
+    body: "Run the tests before saying something is fixed, and quote the summary line.",
+    tag: "feedback",
+    updatedAt: now - 9 * day
+  },
+  {
+    id: "mem-3",
+    scope: "global",
+    section: "About the user",
+    title: "Works in UTC",
+    body: "Schedules, timestamps and cron expressions are in UTC unless stated otherwise.",
+    tag: "user",
+    updatedAt: now - 30 * day
+  },
+  {
+    id: "mem-4",
+    scope: "global",
+    section: "Projects",
+    title: "harbor",
+    body: "Forecast API, deployed as a worker. Cache bugs show up around midnight UTC. Staging deploys are frozen on Fridays.",
+    tag: "project",
+    updatedAt: now - day
+  },
+  {
+    id: "mem-5",
+    scope: "global",
+    section: "Projects",
+    title: "release-notes",
+    body: "Drafted every Friday from merged pull requests, grouped as features, fixes and chores.",
+    tag: "project",
+    updatedAt: now - 4 * day
+  },
+  {
+    id: "mem-6",
+    scope: "cone-harbor",
+    section: "Conventions",
+    title: "Cache keys",
+    body: "Cache keys are `city:UTC-date`. Never key on local time.",
+    tag: "project",
+    updatedAt: now - 2 * day
+  },
+  {
+    id: "mem-7",
+    scope: "cone-harbor",
+    section: "Conventions",
+    title: "Retries",
+    body: "Retry upstream calls three times with exponential backoff starting at 250 ms.",
+    tag: null,
+    updatedAt: now - 2 * day
+  },
+  {
+    id: "mem-8",
+    scope: "cone-release",
+    section: "Style",
+    title: "Past tense, no ticket numbers",
+    body: "One sentence per change, in the past tense, without ticket numbers.",
+    tag: "feedback",
+    updatedAt: now - 7 * day
+  }
+];
+var sprinkleStyle = `
+body { margin: 0; padding: 16px; font: 13px/1.45 var(--font, system-ui, sans-serif); color: var(--fg); background: var(--bg); }
+h1 { font-size: 15px; margin: 0 0 12px; }
+ul { list-style: none; padding: 0; margin: 0 0 12px; display: grid; gap: 6px; }
+li { display: flex; gap: 8px; align-items: center; padding: 6px 8px; border: 1px solid var(--line); border-radius: 6px; }
+li .state { margin-left: auto; color: var(--muted); }
+li.done .state { color: var(--positive); }
+button { font: inherit; padding: 4px 12px; border-radius: 14px; border: 1px solid var(--line); background: var(--bg); color: var(--fg); cursor: pointer; }
+button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
+.actions { display: flex; gap: 8px; }
+p.note { color: var(--muted); }
+`;
+var sprinkleScript = `
+document.addEventListener('click', (event) => {
+  const button = event.target.closest('[data-event]');
+  if (!button) return;
+  parent.postMessage({ type: 'sprinkle-event', event: button.dataset.event, detail: button.dataset.detail ?? null }, '*');
+  const note = document.querySelector('.note');
+  if (note) note.textContent = 'Sent \u201C' + button.textContent.trim() + '\u201D to the agent.';
+});
+`;
+function page2(body) {
+  return `<!doctype html><html><head><meta charset="utf-8"><style>${sprinkleStyle}</style></head><body>${body}<script>${sprinkleScript}<\/script></body></html>`;
+}
+var sprinkles = [
+  {
+    id: "release-board",
+    name: "release-board",
+    title: "Release board",
+    icon: "sp-icon-checkmark-circle",
+    agentId: "cone-release",
+    html: page2(`<h1>harbor 1.9.0</h1>
+<ul>
+  <li class="done">Retry pull request merged <span class="state">done</span></li>
+  <li class="done">Release notes drafted <span class="state">done</span></li>
+  <li>Docs updated to Celsius <span class="state">in review</span></li>
+  <li>Staging smoke test <span class="state">waiting</span></li>
+</ul>
+<div class="actions"><button class="primary" data-event="ship" data-detail="1.9.0">Ship 1.9.0</button><button data-event="hold">Hold</button></div>
+<p class="note"></p>`)
+  },
+  {
+    id: "loose-ends",
+    name: "loose-ends",
+    title: "Loose ends",
+    icon: "sp-icon-filter",
+    agentId: "cone-sliccy",
+    html: page2(`<h1>Loose ends</h1>
+<ul>
+  <li>Reply to the vendor about Thursday <button data-event="done" data-detail="vendor">Done</button></li>
+  <li>Renew the staging certificate <button data-event="done" data-detail="certificate">Done</button></li>
+  <li>Move the cache to KV <button data-event="done" data-detail="kv">Done</button></li>
+</ul>
+<p class="note"></p>`)
+  }
+];
+var tray = {
+  name: "sliccstart",
+  kind: "sliccstart",
+  connection: "live",
+  role: "leader",
+  followers: [
+    { id: "f-phone", name: "Phone", device: "phone", since: now - 36e5 },
+    { id: "f-laptop", name: "Second browser", device: "browser", since: now - 6e5 }
+  ],
+  spent: 23.67,
+  rate: 0.59,
+  budget: { percent: 32, window: "weekly", resets: "resets in 4 days" },
+  joinUrl: "https://www.example.com/join/7Q4D-K9TX"
+};
+
 // src/dummy/files.ts
 function parents(path) {
   const parts = path.split("/").slice(1, -1);
@@ -390,10 +899,10 @@ var DummyFiles = class extends Emitter {
   #mkdirs(path) {
     for (const directory of parents(path)) this.#directories.add(directory);
   }
-  #put(path, text, now) {
+  #put(path, text, now2) {
     this.#mkdirs(path);
     this.#contents.set(path, text);
-    this.#modified.set(path, now);
+    this.#modified.set(path, now2);
   }
   #entries() {
     const directories2 = [...this.#directories].map(
@@ -465,6 +974,672 @@ var DummyFiles = class extends Emitter {
   }
 };
 
+// src/dummy/showcase.ts
+var start = Date.UTC(2026, 9, 4, 16, 0);
+var at = (minutes) => start + minutes * 6e4;
+function picture(label, from, to, width = 640, height = 400) {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="${from}"/><stop offset="1" stop-color="${to}"/></linearGradient></defs><rect width="${width}" height="${height}" fill="url(#g)"/><text x="50%" y="50%" font-family="sans-serif" font-size="${Math.round(height / 9)}" fill="#ffffff" text-anchor="middle" dominant-baseline="middle">${label}</text></svg>`;
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+function tone(seconds = 0.6, frequency = 440, rate = 8e3) {
+  const samples = Math.round(seconds * rate);
+  const bytes = new Uint8Array(44 + samples);
+  const view = new DataView(bytes.buffer);
+  const text = (offset, value) => {
+    for (let i = 0; i < value.length; i++) bytes[offset + i] = value.charCodeAt(i);
+  };
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples, true);
+  text(8, "WAVEfmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, rate, true);
+  view.setUint32(28, rate, true);
+  view.setUint16(32, 1, true);
+  view.setUint16(34, 8, true);
+  text(36, "data");
+  view.setUint32(40, samples, true);
+  for (let i = 0; i < samples; i++) {
+    const fade = Math.min(1, (samples - i) / (rate / 10));
+    bytes[44 + i] = 128 + Math.round(60 * fade * Math.sin(2 * Math.PI * frequency * i / rate));
+  }
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return `data:audio/wav;base64,${btoa(binary)}`;
+}
+function tool(id, name, title, input, output, extra = {}) {
+  return { id, name, title, input, output, status: "done", paths: [], ...extra };
+}
+var markdown = [
+  "## The forecast API in one page",
+  "",
+  "harbor answers `GET /forecast?city=\u2026` with the day\u2019s **high**, **low** and a *short summary*, and caches per city for an hour. ~~XML output~~ is gone.",
+  "",
+  "### How a request flows",
+  "",
+  "1. The worker parses the city.",
+  "2. The cache answers if it has a fresh entry:",
+  "   - same UTC day",
+  "   - younger than one hour",
+  "3. Otherwise the upstream call runs, with three retries.",
+  "",
+  "> Upstream is slow at the top of the hour. Retries back off at 250, 500 and 1000 ms.",
+  "",
+  "```ts",
+  "export async function forecast(city: string): Promise<Forecast> {",
+  "  const cached = cache.get(city);",
+  "  if (cached) return cached;",
+  "  return cache.set(city, await retry(() => upstream(city)));",
+  "}",
+  "```",
+  "",
+  "| Route | Cache | Typical latency |",
+  "| --- | --- | ---: |",
+  "| `/forecast` | 1 hour, per city | 38 ms |",
+  "| `/health` | none | 2 ms |",
+  "| `/forecast` (miss) | \u2014 | 410 ms |",
+  "",
+  "- [x] TTL fix merged",
+  "- [ ] Move the cache to KV",
+  "",
+  "Details are in the [API reference](https://api.example.com/docs/v2/forecast). A long path that must wrap: `/workspace/harbor/node_modules/.cache/wrangler/state/v3/cache/miniflare-CacheObject/7c1f0e3b9a5d4e2f8b6a1c0d9e8f7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f.sqlite`."
+].join("\n");
+var toolShapes = [
+  tool("k-t1", "bash", "Count the routes", "rg -c 'pathname ===' src", "src/index.ts:2"),
+  tool(
+    "k-t2",
+    "read_file",
+    "Read the router",
+    "/workspace/harbor/src/index.ts",
+    "import { forecast } from './routes/forecast.ts';\n\u2026",
+    {
+      paths: ["/workspace/harbor/src/index.ts"]
+    }
+  ),
+  tool(
+    "k-t3",
+    "write_file",
+    "Create the KV binding notes",
+    "/workspace/harbor/docs/kv.md",
+    "Wrote 18 lines",
+    {
+      paths: ["/workspace/harbor/docs/kv.md"]
+    }
+  ),
+  tool(
+    "k-t4",
+    "edit_file",
+    "Rename the cache key",
+    "/workspace/harbor/src/lib/cache.ts",
+    'No match for "cityKey(" in src/lib/cache.ts',
+    {
+      status: "error",
+      paths: ["/workspace/harbor/src/lib/cache.ts"]
+    }
+  ),
+  tool(
+    "k-t5",
+    "grep",
+    "Find TODOs",
+    'TODO --glob "src/**"',
+    "src/routes/forecast.ts:14: TODO: cache negative results\nsrc/lib/units.ts:3: TODO: round half to even"
+  ),
+  tool(
+    "k-t6",
+    "web_fetch",
+    "Fetch the API changelog",
+    "https://api.example.com/changelog.json",
+    '{ "latest": "2.4.1", "breaking": false }'
+  ),
+  tool(
+    "k-t7",
+    "browser",
+    "Screenshot the preview",
+    "screenshot http://localhost:8787/",
+    "Captured 1280\xD7800",
+    {
+      image: picture("localhost:8787", "#3b63fb", "#0a7a43", 640, 400)
+    }
+  ),
+  tool(
+    "k-t8",
+    "scoop_scoop",
+    "Start a scoop for the docs",
+    "name: docs-pass\ntask: Update the forecast page to Celsius",
+    "Scoop docs-pass is running"
+  ),
+  tool(
+    "k-t9",
+    "feed_scoop",
+    "Hand the screenshots to docs-pass",
+    "scoop_name: docs-pass\nmessage: Use the new screenshots in /tmp/shots",
+    "Delivered"
+  ),
+  tool(
+    "k-t10",
+    "send_message",
+    "Tell quiet-otter the tests pass",
+    "to: quiet-otter\nmessage: CI is green, merge when ready",
+    "Delivered"
+  ),
+  tool(
+    "k-t11",
+    "drop_scoop",
+    "Wrap up amber-heron",
+    "scoop_name: amber-heron",
+    "Dropped amber-heron; its notes are in /shared/notes"
+  ),
+  tool(
+    "k-t12",
+    "update_global_memory",
+    "Remember the cache rule",
+    "Cache keys are per city and per UTC day.",
+    "Memory updated (3 sections, 412 characters)"
+  ),
+  tool("k-t13", "bash", "Deploy to staging", "wrangler deploy --env staging", "Stopped", {
+    status: "cancelled"
+  }),
+  tool("k-t14", "bash", "Watch the logs", "wrangler tail --env staging", "", { status: "running" })
+];
+var licks = [
+  [
+    "webhook",
+    "GitHub \xB7 pull_request.opened",
+    "example/harbor#58 Add retries for upstream timeouts",
+    '{\n  "action": "opened",\n  "number": 58,\n  "repository": { "full_name": "example/harbor" }\n}',
+    {}
+  ],
+  [
+    "cron",
+    "Every weekday 09:00",
+    "Morning summary for the harbor cone",
+    void 0,
+    { count: 3 }
+  ],
+  [
+    "sprinkle",
+    "Release board",
+    "Button \u201CShip 1.9.0\u201D clicked",
+    '{ "button": "ship", "version": "1.9.0" }',
+    {}
+  ],
+  [
+    "fswatch",
+    "/workspace/harbor/src",
+    "2 files changed",
+    "modified  /workspace/harbor/src/lib/cache.ts\ncreated   /workspace/harbor/src/lib/retry.ts",
+    {}
+  ],
+  [
+    "session-reload",
+    "Session restored",
+    "The page reloaded; 4 cones resumed from storage",
+    void 0,
+    {}
+  ],
+  [
+    "navigate",
+    "api.example.com",
+    "A page offered a SLICC handoff: open the forecast docs",
+    '{ "verb": "open", "target": "https://api.example.com/docs/v2/forecast" }',
+    {}
+  ],
+  [
+    "discovery",
+    "api.example.com",
+    "Found an ai-catalog.json with 3 tools",
+    "https://api.example.com/.well-known/ai-catalog.json",
+    {}
+  ],
+  ["upgrade", "SLICC updated", "6.4.0 \u2192 6.5.0", void 0, {}],
+  [
+    "workflow",
+    "release-notes",
+    "Step 2 of 4 finished: collect merged pull requests",
+    void 0,
+    {}
+  ],
+  ["bash", "Job 3", "npm run build exited with status 0 after 41 s", void 0, {}],
+  ["jshd", "collect.jsh", "Script finished: 12 pull requests since v1.8.0", void 0, {}],
+  ["preview", "Preview bridge", "Connected from localhost:8787", void 0, {}],
+  [
+    "cherry",
+    "Host page",
+    "Event \u201Ccart-updated\u201D from shop.example.com",
+    '{ "items": 3, "total": 42.5 }',
+    {}
+  ],
+  ["scoop-notify", "docs-pass", "Finished: the forecast page now shows Celsius", void 0, {}],
+  ["scoop-idle", "amber-heron", "Idle for 30 minutes", void 0, {}],
+  ["scoop-wait", "quiet-otter", "The wait for CI resolved: all checks passed", void 0, {}],
+  [
+    "sudo-request",
+    "docs-pass",
+    "Wants to push to example/harbor (branch docs/celsius)",
+    "git push origin docs/celsius",
+    { state: "pending" }
+  ],
+  [
+    "sudo-request",
+    "quiet-otter",
+    "Wants to read secrets: UPSTREAM_TOKEN",
+    void 0,
+    { state: "confirmed" }
+  ],
+  [
+    "sudo-request",
+    "amber-heron",
+    "Wants to run: rm -rf /workspace/harbor/node_modules",
+    void 0,
+    { state: "dismissed" }
+  ]
+];
+var attachmentsMessage = {
+  id: "k-u2",
+  role: "user",
+  text: "Here is the mockup, my notes and the old spec.",
+  createdAt: at(4),
+  attachments: [
+    {
+      id: "k-a1",
+      name: "forecast-card.png",
+      kind: "image",
+      mimeType: "image/png",
+      size: 48211,
+      url: picture("Mockup", "#f5a623", "#d0021b", 480, 320)
+    },
+    {
+      id: "k-a2",
+      name: "notes.txt",
+      kind: "text",
+      mimeType: "text/plain",
+      size: 214,
+      text: "Show \xB0C first.\nRound to whole degrees.\nKeep the summary under 60 characters."
+    },
+    {
+      id: "k-a3",
+      name: "spec-v1.pdf",
+      kind: "file",
+      mimeType: "application/pdf",
+      size: 1204331,
+      path: "/home/user/downloads/spec-v1.pdf"
+    },
+    {
+      id: "k-a4",
+      name: "UPSTREAM_TOKEN",
+      kind: "secret",
+      mimeType: "application/octet-stream",
+      size: 0
+    },
+    {
+      id: "k-a5",
+      name: "recording.mov",
+      kind: "file",
+      mimeType: "video/quicktime",
+      size: 98304e3,
+      error: "Too large: attachments are limited to 25 MB"
+    }
+  ]
+};
+var showcaseAgent = {
+  id: "cone-kitchen",
+  name: "kitchen-sink",
+  kind: "cone",
+  parentId: null,
+  status: "idle",
+  model: "claude-opus-5-5",
+  contextFill: 0.47,
+  unread: 0
+};
+function opening() {
+  return [
+    {
+      id: "k-u1",
+      role: "user",
+      text: "Give me the full tour of harbor, everything you can show.",
+      createdAt: at(0)
+    },
+    {
+      id: "k-m1",
+      role: "assistant",
+      status: "done",
+      createdAt: at(1),
+      model: "claude-opus-5-5",
+      usage: { input: 18204, output: 912, cost: 0.31 },
+      parts: [
+        {
+          type: "thinking",
+          text: "Start with the shape of the API, then show the pieces one kind at a time."
+        },
+        { type: "text", text: markdown }
+      ]
+    },
+    attachmentsMessage,
+    {
+      id: "k-m2",
+      role: "assistant",
+      status: "done",
+      createdAt: at(5),
+      parts: [
+        {
+          type: "text",
+          text: "Mockup, notes and spec received. The recording was too large to attach. Here are the current screens and the alert sound:"
+        },
+        {
+          type: "media",
+          items: [
+            {
+              kind: "image",
+              src: picture("Forecast card", "#3b63fb", "#7a5af8"),
+              alt: "The forecast card in light mode"
+            },
+            {
+              kind: "image",
+              src: picture("Dark card", "#1d1d1d", "#3b63fb"),
+              alt: "The forecast card in dark mode"
+            },
+            {
+              kind: "image",
+              src: picture("Phone", "#0a7a43", "#12b886", 360, 640),
+              alt: "The forecast card on a phone"
+            },
+            {
+              kind: "video",
+              src: "",
+              poster: picture("\u25B6 Walkthrough", "#292929", "#717171"),
+              alt: "A walkthrough of the forecast page"
+            },
+            { kind: "audio", src: tone(), alt: "The storm alert sound" }
+          ]
+        }
+      ]
+    },
+    { id: "k-u3", role: "user", text: "Show me every tool you used.", createdAt: at(8) },
+    {
+      id: "k-m3",
+      role: "assistant",
+      status: "done",
+      createdAt: at(9),
+      parts: [
+        { type: "text", text: "Every tool from today\u2019s run, in order:" },
+        ...toolShapes.map((call) => ({ type: "tool", tool: call }))
+      ]
+    },
+    {
+      id: "k-tool1",
+      role: "tool",
+      createdAt: at(12),
+      tool: tool(
+        "k-t15",
+        "bash",
+        "You ran a command",
+        "git log --oneline -3",
+        "a1b2c3d fix: expire entries from the previous day\ne4f5a6b feat: retry upstream timeouts\n0c9d8e7 chore: update wrangler"
+      )
+    }
+  ];
+}
+function work() {
+  return [
+    {
+      id: "k-m4",
+      role: "assistant",
+      status: "done",
+      createdAt: at(14),
+      parts: [
+        { type: "text", text: "Here is where things stand." },
+        {
+          type: "card",
+          card: {
+            variant: "pr",
+            number: 58,
+            title: "Add retries for upstream timeouts",
+            branch: "fix/retry-upstream",
+            checks: "4 of 4 checks passed",
+            additions: 42,
+            deletions: 7,
+            files: 3,
+            tone: "positive"
+          }
+        },
+        {
+          type: "card",
+          card: {
+            variant: "tool",
+            title: "Visual regression suite",
+            badge: "bash",
+            status: "2 snapshots changed",
+            files: ["forecast-card.png", "forecast-card-dark.png"],
+            tone: "notice"
+          }
+        },
+        {
+          type: "card",
+          card: {
+            variant: "light",
+            title: "Staging is healthy",
+            detail: "/health answered in 2 ms",
+            tone: "informative"
+          }
+        },
+        {
+          type: "plan",
+          items: [
+            "Merge the retry pull request",
+            "Move the cache to KV",
+            "Update the forecast docs to Celsius",
+            "Tag 1.9.0"
+          ]
+        },
+        {
+          type: "check",
+          items: [
+            { text: "TTL fix merged" },
+            { text: "Retries reviewed", tone: "informative" },
+            { text: "Docs pass running", tone: "notice" },
+            { text: "KV migration not started", tone: "negative" }
+          ]
+        },
+        {
+          type: "diff",
+          path: "/workspace/harbor/src/lib/units.ts",
+          before: "export function toCelsius(f: number): number {\n  return ((f - 32) * 5) / 9;\n}\n",
+          after: "export function toCelsius(f: number): number {\n  return Math.round(((f - 32) * 5) / 9);\n}\n"
+        },
+        {
+          type: "link",
+          url: "https://api.example.com/docs/v2/forecast",
+          title: "Forecast API reference",
+          description: "Parameters, units and rate limits for /v2/forecast."
+        },
+        {
+          type: "delegation",
+          kind: "scoop",
+          scoop: "docs-pass",
+          text: "Started a scoop to update the docs"
+        },
+        {
+          type: "delegation",
+          kind: "feed",
+          scoop: "docs-pass",
+          text: "Handed over the new screenshots"
+        },
+        {
+          type: "delegation",
+          kind: "sprinkle",
+          scoop: "release-board",
+          text: "Opened the release board sprinkle"
+        },
+        { type: "delegation", kind: "drop", scoop: "amber-heron", text: "Wrapped up amber-heron" }
+      ]
+    },
+    {
+      id: "k-m5",
+      role: "assistant",
+      status: "done",
+      createdAt: at(18),
+      parts: [
+        { type: "text", text: "Three decisions from earlier:" },
+        {
+          type: "question",
+          question: {
+            id: "k-q1",
+            kind: "yes-no",
+            question: "Tag 1.9.0 after the merge?",
+            options: [],
+            state: "answered",
+            answer: "Yes"
+          }
+        },
+        {
+          type: "question",
+          question: {
+            id: "k-q2",
+            kind: "text",
+            question: "What should the release be called?",
+            options: [],
+            state: "inert"
+          }
+        },
+        {
+          type: "question",
+          question: {
+            id: "k-q3",
+            kind: "choice",
+            question: "Where should the cache live?",
+            options: ["Keep it in memory", "Move it to KV", "Decide after the load test"],
+            state: "open"
+          }
+        }
+      ]
+    }
+  ];
+}
+function events() {
+  return [
+    {
+      id: "k-s1",
+      role: "system",
+      kind: "compaction",
+      title: "Context compacted",
+      text: "58 earlier messages were summarized.",
+      trigger: "threshold",
+      state: "summarized",
+      createdAt: at(1440)
+    },
+    {
+      id: "k-s2",
+      role: "system",
+      kind: "compaction",
+      title: "Compaction fell back",
+      text: "The summary failed, so the oldest 20 messages were dropped instead.",
+      trigger: "overflow",
+      state: "fallback",
+      createdAt: at(1441)
+    },
+    ...licks.map(
+      ([channel, title, text, body, extra], index2) => ({
+        id: `k-l${index2 + 1}`,
+        role: "lick",
+        channel,
+        title,
+        text,
+        createdAt: at(1445 + index2),
+        ...body ? { body } : {},
+        ...extra
+      })
+    ),
+    {
+      id: "k-u4",
+      role: "user",
+      text: "Actually, stop the deploy, staging is frozen today.",
+      mode: "steer",
+      createdAt: at(1470)
+    },
+    {
+      id: "k-m6",
+      role: "assistant",
+      status: "stopped",
+      createdAt: at(1470),
+      parts: [{ type: "text", text: "Stopping the staging deploy and leaving" }]
+    },
+    {
+      id: "k-u5",
+      role: "user",
+      text: "Update the forecast page to Celsius and use the new screenshots.",
+      from: "harbor",
+      createdAt: at(1472)
+    },
+    {
+      id: "k-m7",
+      role: "assistant",
+      status: "error",
+      createdAt: at(1475),
+      parts: [
+        {
+          type: "thinking",
+          text: "The model rejected the request because the context is too large."
+        },
+        {
+          type: "error",
+          message: "The model returned 413: the request is larger than its context window.",
+          action: "change-model"
+        }
+      ]
+    },
+    {
+      id: "k-s3",
+      role: "system",
+      kind: "error",
+      title: "docs-pass failed",
+      text: "The Adobe session expired. Log in again to continue.",
+      action: "login",
+      createdAt: at(1476)
+    },
+    {
+      id: "k-s4",
+      role: "system",
+      kind: "error",
+      title: "Rate limited",
+      text: "Anthropic answered 429. Retrying in 30 seconds.",
+      action: "retry",
+      createdAt: at(1477)
+    },
+    {
+      id: "k-s5",
+      role: "system",
+      kind: "notice",
+      title: "Model changed",
+      text: "This cone now uses Claude Opus 5.5.",
+      createdAt: at(1478)
+    }
+  ];
+}
+function showcase() {
+  return [...opening(), ...work(), ...events()];
+}
+function showcaseQueue() {
+  return [
+    {
+      id: "k-q-1",
+      role: "user",
+      text: "Then open a pull request for the docs.",
+      createdAt: at(1480),
+      queued: true,
+      mode: "queue"
+    },
+    {
+      id: "k-q-2",
+      role: "user",
+      text: "And post the link in the release channel.",
+      createdAt: at(1481),
+      queued: true,
+      mode: "queue"
+    }
+  ];
+}
+
 // src/dummy/fixtures.ts
 var cacheBefore = `export interface Entry<T> {
   value: T;
@@ -743,6 +1918,7 @@ var agents = [
     contextFill: 0.21,
     unread: 0
   },
+  showcaseAgent,
   {
     id: "cone-harbor",
     name: "harbor",
@@ -804,21 +1980,23 @@ var agents = [
     unread: 0
   }
 ];
-var start = Date.UTC(2026, 9, 5, 8, 30);
-var at = (minutes) => start + minutes * 6e4;
+var start2 = Date.UTC(2026, 9, 5, 8, 30);
+var at2 = (minutes) => start2 + minutes * 6e4;
+var queues = { "cone-kitchen": showcaseQueue() };
 var conversations = {
+  "cone-kitchen": showcase(),
   "cone-sliccy": [
     {
       id: "m-s1",
       role: "user",
       text: "What is on my plate today?",
-      createdAt: at(0)
+      createdAt: at2(0)
     },
     {
       id: "m-s2",
       role: "assistant",
       status: "done",
-      createdAt: at(1),
+      createdAt: at2(1),
       parts: [
         {
           type: "tool",
@@ -842,23 +2020,23 @@ var conversations = {
   "cone-harbor": [
     {
       id: "m-h1",
-      role: "event",
-      kind: "webhook",
+      role: "lick",
+      channel: "webhook",
       title: "GitHub \xB7 issue opened",
       text: "example/harbor#57: Forecast stays on yesterday after midnight UTC",
-      createdAt: at(2)
+      createdAt: at2(2)
     },
     {
       id: "m-h2",
       role: "user",
       text: "The forecast endpoint serves stale data after midnight UTC. Find out why and fix it.",
-      createdAt: at(3)
+      createdAt: at2(3)
     },
     {
       id: "m-h3",
       role: "assistant",
       status: "done",
-      createdAt: at(4),
+      createdAt: at2(4),
       parts: [
         {
           type: "thinking",
@@ -920,11 +2098,11 @@ var conversations = {
     },
     {
       id: "m-h4",
-      role: "event",
-      kind: "scoop",
+      role: "lick",
+      channel: "scoop-notify",
       title: "quiet-otter",
       text: "Started: add retries with backoff around the upstream fetch",
-      createdAt: at(9)
+      createdAt: at2(9)
     }
   ],
   "scoop-otter": [
@@ -932,13 +2110,13 @@ var conversations = {
       id: "m-o1",
       role: "user",
       text: "Wrap the upstream fetch in src/routes/forecast.ts with three retries and exponential backoff.",
-      createdAt: at(9)
+      createdAt: at2(9)
     },
     {
       id: "m-o2",
       role: "assistant",
       status: "done",
-      createdAt: at(10),
+      createdAt: at2(10),
       parts: [
         {
           type: "tool",
@@ -973,17 +2151,17 @@ var conversations = {
   "cone-release": [
     {
       id: "m-r1",
-      role: "event",
-      kind: "cron",
+      role: "lick",
+      channel: "cron",
       title: "Every Friday 09:00",
       text: "Draft the release notes for example/harbor",
-      createdAt: at(-1440)
+      createdAt: at2(-1440)
     },
     {
       id: "m-r2",
       role: "assistant",
       status: "done",
-      createdAt: at(-1438),
+      createdAt: at2(-1438),
       parts: [
         {
           type: "tool",
@@ -1007,17 +2185,19 @@ var conversations = {
   "cone-triage": [
     {
       id: "m-t1",
-      role: "event",
+      role: "system",
       kind: "compaction",
+      trigger: "threshold",
+      state: "summarized",
       title: "Context compacted",
       text: "41 earlier messages were summarized to stay under the context limit.",
-      createdAt: at(-30)
+      createdAt: at2(-30)
     },
     {
       id: "m-t2",
       role: "assistant",
       status: "done",
-      createdAt: at(-20),
+      createdAt: at2(-20),
       parts: [
         {
           type: "text",
@@ -1027,11 +2207,12 @@ var conversations = {
     },
     {
       id: "m-t3",
-      role: "event",
+      role: "system",
       kind: "error",
+      action: "login",
       title: "Mail connector",
       text: "The connector returned 401. Reconnect the account in Settings.",
-      createdAt: at(-19)
+      createdAt: at2(-19)
     }
   ]
 };
@@ -1062,6 +2243,177 @@ var terminals = [
   { id: "term-1", title: "bash", cwd: "/workspace/harbor", agentId: null }
 ];
 
+// src/dummy/memory.ts
+var DummyMemory = class extends Emitter {
+  #memories;
+  #next = 1;
+  constructor(memories2) {
+    super();
+    this.#memories = memories2.map((memory2) => ({ ...memory2 }));
+  }
+  list() {
+    return this.#memories.map((memory2) => ({ ...memory2 }));
+  }
+  save(draft) {
+    const memory2 = {
+      ...draft,
+      id: draft.id ?? `mem-new-${this.#next++}`,
+      updatedAt: Date.now()
+    };
+    const index2 = this.#memories.findIndex((candidate) => candidate.id === memory2.id);
+    if (index2 < 0) this.#memories.push(memory2);
+    else this.#memories[index2] = memory2;
+    this.emit("memories", this.list());
+    return { ...memory2 };
+  }
+  remove(id) {
+    this.#memories = this.#memories.filter((memory2) => memory2.id !== id);
+    this.emit("memories", this.list());
+  }
+};
+
+// src/dummy/monitor.ts
+var statuses = {
+  idle: "idle",
+  thinking: "active",
+  working: "active",
+  waiting: "warn",
+  error: "error"
+};
+function wave(seed, length = 24) {
+  return Array.from(
+    { length },
+    (_, i) => Math.round(40 + 25 * Math.sin((i + seed) / 3) + 10 * Math.cos(i * seed / 5))
+  );
+}
+var DummyMonitor = class extends Emitter {
+  #model;
+  #tick = 0;
+  constructor(model) {
+    super();
+    this.#model = model;
+    const update = () => this.resync();
+    model.agent.on("agents", update);
+    model.terminals.on("terminals", update);
+    model.browser.on("tabs", update);
+    model.files.on("changes", update);
+    model.tray.on("status", update);
+  }
+  snapshot() {
+    const { agent, terminals: terminals2, browser, files: files3, sprinkles: sprinkles2, tray: tray2 } = this.#model;
+    const listed = agent.list();
+    const agents2 = listed.filter((candidate) => candidate.kind === "cone").flatMap((cone) => [cone, ...listed.filter((candidate) => candidate.parentId === cone.id)]);
+    const active = agents2.filter((candidate) => candidate.status !== "idle").length;
+    const status = tray2.status();
+    const fill = Math.max(...agents2.map((candidate) => candidate.contextFill), 0);
+    const agentRows = agents2.map(
+      (candidate) => ({
+        name: candidate.kind === "scoop" ? `\u21B3 ${candidate.name}` : candidate.name,
+        meta: `${candidate.status} \xB7 ${Math.round(candidate.contextFill * 100)}% context`,
+        status: statuses[candidate.status],
+        badges: candidate.unread ? [`${candidate.unread} unread`] : []
+      })
+    );
+    return {
+      updatedAt: Date.now(),
+      vitals: [
+        {
+          id: "agents",
+          label: "Active agents",
+          value: String(active),
+          unit: `of ${agents2.length}`,
+          series: wave(this.#tick + 1)
+        },
+        {
+          id: "spend",
+          label: "Spend",
+          value: `$${status.spent.toFixed(2)}`,
+          delta: `$${status.rate.toFixed(2)}/h`,
+          series: wave(this.#tick + 7)
+        },
+        {
+          id: "budget",
+          label: `Budget (${status.budget.window})`,
+          value: `${status.budget.percent}%`,
+          unit: status.budget.resets,
+          ratio: status.budget.percent / 100
+        },
+        {
+          id: "context",
+          label: "Fullest context",
+          value: `${Math.round(fill * 100)}%`,
+          ratio: fill
+        }
+      ],
+      alerts: [
+        ...agents2.filter((candidate) => candidate.contextFill >= 0.6).map((candidate) => ({
+          id: `fill-${candidate.id}`,
+          title: `${candidate.name} is ${Math.round(candidate.contextFill * 100)}% full`,
+          detail: "Compact it soon to keep replies fast.",
+          severity: "warn"
+        })),
+        ...status.connection === "live" ? [] : [
+          {
+            id: "tray",
+            title: `Tray ${status.connection}`,
+            detail: "Followers can\u2019t see this session.",
+            severity: "error"
+          }
+        ]
+      ],
+      sections: [
+        { id: "agents", label: "Cones and scoops", rows: agentRows },
+        {
+          id: "terminals",
+          label: "Terminals",
+          rows: terminals2.list().map((terminal) => ({
+            name: terminal.title,
+            meta: terminal.cwd,
+            status: "active"
+          }))
+        },
+        {
+          id: "tabs",
+          label: "Browser tabs",
+          rows: browser.list().map((tab) => ({
+            name: tab.title,
+            meta: new URL(tab.url).host || tab.url,
+            status: tab.status === "loading" ? "active" : "idle",
+            badges: tab.agentId ? ["agent"] : []
+          }))
+        },
+        {
+          id: "changes",
+          label: "Pending changes",
+          rows: files3.changes().map((change) => ({ name: change.path, meta: change.status, status: "warn" }))
+        },
+        {
+          id: "sprinkles",
+          label: "Sprinkles",
+          rows: sprinkles2.list().map((sprinkle) => ({
+            name: sprinkle.title,
+            meta: sprinkle.name,
+            status: "idle"
+          }))
+        },
+        {
+          id: "followers",
+          label: "Tray followers",
+          rows: status.followers.map((follower) => ({
+            name: follower.name,
+            meta: follower.device,
+            status: "active"
+          }))
+        }
+      ]
+    };
+  }
+  resync() {
+    this.#tick += 1;
+    this.emit("snapshot", this.snapshot());
+  }
+};
+
 // src/dummy/settings.ts
 var key = "slicc-ui.settings";
 var DummySettings = class extends Emitter {
@@ -1116,6 +2468,33 @@ var DummySettings = class extends Emitter {
   }
 };
 
+// src/dummy/sprinkles.ts
+var DummySprinkles = class extends Emitter {
+  #sprinkles;
+  #agent;
+  constructor(sprinkles2, agent) {
+    super();
+    this.#sprinkles = sprinkles2.map((sprinkle) => ({ ...sprinkle }));
+    this.#agent = agent;
+  }
+  list() {
+    return this.#sprinkles.map((sprinkle) => ({ ...sprinkle }));
+  }
+  send(id, payload) {
+    const sprinkle = this.#sprinkles.find((candidate) => candidate.id === id);
+    if (!sprinkle) return;
+    const data = payload ?? {};
+    const what = data.event ? `\u201C${data.event}\u201D${data.detail ? ` (${data.detail})` : ""}` : "an event";
+    this.#agent.lick(
+      sprinkle.agentId,
+      "sprinkle",
+      sprinkle.title,
+      `Sent ${what}`,
+      JSON.stringify(payload, null, 2)
+    );
+  }
+};
+
 // src/dummy/shell.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -1368,13 +2747,48 @@ var DummyTerminals = class extends Emitter {
   }
 };
 
+// src/dummy/tray.ts
+var DummyTray = class extends Emitter {
+  #status;
+  #followers;
+  #clock;
+  constructor(status, clock2) {
+    super();
+    this.#status = structuredClone(status);
+    this.#followers = structuredClone(status.followers);
+    this.#clock = clock2;
+  }
+  status() {
+    return structuredClone(this.#status);
+  }
+  #set(patch) {
+    this.#status = { ...this.#status, ...patch };
+    this.emit("status", this.status());
+  }
+  reconnect() {
+    this.#set({ connection: "reconnecting" });
+    void this.#clock.sleep(15).then(() => this.#set({ connection: "live", followers: structuredClone(this.#followers) }));
+  }
+  disconnect() {
+    this.#set({ connection: "offline", followers: [] });
+  }
+};
+
 // src/dummy/index.ts
 function createDummyModel({ delay = 30, storage = null } = {}) {
   const time = clock(delay);
   const files3 = new DummyFiles(files2, directories, pending, time);
   const browser = new DummyBrowser(tabs, time);
-  return {
-    agent: new DummyAgent(agents, conversations, { files: files3, browser }, time),
+  const agent = new DummyAgent(
+    agents,
+    conversations,
+    { files: files3, browser },
+    time,
+    queues,
+    frozen
+  );
+  const base = {
+    agent,
     files: files3,
     browser,
     terminals: new DummyTerminals(terminals, files3, time),
@@ -1384,8 +2798,12 @@ function createDummyModel({ delay = 30, storage = null } = {}) {
       accounts,
       storage,
       time
-    )
+    ),
+    memory: new DummyMemory(memories),
+    sprinkles: new DummySprinkles(sprinkles, agent),
+    tray: new DummyTray(tray, time)
   };
+  return { ...base, monitor: new DummyMonitor(base) };
 }
 export {
   createDummyModel