@ai-ecoverse/slicc-spectrum 1.0.0 → 1.1.0

package/dist/slicc-dummy.js

@@ -0,0 +1,1393 @@
+import {
+  Emitter
+} from "./chunk-T5NHW4KC.js";
+import "./chunk-Q4AC2O6Z.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: "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 script(prompt) {
+  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);
+}
+
+// src/dummy/agent.ts
+function chunks(text) {
+  return text.match(/\S+\s*|\s+/g) ?? [];
+}
+var DummyAgent = class extends Emitter {
+  #agents;
+  #messages = /* @__PURE__ */ new Map();
+  #runs = /* @__PURE__ */ new Map();
+  #active;
+  #clock;
+  #effects;
+  #next = 1;
+  constructor(agents2, conversations2, effects, clock2) {
+    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.#active = this.#agents[0]?.id ?? "";
+  }
+  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());
+  }
+  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) ?? []];
+  }
+  #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 #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;
+    }
+    this.#status(agentId, "working");
+    const tool = {
+      id: `t-${this.#next++}`,
+      name: step.name,
+      title: step.title,
+      input: step.input,
+      output: "",
+      status: "running",
+      paths: step.paths
+    };
+    reply.parts.push({ type: "tool", tool });
+    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 };
+    if (!run.stopped) await step.effect?.({ ...this.#effects, agentId });
+    Object.assign(tool, done);
+    this.emit("message", { agentId, message: reply });
+  }
+  async send(agentId, text) {
+    const agent = this.#agent(agentId);
+    const prompt = text.trim();
+    if (!agent || !prompt) return;
+    this.stop(agentId);
+    const run = { stopped: false };
+    this.#runs.set(agentId, run);
+    this.#post(agentId, {
+      id: `m-${this.#next++}`,
+      role: "user",
+      text: prompt,
+      createdAt: Date.now()
+    });
+    const reply = {
+      id: `m-${this.#next++}`,
+      role: "assistant",
+      parts: [],
+      status: "streaming",
+      createdAt: Date.now()
+    };
+    this.#post(agentId, reply);
+    for (const step of script(prompt)) {
+      if (run.stopped) break;
+      await this.#step(agentId, reply, step, run);
+    }
+    reply.status = run.stopped ? "stopped" : "done";
+    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;
+    this.emit("message", { agentId, message: reply });
+    agent.status = "idle";
+    this.#changed();
+  }
+  stop(agentId) {
+    const run = this.#runs.get(agentId);
+    if (run) run.stopped = true;
+  }
+};
+
+// 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);
+  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/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, now) {
+    this.#mkdirs(path);
+    this.#contents.set(path, text);
+    this.#modified.set(path, now);
+  }
+  #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/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
+  },
+  {
+    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 start = Date.UTC(2026, 9, 5, 8, 30);
+var at = (minutes) => start + minutes * 6e4;
+var conversations = {
+  "cone-sliccy": [
+    {
+      id: "m-s1",
+      role: "user",
+      text: "What is on my plate today?",
+      createdAt: at(0)
+    },
+    {
+      id: "m-s2",
+      role: "assistant",
+      status: "done",
+      createdAt: at(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: "event",
+      kind: "webhook",
+      title: "GitHub \xB7 issue opened",
+      text: "example/harbor#57: Forecast stays on yesterday after midnight UTC",
+      createdAt: at(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)
+    },
+    {
+      id: "m-h3",
+      role: "assistant",
+      status: "done",
+      createdAt: at(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: "event",
+      kind: "scoop",
+      title: "quiet-otter",
+      text: "Started: add retries with backoff around the upstream fetch",
+      createdAt: at(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: at(9)
+    },
+    {
+      id: "m-o2",
+      role: "assistant",
+      status: "done",
+      createdAt: at(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: "event",
+      kind: "cron",
+      title: "Every Friday 09:00",
+      text: "Draft the release notes for example/harbor",
+      createdAt: at(-1440)
+    },
+    {
+      id: "m-r2",
+      role: "assistant",
+      status: "done",
+      createdAt: at(-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: "event",
+      kind: "compaction",
+      title: "Context compacted",
+      text: "41 earlier messages were summarized to stay under the context limit.",
+      createdAt: at(-30)
+    },
+    {
+      id: "m-t2",
+      role: "assistant",
+      status: "done",
+      createdAt: at(-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: "event",
+      kind: "error",
+      title: "Mail connector",
+      text: "The connector returned 401. Reconnect the account in Settings.",
+      createdAt: at(-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/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/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/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),
+    files: files3,
+    browser,
+    terminals: new DummyTerminals(terminals, files3, time),
+    settings: new DummySettings(
+      defaults,
+      models,
+      accounts,
+      storage,
+      time
+    )
+  };
+}
+export {
+  createDummyModel
+};
+//# sourceMappingURL=slicc-dummy.js.map