@ai-ecoverse/slicc-spectrum 1.0.0 → 1.2.0

package/dist/slicc-dummy.js

@@ -0,0 +1,2811 @@
+import {
+  Emitter
+} from "./chunk-T5NHW4KC.js";
+import "./chunk-AXQFWXYZ.js";
+
+// src/dummy/script.ts
+var units = "/workspace/harbor/src/lib/units.ts";
+var kelvin = `
+export function toKelvin(celsius: number): number {
+  return Math.round((celsius + 273.15) * 100) / 100;
+}
+`;
+function test() {
+  return [
+    { type: "thinking", text: "Run the whole suite first, then look at anything that fails." },
+    {
+      type: "tool",
+      name: "bash",
+      title: "Run the tests",
+      input: "npm test",
+      output: "> harbor@0.0.0 test\n> node --test test/\n\n\u2714 converts both ways (0.6ms)\n\u2714 expires entries from the previous day (0.4ms)\n\u2714 retries upstream timeouts (3.1ms)\n\u2139 tests 3\n\u2139 pass 3\n\u2139 fail 0",
+      paths: [],
+      ticks: 40
+    },
+    {
+      type: "text",
+      text: "All **3 tests pass**, including the new one for the midnight rollover. Nothing else to fix."
+    }
+  ];
+}
+function edit() {
+  return [
+    {
+      type: "thinking",
+      text: "The conversion helpers live in units.ts. Add the missing one next to them."
+    },
+    {
+      type: "tool",
+      name: "read_file",
+      title: "Read the unit helpers",
+      input: units,
+      output: "export function toCelsius(fahrenheit: number): number { \u2026 }\nexport function toFahrenheit(celsius: number): number { \u2026 }",
+      paths: [units],
+      ticks: 10
+    },
+    {
+      type: "tool",
+      name: "edit_file",
+      title: "Add toKelvin()",
+      input: units,
+      output: "Appended 4 lines",
+      paths: [units],
+      ticks: 20,
+      effect: async ({ files: files3, agentId }) => {
+        const before = await files3.read(units);
+        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."
+    }
+  ];
+}
+function browse() {
+  const url = "https://api.example.com/docs/v2/units";
+  return [
+    {
+      type: "tool",
+      name: "browser",
+      title: "Open the units reference",
+      input: `navigate ${url}`,
+      output: "Loaded api.example.com/docs/v2/units (200, 412 ms)",
+      paths: [],
+      ticks: 25,
+      effect: ({ browser, agentId }) => browser.open(url, agentId)
+    },
+    {
+      type: "text",
+      text: "The reference page is open in the **Browser** panel. Temperatures are documented in Celsius, with Fahrenheit behind `?units=imperial`."
+    }
+  ];
+}
+function files() {
+  return [
+    {
+      type: "tool",
+      name: "bash",
+      title: "List the project",
+      input: "ls /workspace/harbor/src",
+      output: "index.ts  legacy  lib  routes",
+      paths: ["/workspace/harbor/src"],
+      ticks: 8
+    },
+    {
+      type: "tool",
+      name: "read_file",
+      title: "Read the README",
+      input: "/workspace/harbor/README.md",
+      output: "# harbor\n\nA small forecast API that sits in front of the upstream weather service and caches per city.",
+      paths: ["/workspace/harbor/README.md"],
+      ticks: 8
+    },
+    {
+      type: "text",
+      text: "harbor has four parts:\n\n- `index.ts`: the worker entry and routing\n- `routes/forecast.ts`: the forecast handler\n- `lib/`: cache, retry and unit helpers\n- `legacy/`: the XML output, marked for removal"
+    }
+  ];
+}
+function chat(prompt) {
+  return [
+    { type: "thinking", text: "Short question. Answer directly, then offer the next step." },
+    {
+      type: "tool",
+      name: "bash",
+      title: "Check the working tree",
+      input: "git status --short",
+      output: " M src/lib/cache.ts\n M src/routes/forecast.ts\n A src/lib/retry.ts\n D src/legacy/xml.ts",
+      paths: [],
+      ticks: 12
+    },
+    {
+      type: "text",
+      text: `On \u201C${prompt.slice(0, 60)}\u201D: there are **4 uncommitted changes** in harbor, from me and quiet-otter. Review them in Changes, or ask me to run the tests, edit a file or open a page.`
+    }
+  ];
+}
+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();
+  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, 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 }));
+  }
+  active() {
+    return this.#active;
+  }
+  #agent(id) {
+    return this.#agents.find((agent) => agent.id === id);
+  }
+  #changed() {
+    this.emit("agents", this.list());
+  }
+  #id(prefix) {
+    return `${prefix}-${this.#next++}`;
+  }
+  select(id) {
+    const agent = this.#agent(id);
+    if (!agent) return;
+    this.#active = id;
+    agent.unread = 0;
+    this.emit("active", id);
+    this.#changed();
+  }
+  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 });
+  }
+  #status(agentId, status) {
+    const agent = this.#agent(agentId);
+    if (!agent || agent.status === status) return;
+    agent.status = status;
+    this.#changed();
+  }
+  async #stream(agentId, reply, part, text, run) {
+    for (const chunk of chunks(text)) {
+      await this.#clock.sleep();
+      if (run.stopped) return;
+      part.text += chunk;
+      this.emit("message", { agentId, message: reply });
+    }
+  }
+  async #tool(agentId, reply, step, run) {
+    this.#status(agentId, "working");
+    const tool2 = {
+      id: this.#id("t"),
+      name: step.name,
+      title: step.title,
+      input: step.input,
+      output: "",
+      status: "running",
+      paths: step.paths
+    };
+    reply.parts.push({ type: "tool", tool: tool2 });
+    this.emit("message", { agentId, message: reply });
+    await this.#clock.sleep(step.ticks);
+    const done = run.stopped ? { status: "cancelled", output: "Stopped" } : { status: "done", output: step.output };
+    if (!run.stopped) await step.effect?.({ ...this.#effects, agentId });
+    Object.assign(tool2, done);
+    this.emit("message", { agentId, message: reply });
+  }
+  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 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: this.#id("m"),
+      role: "user",
+      text: prompt,
+      createdAt: Date.now(),
+      ...message.mode === "steer" ? { mode: "steer" } : {},
+      ...message.attachments?.length ? { attachments: message.attachments } : {}
+    });
+    const reply = {
+      id: this.#id("m"),
+      role: "assistant",
+      parts: [],
+      status: "streaming",
+      createdAt: Date.now(),
+      model: agent.model
+    };
+    this.#post(agentId, reply);
+    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());
+  }
+};
+
+// src/dummy/browser.ts
+function escape(text) {
+  return text.replace(/[<>&"]/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+function hue(text) {
+  let sum = 0;
+  for (const char of text) sum = (sum * 31 + char.charCodeAt(0)) % 360;
+  return sum;
+}
+function page(tab) {
+  const h = hue(new URL(tab.url).host);
+  const rows = [0, 1, 2, 3, 4, 5].map(
+    (i) => `<rect x="64" y="${220 + i * 36}" width="${560 - i % 3 * 90}" height="12" rx="6" fill="#d6d6d6"/>`
+  ).join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="1280" height="800" viewBox="0 0 1280 800"><rect width="1280" height="800" fill="#ffffff"/><rect width="1280" height="64" fill="hsl(${h} 45% 32%)"/><text x="64" y="40" font-family="sans-serif" font-size="20" fill="#ffffff">${escape(new URL(tab.url).host)}</text><text x="64" y="160" font-family="sans-serif" font-size="36" fill="#222222">${escape(tab.title)}</text>${rows}<rect x="720" y="200" width="496" height="280" rx="12" fill="hsl(${h} 40% 92%)"/></svg>`;
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+function titleFor(url) {
+  const { host, pathname } = new URL(url);
+  if (!host) return "New tab";
+  return pathname === "/" ? host : `${host}${pathname}`;
+}
+var DummyBrowser = class extends Emitter {
+  #tabs;
+  #active;
+  #clock;
+  #next = 1;
+  constructor(tabs2, clock2) {
+    super();
+    this.#clock = clock2;
+    this.#tabs = tabs2.map((tab) => ({ ...tab }));
+    this.#active = this.#tabs[0]?.id ?? null;
+  }
+  list() {
+    return this.#tabs.map((tab) => ({ ...tab }));
+  }
+  active() {
+    return this.#active;
+  }
+  #changed() {
+    this.emit("tabs", this.list());
+    this.emit("active", this.#active);
+  }
+  activate(id) {
+    if (!this.#tabs.some((tab) => tab.id === id)) return;
+    this.#active = id;
+    this.emit("active", id);
+  }
+  #load(id) {
+    void this.#clock.sleep(15).then(() => {
+      const tab = this.#tabs.find((candidate) => candidate.id === id);
+      if (!tab) return;
+      tab.status = "complete";
+      tab.title = titleFor(tab.url);
+      this.#changed();
+    });
+  }
+  open(url, agentId = null) {
+    const tab = {
+      id: `tab-new-${this.#next++}`,
+      title: url,
+      url,
+      status: "loading",
+      agentId
+    };
+    this.#tabs.push(tab);
+    this.#active = tab.id;
+    this.#changed();
+    this.#load(tab.id);
+    return { ...tab };
+  }
+  navigate(id, url) {
+    const tab = this.#tabs.find((candidate) => candidate.id === id);
+    if (!tab) return;
+    tab.url = url;
+    tab.title = url;
+    tab.status = "loading";
+    this.#changed();
+    this.#load(id);
+  }
+  close(id) {
+    const index2 = this.#tabs.findIndex((tab) => tab.id === id);
+    if (index2 < 0) return;
+    this.#tabs.splice(index2, 1);
+    if (this.#active === id)
+      this.#active = this.#tabs[Math.min(index2, this.#tabs.length - 1)]?.id ?? null;
+    this.#changed();
+  }
+  async screenshot(id) {
+    await this.#clock.sleep(2);
+    const tab = this.#tabs.find((candidate) => candidate.id === id);
+    if (!tab) throw new Error(`No tab ${id}`);
+    return page(tab);
+  }
+};
+
+// src/dummy/clock.ts
+function clock(delay) {
+  return {
+    delay,
+    sleep: (ticks = 1) => new Promise((resolve2) => setTimeout(resolve2, delay * ticks))
+  };
+}
+
+// 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);
+  return parts.map((_, i) => `/${parts.slice(0, i + 1).join("/")}`);
+}
+var DummyFiles = class extends Emitter {
+  #contents = /* @__PURE__ */ new Map();
+  #directories = /* @__PURE__ */ new Set();
+  #modified = /* @__PURE__ */ new Map();
+  #changes = /* @__PURE__ */ new Map();
+  #clock;
+  constructor(contents, directories2, changes, clock2) {
+    super();
+    this.#clock = clock2;
+    for (const directory of directories2) this.#mkdirs(`${directory}/`);
+    for (const [path, text] of Object.entries(contents)) this.#put(path, text, 0);
+    for (const change of changes) this.#changes.set(change.path, { ...change });
+    for (const change of changes) {
+      if (change.after === null) this.#contents.delete(change.path);
+      else this.#put(change.path, change.after, 0);
+    }
+  }
+  #mkdirs(path) {
+    for (const directory of parents(path)) this.#directories.add(directory);
+  }
+  #put(path, text, now2) {
+    this.#mkdirs(path);
+    this.#contents.set(path, text);
+    this.#modified.set(path, now2);
+  }
+  #entries() {
+    const directories2 = [...this.#directories].map(
+      (path) => ({ path, kind: "directory", size: 0, modified: 0 })
+    );
+    const files3 = [...this.#contents].map(
+      ([path, text]) => ({
+        path,
+        kind: "file",
+        size: new TextEncoder().encode(text).length,
+        modified: this.#modified.get(path)
+      })
+    );
+    return [...directories2, ...files3].sort((a, b) => a.path.localeCompare(b.path));
+  }
+  async list() {
+    await this.#clock.sleep();
+    return this.#entries();
+  }
+  async read(path) {
+    await this.#clock.sleep();
+    const text = this.#contents.get(path);
+    if (text === void 0) throw new Error(`ENOENT: ${path}`);
+    return text;
+  }
+  #record(path, after, agentId) {
+    const previous = this.#changes.get(path);
+    const before = previous ? previous.before : this.#contents.get(path) ?? null;
+    if (before === after) {
+      this.#changes.delete(path);
+      return;
+    }
+    const status = before === null ? "added" : after === null ? "deleted" : "modified";
+    this.#changes.set(path, { path, status, before, after, agentId });
+  }
+  #announce(path) {
+    this.emit("files", this.#entries());
+    this.emit("file", path);
+    this.emit("changes", this.changes());
+  }
+  async write(path, text, agentId = null) {
+    await this.#clock.sleep();
+    this.#record(path, text, agentId);
+    this.#put(path, text, Date.now());
+    this.#announce(path);
+  }
+  async remove(path, agentId = null) {
+    await this.#clock.sleep();
+    if (!this.#contents.has(path)) throw new Error(`ENOENT: ${path}`);
+    this.#record(path, null, agentId);
+    this.#contents.delete(path);
+    this.#announce(path);
+  }
+  changes() {
+    return [...this.#changes.values()].sort((a, b) => a.path.localeCompare(b.path));
+  }
+  accept(path) {
+    this.#changes.delete(path);
+    this.emit("changes", this.changes());
+  }
+  async revert(path) {
+    const change = this.#changes.get(path);
+    if (!change) return;
+    await this.#clock.sleep();
+    this.#changes.delete(path);
+    if (change.before === null) this.#contents.delete(path);
+    else this.#put(path, change.before, Date.now());
+    this.#announce(path);
+  }
+};
+
+// 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;
+  storedAt: number;
+}
+
+const TTL = 60 * 60 * 1000;
+
+export class ForecastCache<T> {
+  #entries = new Map<string, Entry<T>>();
+
+  get(key: string, now = Date.now()): T | undefined {
+    const entry = this.#entries.get(key);
+    if (!entry) return undefined;
+    const day = new Date(entry.storedAt).getDate();
+    if (day !== new Date(now).getDate()) return entry.value;
+    if (now - entry.storedAt > TTL) return undefined;
+    return entry.value;
+  }
+
+  set(key: string, value: T, now = Date.now()): void {
+    this.#entries.set(key, { value, storedAt: now });
+  }
+}
+`;
+var cacheAfter = `export interface Entry<T> {
+  value: T;
+  storedAt: number;
+}
+
+const TTL = 60 * 60 * 1000;
+
+export class ForecastCache<T> {
+  #entries = new Map<string, Entry<T>>();
+
+  get(key: string, now = Date.now()): T | undefined {
+    const entry = this.#entries.get(key);
+    if (!entry) return undefined;
+    if (dayOf(entry.storedAt) !== dayOf(now)) {
+      this.#entries.delete(key);
+      return undefined;
+    }
+    if (now - entry.storedAt > TTL) return undefined;
+    return entry.value;
+  }
+
+  set(key: string, value: T, now = Date.now()): void {
+    this.#entries.set(key, { value, storedAt: now });
+  }
+}
+
+function dayOf(time: number): string {
+  return new Date(time).toISOString().slice(0, 10);
+}
+`;
+var retry = `export async function retry<T>(task: () => Promise<T>, attempts = 3, wait = 250): Promise<T> {
+  let last: unknown;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await task();
+    } catch (error) {
+      last = error;
+      await new Promise((resolve) => setTimeout(resolve, wait * 2 ** attempt));
+    }
+  }
+  throw last;
+}
+`;
+var legacyXml = `export function toXml(forecast: { city: string; high: number; low: number }): string {
+  return \`<forecast city="\${forecast.city}"><high>\${forecast.high}</high><low>\${forecast.low}</low></forecast>\`;
+}
+`;
+var forecastBefore = `import { ForecastCache } from '../lib/cache.ts';
+import { toCelsius } from '../lib/units.ts';
+
+const cache = new ForecastCache<Forecast>();
+
+export interface Forecast {
+  city: string;
+  high: number;
+  low: number;
+  summary: string;
+}
+
+export async function forecast(city: string, upstream: typeof fetch = fetch): Promise<Forecast> {
+  const cached = cache.get(city);
+  if (cached) return cached;
+  const response = await upstream(\`https://api.example.com/v2/forecast?city=\${encodeURIComponent(city)}\`);
+  const body = await response.json();
+  const result = {
+    city,
+    high: toCelsius(body.daily.max),
+    low: toCelsius(body.daily.min),
+    summary: body.daily.summary,
+  };
+  cache.set(city, result);
+  return result;
+}
+`;
+var forecastAfter = forecastBefore.replace(
+  "import { toCelsius } from '../lib/units.ts';",
+  "import { retry } from '../lib/retry.ts';\nimport { toCelsius } from '../lib/units.ts';"
+).replace("const response = await upstream(", "const response = await retry(() =>\n    upstream(").replace("(city)}`);", "(city)}`)\n  );");
+var units2 = `export function toCelsius(fahrenheit: number): number {
+  return Math.round(((fahrenheit - 32) * 5) / 9);
+}
+
+export function toFahrenheit(celsius: number): number {
+  return Math.round((celsius * 9) / 5 + 32);
+}
+`;
+var unitsTest = `import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { toCelsius, toFahrenheit } from '../src/lib/units.ts';
+
+test('converts both ways', () => {
+  assert.equal(toCelsius(212), 100);
+  assert.equal(toFahrenheit(0), 32);
+});
+`;
+var index = `import { forecast } from './routes/forecast.ts';
+
+export default {
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === '/health') return new Response('ok');
+    const city = url.searchParams.get('city');
+    if (!city) return Response.json({ error: 'city is required' }, { status: 400 });
+    return Response.json(await forecast(city));
+  },
+};
+`;
+var readme = `# harbor
+
+A small forecast API that sits in front of the upstream weather service and caches per city.
+
+## Development
+
+\`\`\`sh
+npm install
+npm test
+npm run dev
+\`\`\`
+
+The worker listens on \`http://localhost:8787\`. Try \`/forecast?city=Lisbon\`.
+`;
+var pkg = `{
+  "name": "harbor",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "wrangler dev",
+    "test": "node --test test/"
+  },
+  "devDependencies": {
+    "wrangler": "4.40.0"
+  }
+}
+`;
+var skill = `---
+name: release-notes
+description: Draft release notes from merged pull requests since the last tag.
+---
+
+1. Run \`collect.jsh\` with the repository and the previous tag.
+2. Group the pull requests by label: features, fixes, chores.
+3. Write one sentence per change, in the past tense, without ticket numbers.
+`;
+var collect = `const [repo, since] = process.argv.slice(2);
+const pulls = await gh(\`repos/\${repo}/pulls?state=closed&per_page=100\`);
+for (const pull of pulls.filter((p) => p.merged_at > since)) {
+  console.log(\`\${pull.number}\\t\${pull.labels.map((l) => l.name).join(',')}\\t\${pull.title}\`);
+}
+`;
+var memory = `# Shared memory
+
+## Preferences
+- Keep replies short. Lead with the result, then the evidence.
+- Run the tests before saying something is fixed.
+
+## Projects
+- harbor: forecast API, deployed as a worker. Cache bugs show up around midnight UTC.
+- release-notes: drafted every Friday from merged pull requests.
+`;
+var standup = `# Standup, 4 October
+
+- harbor: retries for upstream timeouts are in review.
+- Docs: the forecast endpoint page still shows Fahrenheit examples.
+- Next: move the cache to KV once the TTL fix lands.
+`;
+var sample = `{
+  "city": "Lisbon",
+  "daily": { "max": 77, "min": 61, "summary": "Clear, light wind from the north" }
+}
+`;
+var bashrc = `export PS1='\\u@slicc:\\w\\$ '
+alias ll='ls -la'
+`;
+var files2 = {
+  "/workspace/harbor/README.md": readme,
+  "/workspace/harbor/package.json": pkg,
+  "/workspace/harbor/wrangler.toml": 'name = "harbor"\nmain = "src/index.ts"\ncompatibility_date = "2026-09-01"\n',
+  "/workspace/harbor/.gitignore": "node_modules/\n.wrangler/\n",
+  "/workspace/harbor/src/index.ts": index,
+  "/workspace/harbor/src/routes/forecast.ts": forecastBefore,
+  "/workspace/harbor/src/lib/cache.ts": cacheBefore,
+  "/workspace/harbor/src/lib/units.ts": units2,
+  "/workspace/harbor/src/legacy/xml.ts": legacyXml,
+  "/workspace/harbor/test/units.test.ts": unitsTest,
+  "/workspace/skills/release-notes/SKILL.md": skill,
+  "/workspace/skills/release-notes/scripts/collect.jsh": collect,
+  "/shared/MEMORY.md": memory,
+  "/shared/notes/2026-10-04-standup.md": standup,
+  "/home/user/.bashrc": bashrc,
+  "/tmp/forecast-sample.json": sample
+};
+var directories = ["/sessions", "/home/user/downloads"];
+var pending = [
+  {
+    path: "/workspace/harbor/src/lib/cache.ts",
+    status: "modified",
+    before: cacheBefore,
+    after: cacheAfter,
+    agentId: "cone-harbor"
+  },
+  {
+    path: "/workspace/harbor/src/lib/retry.ts",
+    status: "added",
+    before: null,
+    after: retry,
+    agentId: "scoop-otter"
+  },
+  {
+    path: "/workspace/harbor/src/routes/forecast.ts",
+    status: "modified",
+    before: forecastBefore,
+    after: forecastAfter,
+    agentId: "scoop-otter"
+  },
+  {
+    path: "/workspace/harbor/src/legacy/xml.ts",
+    status: "deleted",
+    before: legacyXml,
+    after: null,
+    agentId: "cone-harbor"
+  }
+];
+var models = [
+  { id: "claude-opus-5-5", label: "Claude Opus 5.5", provider: "Anthropic" },
+  { id: "claude-sonnet-5-5", label: "Claude Sonnet 5.5", provider: "Anthropic" },
+  { id: "claude-haiku-4-5", label: "Claude Haiku 4.5", provider: "Anthropic" },
+  { id: "local-small", label: "Local (ort-llama)", provider: "This browser" }
+];
+var defaults = {
+  color: "system",
+  model: "claude-sonnet-5-5",
+  thinking: "medium",
+  sendOnEnter: true,
+  showThinking: true,
+  diffStyle: "unified"
+};
+var accounts = [
+  { id: "anthropic", provider: "Anthropic", identity: "API key ending 3f2a", status: "connected" },
+  { id: "github", provider: "GitHub", identity: "@example-dev", status: "connected" },
+  { id: "adobe", provider: "Adobe", identity: "dev@example.com", status: "expired" },
+  { id: "openai", provider: "OpenAI", identity: "", status: "disconnected" }
+];
+var agents = [
+  {
+    id: "cone-sliccy",
+    name: "sliccy",
+    kind: "cone",
+    parentId: null,
+    status: "idle",
+    model: "claude-sonnet-5-5",
+    contextFill: 0.21,
+    unread: 0
+  },
+  showcaseAgent,
+  {
+    id: "cone-harbor",
+    name: "harbor",
+    kind: "cone",
+    parentId: null,
+    status: "idle",
+    model: "claude-opus-5-5",
+    contextFill: 0.38,
+    unread: 0
+  },
+  {
+    id: "scoop-otter",
+    name: "quiet-otter",
+    kind: "scoop",
+    parentId: "cone-harbor",
+    status: "working",
+    model: "claude-haiku-4-5",
+    contextFill: 0.12,
+    unread: 0
+  },
+  {
+    id: "scoop-heron",
+    name: "amber-heron",
+    kind: "scoop",
+    parentId: "cone-harbor",
+    status: "idle",
+    model: "claude-haiku-4-5",
+    contextFill: 0.04,
+    unread: 0
+  },
+  {
+    id: "cone-release",
+    name: "release-notes",
+    kind: "cone",
+    parentId: null,
+    status: "idle",
+    model: "claude-sonnet-5-5",
+    contextFill: 0.09,
+    unread: 1
+  },
+  {
+    id: "cone-triage",
+    name: "inbox-triage",
+    kind: "cone",
+    parentId: null,
+    status: "waiting",
+    model: "claude-sonnet-5-5",
+    contextFill: 0.62,
+    unread: 2
+  },
+  {
+    id: "scoop-wren",
+    name: "tidal-wren",
+    kind: "scoop",
+    parentId: "cone-sliccy",
+    status: "idle",
+    model: "claude-haiku-4-5",
+    contextFill: 0.02,
+    unread: 0
+  }
+];
+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: at2(0)
+    },
+    {
+      id: "m-s2",
+      role: "assistant",
+      status: "done",
+      createdAt: at2(1),
+      parts: [
+        {
+          type: "tool",
+          tool: {
+            id: "t-s1",
+            name: "read_file",
+            title: "Read the standup notes",
+            input: "/shared/notes/2026-10-04-standup.md",
+            output: standup,
+            status: "done",
+            paths: ["/shared/notes/2026-10-04-standup.md"]
+          }
+        },
+        {
+          type: "text",
+          text: "Three things carry over from yesterday:\n\n1. **harbor**: the retry change is in review, and the midnight cache bug is still open.\n2. **Docs**: the forecast page still shows Fahrenheit examples.\n3. **release-notes** has a draft waiting for you.\n\nThe `harbor` cone is the one to start with."
+        }
+      ]
+    }
+  ],
+  "cone-harbor": [
+    {
+      id: "m-h1",
+      role: "lick",
+      channel: "webhook",
+      title: "GitHub \xB7 issue opened",
+      text: "example/harbor#57: Forecast stays on yesterday after midnight UTC",
+      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: at2(3)
+    },
+    {
+      id: "m-h3",
+      role: "assistant",
+      status: "done",
+      createdAt: at2(4),
+      parts: [
+        {
+          type: "thinking",
+          text: "Stale after midnight points at the cache expiry. Check how the cache compares days."
+        },
+        {
+          type: "tool",
+          tool: {
+            id: "t-h1",
+            name: "bash",
+            title: "Search for the cache expiry",
+            input: 'rg -n "getDate|TTL" src',
+            output: "src/lib/cache.ts:6:const TTL = 60 * 60 * 1000;\nsrc/lib/cache.ts:14:    const day = new Date(entry.storedAt).getDate();\nsrc/lib/cache.ts:16:    if (now - entry.storedAt > TTL) return undefined;",
+            status: "done",
+            paths: ["/workspace/harbor/src/lib/cache.ts"]
+          }
+        },
+        {
+          type: "tool",
+          tool: {
+            id: "t-h2",
+            name: "read_file",
+            title: "Read the cache",
+            input: "/workspace/harbor/src/lib/cache.ts",
+            output: cacheBefore,
+            status: "done",
+            paths: ["/workspace/harbor/src/lib/cache.ts"]
+          }
+        },
+        {
+          type: "tool",
+          tool: {
+            id: "t-h3",
+            name: "edit_file",
+            title: "Expire entries from the previous day",
+            input: "/workspace/harbor/src/lib/cache.ts",
+            output: "Replaced 1 block (4 lines \u2192 7 lines), added dayOf()",
+            status: "done",
+            paths: ["/workspace/harbor/src/lib/cache.ts"]
+          }
+        },
+        {
+          type: "tool",
+          tool: {
+            id: "t-h4",
+            name: "bash",
+            title: "Run the tests",
+            input: "npm test",
+            output: "> harbor@0.0.0 test\n> node --test test/\n\n\u2714 converts both ways (0.6ms)\n\u2714 expires entries from the previous day (0.4ms)\n\u2139 tests 2\n\u2139 pass 2\n\u2139 fail 0",
+            status: "done",
+            paths: []
+          }
+        },
+        {
+          type: "text",
+          text: "Found it. `ForecastCache.get` compared **local** calendar days, and when the day changed it returned the old entry instead of dropping it:\n\n```ts\nif (day !== new Date(now).getDate()) return entry.value;\n```\n\nI changed it to compare UTC dates and delete the entry, so the first request after midnight goes upstream. The tests pass.\n\n| | Before | After |\n| --- | --- | --- |\n| Day compared | local `getDate()` | UTC `toISOString()` |\n| On a new day | returns stale entry | deletes and refetches |\n\nquiet-otter is adding retries for upstream timeouts in a scoop."
+        }
+      ]
+    },
+    {
+      id: "m-h4",
+      role: "lick",
+      channel: "scoop-notify",
+      title: "quiet-otter",
+      text: "Started: add retries with backoff around the upstream fetch",
+      createdAt: at2(9)
+    }
+  ],
+  "scoop-otter": [
+    {
+      id: "m-o1",
+      role: "user",
+      text: "Wrap the upstream fetch in src/routes/forecast.ts with three retries and exponential backoff.",
+      createdAt: at2(9)
+    },
+    {
+      id: "m-o2",
+      role: "assistant",
+      status: "done",
+      createdAt: at2(10),
+      parts: [
+        {
+          type: "tool",
+          tool: {
+            id: "t-o1",
+            name: "write_file",
+            title: "Add retry()",
+            input: "/workspace/harbor/src/lib/retry.ts",
+            output: "Wrote 12 lines",
+            status: "done",
+            paths: ["/workspace/harbor/src/lib/retry.ts"]
+          }
+        },
+        {
+          type: "tool",
+          tool: {
+            id: "t-o2",
+            name: "edit_file",
+            title: "Use retry() for the upstream call",
+            input: "/workspace/harbor/src/routes/forecast.ts",
+            output: "Replaced 1 block",
+            status: "done",
+            paths: ["/workspace/harbor/src/routes/forecast.ts"]
+          }
+        },
+        { type: "text", text: "Both edits are in. Running the tests next." }
+      ]
+    }
+  ],
+  "scoop-heron": [],
+  "scoop-wren": [],
+  "cone-release": [
+    {
+      id: "m-r1",
+      role: "lick",
+      channel: "cron",
+      title: "Every Friday 09:00",
+      text: "Draft the release notes for example/harbor",
+      createdAt: at2(-1440)
+    },
+    {
+      id: "m-r2",
+      role: "assistant",
+      status: "done",
+      createdAt: at2(-1438),
+      parts: [
+        {
+          type: "tool",
+          tool: {
+            id: "t-r1",
+            name: "bash",
+            title: "Collect merged pull requests",
+            input: "collect.jsh example/harbor v1.8.0",
+            output: "41	fix	Return 400 when the city is missing\n43	feature	Add /health\n44	chore	Update wrangler to 4.40.0",
+            status: "done",
+            paths: ["/workspace/skills/release-notes/scripts/collect.jsh"]
+          }
+        },
+        {
+          type: "text",
+          text: "## harbor 1.9.0\n\n**Features**\n- Added a `/health` endpoint.\n\n**Fixes**\n- Requests without a city now get a 400 instead of a 500.\n\n**Chores**\n- Updated wrangler to 4.40.0."
+        }
+      ]
+    }
+  ],
+  "cone-triage": [
+    {
+      id: "m-t1",
+      role: "system",
+      kind: "compaction",
+      trigger: "threshold",
+      state: "summarized",
+      title: "Context compacted",
+      text: "41 earlier messages were summarized to stay under the context limit.",
+      createdAt: at2(-30)
+    },
+    {
+      id: "m-t2",
+      role: "assistant",
+      status: "done",
+      createdAt: at2(-20),
+      parts: [
+        {
+          type: "text",
+          text: "Two messages need a decision from you:\n\n- A vendor asks to move Thursday\u2019s call to Friday.\n- The staging certificate expires in 6 days. Should I open a ticket?"
+        }
+      ]
+    },
+    {
+      id: "m-t3",
+      role: "system",
+      kind: "error",
+      action: "login",
+      title: "Mail connector",
+      text: "The connector returned 401. Reconnect the account in Settings.",
+      createdAt: at2(-19)
+    }
+  ]
+};
+var tabs = [
+  {
+    id: "tab-preview",
+    title: "harbor \xB7 localhost",
+    url: "http://localhost:8787/forecast?city=Lisbon",
+    status: "complete",
+    agentId: "cone-harbor"
+  },
+  {
+    id: "tab-docs",
+    title: "Forecast API reference",
+    url: "https://api.example.com/docs/v2/forecast",
+    status: "complete",
+    agentId: null
+  },
+  {
+    id: "tab-pull",
+    title: "Add retries for upstream timeouts \xB7 Pull request #58",
+    url: "https://git.example.com/example/harbor/pull/58",
+    status: "complete",
+    agentId: "scoop-otter"
+  }
+];
+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 {
+  #settings;
+  #accounts;
+  #models;
+  #storage;
+  #clock;
+  constructor(defaults2, models2, accounts2, storage, clock2) {
+    super();
+    this.#storage = storage;
+    this.#clock = clock2;
+    this.#models = models2;
+    this.#accounts = accounts2.map((account) => ({ ...account }));
+    this.#settings = { ...defaults2, ...this.#load() };
+  }
+  #load() {
+    try {
+      return JSON.parse(this.#storage?.getItem(key) ?? "{}");
+    } catch {
+      return {};
+    }
+  }
+  get() {
+    return { ...this.#settings };
+  }
+  update(patch) {
+    this.#settings = { ...this.#settings, ...patch };
+    this.#storage?.setItem(key, JSON.stringify(this.#settings));
+    this.emit("settings", this.get());
+  }
+  models() {
+    return this.#models;
+  }
+  accounts() {
+    return this.#accounts.map((account) => ({ ...account }));
+  }
+  #set(id, patch) {
+    this.#accounts = this.#accounts.map(
+      (account) => account.id === id ? { ...account, ...patch } : account
+    );
+    this.emit("accounts", this.accounts());
+  }
+  async connect(id) {
+    await this.#clock.sleep(10);
+    const account = this.#accounts.find((candidate) => candidate.id === id);
+    const identity = account?.identity || `${id}-user@example.com`;
+    this.#set(id, { status: "connected", identity });
+  }
+  disconnect(id) {
+    this.#set(id, { status: "disconnected" });
+  }
+};
+
+// 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();
+var home = "/home/user";
+function resolve(cwd, target) {
+  const path = target === "~" || target.startsWith("~/") ? home + target.slice(1) : target;
+  const parts = (path.startsWith("/") ? path : `${cwd}/${path}`).split("/");
+  const out = [];
+  for (const part of parts) {
+    if (part === "..") out.pop();
+    else if (part && part !== ".") out.push(part);
+  }
+  return `/${out.join("/")}`;
+}
+function shorten(cwd) {
+  return cwd === home || cwd.startsWith(`${home}/`) ? `~${cwd.slice(home.length)}` : cwd;
+}
+var FakeShell = class {
+  #sink;
+  #files;
+  #clock;
+  #line = "";
+  #escape = false;
+  #busy = false;
+  #interrupted = false;
+  #history = [];
+  #commands;
+  cwd;
+  closed = false;
+  constructor(sink, files3, cwd, clock2) {
+    this.#sink = sink;
+    this.#files = files3;
+    this.#clock = clock2;
+    this.cwd = cwd;
+    this.#commands = {
+      help: () => this.#print("Commands: cat cd clear date echo exit git help ls npm pwd whoami"),
+      pwd: () => this.#print(this.cwd),
+      whoami: () => this.#print("user"),
+      date: () => this.#print((/* @__PURE__ */ new Date()).toUTCString()),
+      echo: (args) => this.#print(args.join(" ")),
+      clear: () => this.#out("\x1B[2J\x1B[H"),
+      exit: () => this.#exit(),
+      cd: (args) => this.#cd(args[0] ?? "~"),
+      ls: (args) => this.#ls(args.filter((arg) => !arg.startsWith("-"))[0] ?? "."),
+      cat: (args) => this.#cat(args),
+      git: (args) => this.#git(args[0]),
+      npm: (args) => this.#npm(args[0])
+    };
+    this.#prompt();
+  }
+  #out(text) {
+    this.#sink.output(encoder.encode(text));
+  }
+  #print(text) {
+    this.#out(`${text.replace(/\n/g, "\r\n")}\r
+`);
+  }
+  #prompt() {
+    this.#out(`\x1B[1;32muser@slicc\x1B[0m:\x1B[1;34m${shorten(this.cwd)}\x1B[0m$ `);
+  }
+  #exit() {
+    this.closed = true;
+    this.#sink.exit(0);
+  }
+  async #entries() {
+    return new Map((await this.#files.list()).map((entry) => [entry.path, entry.kind]));
+  }
+  async #cd(target) {
+    const path = resolve(this.cwd, target);
+    if (path === "/" || (await this.#entries()).get(path) === "directory") this.cwd = path;
+    else this.#print(`bash: cd: ${target}: No such file or directory`);
+  }
+  async #ls(target) {
+    const path = resolve(this.cwd, target);
+    const entries = await this.#entries();
+    const prefix = path === "/" ? "/" : `${path}/`;
+    const names = [...entries].filter(
+      ([candidate]) => candidate.startsWith(prefix) && !candidate.slice(prefix.length).includes("/")
+    ).map(([candidate, kind]) => {
+      const name = candidate.slice(prefix.length);
+      return kind === "directory" ? `\x1B[1;34m${name}\x1B[0m` : name;
+    });
+    if (path !== "/" && !entries.has(path))
+      this.#print(`ls: cannot access '${target}': No such file or directory`);
+    else if (names.length > 0) this.#print(names.join("  "));
+  }
+  async #cat(args) {
+    for (const arg of args) {
+      const text = await this.#files.read(resolve(this.cwd, arg)).catch(() => null);
+      if (text === null) this.#print(`cat: ${arg}: No such file or directory`);
+      else this.#out(text.replace(/\n/g, "\r\n"));
+    }
+  }
+  #git(sub) {
+    if (sub !== "status") {
+      this.#print("usage: git status");
+      return;
+    }
+    const changes = this.#files.changes();
+    this.#print("On branch main");
+    if (changes.length === 0) {
+      this.#print("nothing to commit, working tree clean");
+      return;
+    }
+    this.#print("Changes not staged for commit:");
+    const colors = { added: 32, modified: 33, deleted: 31 };
+    for (const change of changes) {
+      this.#print(`	\x1B[${colors[change.status]}m${change.status}:   ${change.path}\x1B[0m`);
+    }
+  }
+  async #npm(sub) {
+    if (sub !== "test") {
+      this.#print("usage: npm test");
+      return;
+    }
+    const lines = [
+      "> harbor@0.0.0 test",
+      "> node --test test/",
+      "",
+      "\x1B[32m\u2714\x1B[0m converts both ways \x1B[90m(0.6ms)\x1B[0m",
+      "\x1B[32m\u2714\x1B[0m expires entries from the previous day \x1B[90m(0.4ms)\x1B[0m",
+      "\x1B[32m\u2714\x1B[0m retries upstream timeouts \x1B[90m(3.1ms)\x1B[0m",
+      "\u2139 tests 3",
+      "\u2139 pass 3",
+      "\u2139 fail 0"
+    ];
+    for (const line of lines) {
+      await this.#clock.sleep(2);
+      if (this.closed || this.#interrupted) return;
+      this.#print(line);
+    }
+  }
+  async #run(line) {
+    const [name, ...args] = line.trim().split(/\s+/);
+    if (!name) return;
+    this.#history.push(line);
+    const command = this.#commands[name];
+    if (command) await command(args);
+    else this.#print(`bash: ${name}: command not found`);
+  }
+  #key(char) {
+    if (this.#escape) {
+      this.#escape = !/[A-Za-z~]/.test(char) || char === "[";
+      return;
+    }
+    if (char === "\x1B") this.#escape = true;
+    else if (char === "\r") this.#enter();
+    else if (char === "\x7F") this.#backspace();
+    else if (char === "") this.signal("SIGINT");
+    else if (char === "\f") {
+      this.#out("\x1B[2J\x1B[H");
+      this.#prompt();
+      this.#out(this.#line);
+    } else if (char >= " ") {
+      this.#line += char;
+      this.#out(char);
+    }
+  }
+  #backspace() {
+    if (!this.#line) return;
+    this.#line = [...this.#line].slice(0, -1).join("");
+    this.#out("\b \b");
+  }
+  #enter() {
+    const line = this.#line;
+    this.#line = "";
+    this.#out("\r\n");
+    this.#busy = true;
+    this.#interrupted = false;
+    void this.#run(line).then(() => {
+      this.#busy = false;
+      if (!this.closed) this.#prompt();
+    });
+  }
+  history() {
+    return this.#history;
+  }
+  write(data) {
+    if (this.closed) return;
+    const text = decoder.decode(data);
+    if (!this.#busy) for (const char of text) this.#key(char);
+    else if (text.includes("")) this.signal("SIGINT");
+  }
+  resize() {
+  }
+  signal(name) {
+    if (name === "SIGHUP") {
+      this.#exit();
+      return;
+    }
+    this.#line = "";
+    this.#interrupted = this.#busy;
+    this.#out("^C\r\n");
+    if (!this.#busy) this.#prompt();
+  }
+  close() {
+    this.closed = true;
+  }
+};
+function shellBackend(files3, cwd, clock2) {
+  return { open: (sink) => new FakeShell(sink, files3, cwd, clock2) };
+}
+
+// src/dummy/terminals.ts
+var DummyTerminals = class extends Emitter {
+  #terminals;
+  #backends = /* @__PURE__ */ new Map();
+  #files;
+  #clock;
+  #next;
+  constructor(terminals2, files3, clock2) {
+    super();
+    this.#files = files3;
+    this.#clock = clock2;
+    this.#terminals = terminals2.map((terminal) => ({ ...terminal }));
+    this.#next = this.#terminals.length + 1;
+  }
+  list() {
+    return this.#terminals.map((terminal) => ({ ...terminal }));
+  }
+  open({
+    cwd = "/workspace/harbor",
+    agentId = null
+  } = {}) {
+    const terminal = {
+      id: `term-${this.#next}`,
+      title: `bash ${this.#next}`,
+      cwd,
+      agentId
+    };
+    this.#next += 1;
+    this.#terminals.push(terminal);
+    this.emit("terminals", this.list());
+    return { ...terminal };
+  }
+  close(id) {
+    this.#terminals = this.#terminals.filter((terminal) => terminal.id !== id);
+    this.#backends.delete(id);
+    this.emit("terminals", this.list());
+  }
+  backend(id) {
+    const terminal = this.#terminals.find((candidate) => candidate.id === id);
+    if (!terminal) throw new Error(`No terminal ${id}`);
+    let backend = this.#backends.get(id);
+    if (!backend) {
+      backend = shellBackend(this.#files, terminal.cwd, this.#clock);
+      this.#backends.set(id, backend);
+    }
+    return backend;
+  }
+};
+
+// 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);
+  const agent = new DummyAgent(
+    agents,
+    conversations,
+    { files: files3, browser },
+    time,
+    queues,
+    frozen
+  );
+  const base = {
+    agent,
+    files: files3,
+    browser,
+    terminals: new DummyTerminals(terminals, files3, time),
+    settings: new DummySettings(
+      defaults,
+      models,
+      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
+};
+//# sourceMappingURL=slicc-dummy.js.map