@ai-ecoverse/slicc-spectrum 1.34.0 → 1.36.0

package/README.md

@@ -134,21 +134,21 @@ Text is Adobe Clean Spectrum VF, falling back to Adobe Clean, and code is Spectr
 | `<slicc-app>` | The shell: header with the agent picker, status items, the update status, the network indicator, the tray, the View menu and the theme switch, rails, and a `<slicc-dock>`. Saves the dock layout per screen class to `storage` (default `localStorage`) under `layoutKey`. While connected it sets `overscroll-behavior` to `none !important` on the page's `html` and `body`, so only scroll areas inside panels rubber-band. When the last app on the page is removed, the page's own inline values come back. |
 | `<slicc-dock>` | Generic. [dockview-core](https://dockview.dev/) 8 with a theme mapped to Spectrum tokens, in its own shadow root. Panels come from `factories` (`name → (params) => HTMLElement`). `open`, `close`, `has`, `content`, `focusPanel`, `cycleGroup`, `cycleTab`, `toJSON`, `restore`, `clear`, and the full `api`. Tabs have a context menu (close, close others, float, maximize). Events: `layout-change`, `active-panel-change`, `panel-close`. |
 | `<slicc-agents>` | Cones with their scoops, status, context fill and unread count. Selecting one makes it the active agent. |
-| `<slicc-chat>` | One thread's conversation (its `agent`, or the active agent if unset), by day: user messages (with attachments, tagged as steered or follow-up by `delivered`, or delegated from another cone), assistant messages (Markdown with tables, task lists, quotes, code and images; thinking; tool calls, grouped into a collapsible cluster from three in a row, each with its input (a shell command after `$`), an optional `meta` such as a timeout, and an edit's `diff` shown as a diff view; media galleries with images, video and audio; action cards for tools, pull requests and status; plans and checklists; inline diffs; question prompts; delegations; link previews; errors with a fix-it action; a content-filter stop offers **Drop the last turn**, which rewinds that turn and puts its prompt back into the composer; when the turns right before it failed too, the button reads **Drop N failed turns** and rewinds to before the first of them, putting the latest prompt back), standalone tool results, system messages (compaction markers, error cards, notices) and licks, SLICC's events into a cone, on every channel; a lick's `severity` (`warn` or `error`) turns its channel badge into a notice or negative one with an alert icon. Permission requests are allowed or denied in place. The header shows the status, a model picker that names each model's provider and leaves out classifiers and models with `tools: false`, the thinking picker, the context meter and **New chat**, which calls `clear` and puts focus back in the composer. |
+| `<slicc-chat>` | One thread's conversation (its `agent`, or the active agent if unset), by day: user messages (with attachments, tagged as steered or follow-up by `delivered`, or delegated from another cone), assistant messages (Markdown with tables, task lists, quotes, code and images; thinking; tool calls, grouped into a collapsible cluster from three in a row, each with its input (a shell command after `$`), an optional `meta` such as a timeout, and an edit's `diff` shown as a diff view; media galleries with images, video and audio; action cards for tools, pull requests and status; plans and checklists; inline diffs; question prompts; delegations; link previews; errors with a fix-it action; a content-filter stop offers **Drop the last turn**, which rewinds that turn and puts its prompt back into the composer; when the turns right before it failed too, the button reads **Drop N failed turns** and rewinds to before the first of them, putting the latest prompt back), standalone tool results, system messages (compaction markers, error cards, notices) and licks, SLICC's events into a cone, on every channel; a lick's `severity` (`warn` or `error`) turns its channel badge into a notice or negative one with an alert icon. Permission requests are allowed or denied in place. The header shows the status, a model picker that names each model's provider and leaves out classifiers and models with `tools: false`, the thinking picker, the context meter and **New chat**, which calls `clear` and puts focus back in the composer; on a cone, when the port can freeze, its tooltip says the old chat goes to the freezer. |
 | `<slicc-composer>` | The message box. <kbd>Enter</kbd> sends, or steers a running reply: the message joins after the current tool round, without interrupting; <kbd>Ctrl</kbd>/<kbd>⌘</kbd>+<kbd>Enter</kbd> queues a follow-up that runs after the reply and can be withdrawn; <kbd>Shift</kbd>+<kbd>Enter</kbd> adds a line; <kbd>Tab</kbd> takes the suggested follow-up; <kbd>↑</kbd>/<kbd>↓</kbd> at the start or end walk this agent's history; <kbd>Esc</kbd> stops. `/` completes commands (`/clear`, `/compact`, `/model`, `/thinking`, `/scoop`, `/stop`, `/freeze` when the port can freeze, `/theme`) and their arguments, `@` mentions agents and files. Attach from the computer, from SLICC's files, a browser screenshot or a shared secret, or paste and drop files (25 MB each). Queued messages wait above it, to send now or drop. Model and thinking pickers, and dictation where the browser has speech recognition. Drafts are kept per agent. |
 | `<slicc-files>` | The file system as a `<slicc-file-tree>`, with pending changes as git status. Opening a file opens it in a tab. With `files.mountFolder`, **Mount a folder…** (`data-action="mount-folder"`) mounts a local folder, then selects and expands it in the tree; with `files.mounts`, a **Mounted** strip lists the mount points, each with **Eject** (`data-action="eject"`, `data-path` the mount point) when the port has `eject`. With `files.needsFolder`, a **Needs a folder** section lists the mount points waiting for a folder, each with **Insert folder…** (`data-action="insert-folder"`, `data-id` the mount point), which calls `mountFolder(path)`. A failed mount, insert or eject shows its message under the bar. |
 | `<slicc-file-view>` | One file (`path`), highlighted, with its pending change and a link to the diff. |
-| `<slicc-changes>` | Pending changes with their author. Opens the diff, accepts or reverts one change or all of them. |
-| `<slicc-diff-panel>` | The diff of one pending change (`path`), unified or split, with accept and revert. |
+| `<slicc-changes>` | Pending changes with their author. Opens the diff, accepts or reverts one change or all of them. Changes with a `repo` show their folder relative to it, and no author when `agentId` is `null`; with more than one repository they group under a header per repository (its path and count), in the order the port returns them. Revert and Revert all ask with a destructive confirm that says the uncommitted (or, without a repo, pending) changes can't be undone; a failed revert shows its message under the bar. When the port's `unavailable()` returns a string, the panel shows it instead of the list. |
+| `<slicc-diff-panel>` | The diff of one pending change (`path`), unified or split, with accept and revert. A change with `before` and `after` both `null` (a binary file, or text over 1 MB) shows “No diff for this file” and Open the file instead, and keeps Accept and Revert. |
 | `<slicc-terminals>` | Terminal sessions in tabs, each a `<slicc-terminal>` on the session's `TerminalBackend`. Sessions stay alive while hidden; `exit` closes the tab. |
 | `<slicc-browser>` | Browser tabs with the agent driving each, an address bar, reload, and the active tab's screenshot. |
 | `<slicc-settings>` | Theme, the model and thinking level for new cones, composer and diff preferences, and accounts to connect, reconnect or disconnect. An account whose status is `signing-in` (or a non-API-key account while its `connect` is pending) reads “Signing in…”; when the port has `cancel(id)`, its row offers Cancel (`data-action="cancel-sign-in"`), and the rejected `connect` that follows shows no error. |
 | `<slicc-updates>` | Install / Update: component states, version changes, last checks, download and link counts, action buttons, failures with Retry, and collapsible install logs. Opens at boot until the agent is ready without failures. Background updates stay in the header's update status; new failures reopen the panel. Also available through View and the rails. |
 | `<slicc-memory>` | What agents remember, per scope (everyone, a cone or a role), grouped by section: search, filter by tag, expand, edit, add and forget. Free text outside an entry shows “From MEMORY.md”. |
 | `<slicc-monitor>` | The live monitor: vitals with sparklines (active agents, spend, budget, fullest context), alerts, and the topology (cones and scoops, terminals, tabs, pending changes, sprinkles, tray followers). |
-| `<slicc-freezer>` | Frozen cones, archived with their scoops: thaw to bring one back, delete, or freeze the active cone (also `/freeze`). |
+| `<slicc-freezer>` | Frozen cones, archived with their scoops, and the chats New chat put away: thaw to bring one back, delete, or freeze the active cone (also `/freeze`). |
 | `<slicc-sprinkle>` | A SLICC sprinkle (`.shtml`), as a panel or, with `inline`, as a dip in the chat that grows to fit. A dip has a tab-like handle: drag it into the dock (or onto a rail, or use its open-as-panel button) and it lives on as a sprinkle panel, with a note in the chat where it was; which dips are out is saved in `slicc-ui.dips`. It runs in a sandboxed frame (`allow-scripts` only) with SLICC's sprinkle theme (the `--s2-*` tokens and `.sprinkle-*` classes), the app's fonts, and Lucide icons (`<i data-lucide>`, `LucideIcons.render()`). It talks back through `slicc.lick({ action, data })`, which reaches the owning cone as a `sprinkle` lick, and, when the port has `call`, reads files and keeps state (see [Sprinkle bridge](#sprinkle-bridge)). Panel sprinkles sit at the top of the right rail with their Lucide icon. |
-| `<slicc-network>` | Network: the route and its health in plain words with the bios `detail`, **Check again** (`data-action="check"`) when the port has `check`, **Get the whole web** with the Chrome extension link (`data-action="install-extension"`, when `extensionUrl` is set) and `npx @ai-ecoverse/slicc-node` with a copy button (`data-action="copy-command"`), folded away when the route already reaches the whole web, and recent failures with host, error and time. The header's **Network** indicator (`data-network`, `data-health`) opens it: a status light, green for `ok`, yellow for `limited` and red for `failing`, with the state in its text and label and `detail` as its tooltip; on a phone, a cloud icon for the state. Offered only when the model has a `network` port. |
+| `<slicc-network>` | Network: the route and its health in plain words with the bios `detail`, a line on browser automation (`data-browser`: through the SLICC extension, through slicc-node, not available with how to get it, or `declined`, muted: off for this session, reload to be asked again) when the status has `browser`, **Check again** (`data-action="check"`) when the port has `check`, **Get the whole web** with the Chrome extension link (`data-action="install-extension"`, when `extensionUrl` is set) and `npx @ai-ecoverse/slicc-node` with a copy button (`data-action="copy-command"`), folded away when the route already reaches the whole web, and recent failures with host, error and time. The header's **Network** indicator (`data-network`, `data-health`) opens it: a status light, green for `ok`, yellow for `limited` and red for `failing`, with the state in its text and label and `detail` as its tooltip; on a phone, a cloud icon for the state. Offered only when the model has a `network` port. |
 | `<slicc-tray>` | The tray indicator in the header: connection, the float's name, followers and budget; its panel adds role, runtime, spend, the follower list, the join link, and disconnect or reconnect. |
 | `<slicc-confirm>` | The confirmation dialog `confirm()` opens. Not for direct use. |
 | `<slicc-prompt>` | The name dialog `prompt()` opens. Not for direct use. |
@@ -162,7 +162,7 @@ Keys: <kbd>Alt</kbd>+<kbd>1</kbd>… opens and focuses a panel, <kbd>F6</kbd> an
 
 ### Confirmations
 
-Destructive actions ask first: reverting one change or all, deleting a frozen cone, forgetting a memory, disconnecting an account or the tray, and closing a terminal. `confirm({ title, body, action, variant, trigger })`, exported from `dist/slicc-ui.js`, opens a modal alert dialog (1.12 `sp-alert-dialog`, as Gen2 has no dialog yet) inside `<slicc-app>`'s themed shadow root and resolves `true` on the action and `false` on Cancel or <kbd>Esc</kbd>. Focus starts on Cancel and goes back to `trigger` (default: the focused element) when it closes. `variant` is `destructive` (default, a negative action button) for actions that lose data for good, or `confirmation` (accent) for ones you can take back, like disconnecting. Title the dialog with a question, say what can’t be undone in `body`, and name the action with a verb.
+Destructive actions ask first: reverting one change or all, deleting a frozen cone, forgetting a memory, disconnecting an account or the tray, and closing a terminal. `confirm({ title, body, action, variant, cancel, trigger })`, exported from `dist/slicc-ui.js`, opens a modal alert dialog (1.12 `sp-alert-dialog`, as Gen2 has no dialog yet) inside `<slicc-app>`'s themed shadow root and resolves `true` on the action and `false` on Cancel or <kbd>Esc</kbd>. `cancel` renames Cancel, for example “Don’t allow” next to “Allow” in a permission prompt. Focus starts on Cancel and goes back to `trigger` (default: the focused element) when it closes. `variant` is `destructive` (default, a negative action button) for actions that lose data for good, or `confirmation` (accent) for ones you can take back, like disconnecting. Title the dialog with a question, say what can’t be undone in `body`, and name the action with a verb.
 
 ```js
 import { confirm } from './dist/slicc-ui.js';
@@ -195,21 +195,22 @@ Paths are the agent's: `/shared/…` and `/home/…`, nothing else. A refusal or
 
 | Port | Later backed by | |
 | :--- | :--- | :--- |
-| `agent` | `@ai-ecoverse/slicc-agent` | Cones and scoops, the active agent, conversations, `send` (with attachments, as a send, a steer or a queued follow-up) and `stop`, the queue, suggestions, answers to questions, permission decisions, compaction, clearing, the model per agent and new scoops. The optional `rewind(agentId, messageId)` drops the user turn before that message and everything after it, and resolves with the turn's prompt (text and attachments) for the composer, or `null`. The optional `drop(agentId)` removes a scoop: it stops and its working folder is deleted, while its conversation and reports are kept, and `createCone(name)` resolves with a new cone; the dummy rejects a cone name that is taken. `freeze(agentId)` is optional too: without it, `/freeze` and the Freezer's freeze button don't show. Assistant messages stream: the same message is re-emitted as its parts grow and its tool calls go from `running` to `done`. |
+| `agent` | `@ai-ecoverse/slicc-agent` | Cones and scoops, the active agent, conversations, `send` (with attachments, as a send, a steer or a queued follow-up) and `stop`, the queue, suggestions, answers to questions, permission decisions, compaction, clearing (`clear(agentId)` starts a new chat: on a cone, a port with `freeze` first puts the old chat in the freezer as its own entry, which thaws into a cone of its own; a scoop's chat is just reset), the model per agent and new scoops. The optional `rewind(agentId, messageId)` drops the user turn before that message and everything after it, and resolves with the turn's prompt (text and attachments) for the composer, or `null`. The optional `drop(agentId)` removes a scoop: it stops and its working folder is deleted, while its conversation and reports are kept, and `createCone(name)` resolves with a new cone; the dummy rejects a cone name that is taken, and names a thawed cone `<name> (earlier)`, then `(earlier 2)` and so on, when its name is taken. `freeze(agentId)` is optional too: without it, `/freeze` and the Freezer's freeze button don't show. Assistant messages stream: the same message is re-emitted as its parts grow and its tool calls go from `running` to `done`. |
 | `files` | slicc-kernel's OPFS | `list`, `read`, `write`, `remove`, and pending changes with their before and after text (`accept`, `revert`). The optional `mountFolder()` asks for a local folder and resolves with its mount point (for example `/mnt/photos`), or `null` when the user cancels; the panel calls it synchronously in the click, so the port can call `showDirectoryPicker()`. The optional `mounts()` lists the mount points, and `eject(path)` unmounts one (the folder stays on disk). `mountFolder(path)` inserts the picked folder at a mount point that waits for one; the optional `needsFolder()` lists those mount points. The port emits `mounts` and then `files` after every mount and eject, including those made from the shell, and `mounts` whenever `needsFolder()` changes. |
 | `terminals` | slicc-kernel's terminal API | Terminal sessions; `backend(id)` returns a `TerminalBackend` for `<slicc-terminal>`. |
 | `browser` | `@ai-ecoverse/slicc-cdp` | Tabs, the active tab, `open`, `navigate`, `close`, `screenshot`. |
 | `settings` | local storage | Theme, model, thinking level, composer and diff preferences, the models on offer, and accounts. |
+| `changes` (optional) | `@ai-ecoverse/slicc-agent` | Pending changes from git instead of the file system: `changes()`, `accept(path)` (stage), `revert(path)` (discard), and a `changes` event, as on `files`. When present, the UI reads changes only from this port, including the rail's count. A `Change` may carry `repo`, its repository root; put the active agent's repository first. The optional `unavailable()` returns why there can be no changes (no git, no repository), which the panel shows as is, or `null`; emit `changes` when it flips. |
 | `memory` | `@ai-ecoverse/slicc-agent` | Memories with scope, section, tag and body; `save` and `remove`. `source: 'notes'` marks free text the panel shows as an entry titled after its section; saving it makes it an entry. The optional `scopes()` lists the scope picker's choices as `{ id, label, group }`, ungrouped first, then under “Cones” and “Roles”; without it the picker offers “Everyone” (`global`) and each cone. The panel re-reads `scopes()` on `memories` and `agents`, so emit `memories` when the list changes. A scope that disappears falls back to `global`. |
 | `monitor` | all of them | A snapshot of vitals, alerts and sections, re-emitted as the system changes, and `resync`. |
 | `sprinkles` | `@ai-ecoverse/slicc-agent` | Sprinkles (`inline` ones show as dips in the chat, not in the rail) and `send`, which turns a sprinkle's lick into a lick on its cone. The optional `call(id, method, args)` serves the [sprinkle bridge](#sprinkle-bridge) for sprinkle `id`: `readFile` and `exists` (`[path]`) resolve with a string and a boolean, `getState` (`[]`) with the saved value or `null`, and `setState` (`[value]`) once it is saved. The adapter owns path policy and keeps state per sprinkle; `<slicc-sprinkle>` awaits `getState` before it builds a frame, mirrors what the frame saves, and forwards only these four methods from its own frame. The dummy keeps state in memory and maps `/shared/x` to `/home/x` in its files, refusing anything outside `/home`. |
 | `tray` | the tray protocol | Connection, role, float kind, followers, spend and budget; `reconnect` and `disconnect`. |
 | `updates` (optional) | BIOS installers | `list()` returns `UpdateItem` rows for BIOS, kernel, agent, grammars, global pnpm packages, skills and UI. `ready()` explicitly reports agent readiness, independently of agent activity. Emit `items` whenever rows or readiness change. Use `queued` for a row that waits for another component before it starts; it reads "Waiting" and doesn't count as updating. A `failed` row with an installed `from` version reads "Update failed". `act(id, action)` resolves when dispatched or rejects with a displayed error; actions are `retry`, `update-now`, `restart-agent` and `reload`. Missing ports preserve existing adapters and report disconnected information in the panel. Real installer wiring belongs to ai-ecoverse/slicc-bios#70. |
-| `network` (optional) | BIOS | `status()` returns the `NetworkStatus`: `route` (`proxy` for slicc-node, `extension` for the Chrome extension relay, `page` for the page's own fetch, limited by CORS, or `null`), `health` (`ok`, `limited` or `failing`, decided by the port), a one-line `detail`, recent `failures` (`{ url, error, at }`, newest first) and an optional `extensionUrl`. Emit `network` when it changes. The optional `check()` tests the route again. Without the port, the indicator and the Network panel don't show. |
+| `network` (optional) | BIOS | `status()` returns the `NetworkStatus`: `route` (`proxy` for slicc-node, `extension` for the Chrome extension relay, `page` for the page's own fetch, limited by CORS, or `null`), `health` (`ok`, `limited` or `failing`, decided by the port), a one-line `detail`, recent `failures` (`{ url, error, at }`, newest first), an optional `extensionUrl` and an optional `browser` (`{ via, detail?, declined? }`, `via` being `extension`, `proxy` or `null` when browser automation isn't available, and `declined: true` once the user declined browser control for the session). Emit `network` when it changes. The optional `check()` tests the route again. Without the port, the indicator and the Network panel don't show. |
 
-The dummy supports `createDummyModel({ updates: 'boot' | 'current' | 'available' | 'restart' | 'failure' })`, also selectable with `?updates=` on `/ui/`. Fixtures stay stable for inspection; `model.updates.setScenario('current')` completes boot. Dummy Update now and Retry simulate download and link progress; Restart agent and Reload only change fixture state, never restart a real process or reload the browser. `updateFixtures` and `DummyUpdates` are exported from `/dummy`. `createDummyModel({ mounts: 'mount' | 'cancel' | 'fail' | 'needs' })` (or `?mounts=` on `/ui/`) turns on the optional mount members, which are off by default: `mountFolder` mounts invented files at `/mnt/photos`, resolves with `null`, or rejects, as `model.files.mount.scenario` says; `needs` also lists `/mnt/photos` in `needsFolder()` until a folder is inserted there. `createDummyModel({ network: 'ok' | 'limited' | 'failing' | 'off' })` (or `?network=` on `/ui/`, default `limited`) sets the dummy network: slicc-node, the page fetch with CORS failures, or no route, all invented; `off` leaves out the port. `model.network.setScenario()` switches it and Check again re-emits after a short wait. `networkFixtures` and `DummyNetwork` are exported from `/dummy`.
+The dummy supports `createDummyModel({ updates: 'boot' | 'current' | 'available' | 'restart' | 'failure' })`, also selectable with `?updates=` on `/ui/`. Fixtures stay stable for inspection; `model.updates.setScenario('current')` completes boot. Dummy Update now and Retry simulate download and link progress; Restart agent and Reload only change fixture state, never restart a real process or reload the browser. `updateFixtures` and `DummyUpdates` are exported from `/dummy`. `createDummyModel({ mounts: 'mount' | 'cancel' | 'fail' | 'needs' })` (or `?mounts=` on `/ui/`) turns on the optional mount members, which are off by default: `mountFolder` mounts invented files at `/mnt/photos`, resolves with `null`, or rejects, as `model.files.mount.scenario` says; `needs` also lists `/mnt/photos` in `needsFolder()` until a folder is inserted there. `createDummyModel({ network: 'ok' | 'limited' | 'failing' | 'off' })` (or `?network=` on `/ui/`, default `limited`) sets the dummy network: slicc-node (with browser automation through it), the page fetch with CORS failures, or no route, all invented; `off` leaves out the port. `model.network.setScenario()` switches it and Check again re-emits after a short wait. `networkFixtures` and `DummyNetwork` are exported from `/dummy`. `createDummyModel({ changes: 'files' | 'git' | 'nogit' })` (or `?changes=` on `/ui/`, default `files`) adds a git `changes` port: `git` lists the pending changes under `/workspace/harbor` and `/workspace/skills` with their `repo` and no author, and `nogit` reports git as unavailable. `DummyChanges` is exported from `/dummy`.
 
-On phones the tray and the network indicator use compact indicators (their full status remains available on activation), the agent picker shrinks to fit, and the bottom rail scrolls when needed. The update status comes first so progress and failures remain reachable on narrow screens.
+On phones the update status and the tray show only their status light and the network indicator a cloud icon, with the text in their labels and tooltips; the agent picker keeps room for the cone's name, cut with an ellipsis when long, and the bottom rail scrolls when needed. The update status comes first so progress and failures remain reachable on narrow screens.
 
 ### Kernel model
 
@@ -235,7 +236,7 @@ Each section is its own port, so an embedder can mix real and dummy per section,
 
 `<slicc-file-view>` has **Edit**: the file opens in a plain text area, and **Save** or `Mod+S` writes it through `files.write`; `Escape` cancels.
 
-The `kitchen-sink` cone holds every kind of message, content and lick in one conversation, for design work and screenshots. The dummy's fixtures are invented: a small forecast API called harbor, with cones, scoops, a conversation per agent, pending changes, browser tabs and accounts. Its only sprinkles are SLICC's own: `welcome` (the onboarding wizard, as a dip in the sliccy cone) and `suggestions`, copied from `slicc` (`packages/vfs-root/shared/sprinkles/`, commit `aa29784`) with their comments stripped, as is the sprinkle theme in `src/app/sprinkle-theme.css`. `suggestions` reads its stream from the invented `/home/.gelatiere/suggestions.json` through the bridge; there is no `/home/.welcomed`, so `welcome` starts its wizard. Its replies are scripted by keyword (tests, fix or add, open or docs, files, anything else), and their tool calls act on the other ports: an edit writes a file and shows up as a change, a browse opens a tab.
+The `kitchen-sink` cone holds every kind of message, content and lick in one conversation, for design work and screenshots. The dummy's fixtures are invented: a small forecast API called harbor, with cones, scoops, a conversation per agent, pending changes (one of them binary, without a diff), browser tabs and accounts. Its only sprinkles are SLICC's own: `welcome` (the onboarding wizard, as a dip in the sliccy cone) and `suggestions`, copied from `slicc` (`packages/vfs-root/shared/sprinkles/`, commit `aa29784`) with their comments stripped, as is the sprinkle theme in `src/app/sprinkle-theme.css`. `suggestions` reads its stream from the invented `/home/.gelatiere/suggestions.json` through the bridge; there is no `/home/.welcomed`, so `welcome` starts its wizard. Its replies are scripted by keyword (tests, fix or add, open or docs, files, anything else), and their tool calls act on the other ports: an edit writes a file and shows up as a change, a browse opens a tab.
 
 ### Distribution
 

package/dist/slicc-dummy.js

@@ -7,6 +7,38 @@ import {
 } from "./chunk-T5NHW4KC.js";
 import "./chunk-AXQFWXYZ.js";
 
+// src/dummy/changes.ts
+var repos = ["/workspace/harbor", "/workspace/skills"];
+var noGit = "Changes needs git and a git repository. Install git with pnpm add -g @ai-ecoverse/wasm-git, then git init, or clone with slicc-node or the extension connected.";
+function repoOf(path) {
+  return repos.find((repo) => path.startsWith(`${repo}/`));
+}
+var DummyChanges = class {
+  #files;
+  #git;
+  constructor(files3, git) {
+    this.#files = files3;
+    this.#git = git;
+  }
+  on = (type, listener) => this.#files.on(type, () => listener(this.changes()));
+  changes() {
+    if (!this.#git) return [];
+    return this.#files.changes().flatMap((change) => {
+      const repo = repoOf(change.path);
+      return repo ? [{ ...change, agentId: null, repo }] : [];
+    });
+  }
+  accept(path) {
+    this.#files.accept(path);
+  }
+  revert(path) {
+    return this.#files.revert(path);
+  }
+  unavailable() {
+    return this.#git ? null : noGit;
+  }
+};
+
 // src/dummy/script.ts
 var units = "/workspace/harbor/src/lib/units.ts";
 var kelvin = `
@@ -232,6 +264,7 @@ var DummyAgent = class extends Emitter {
   #effects;
   #next = 1;
   #cones = 1;
+  #chats = 1;
   constructor(agents2, conversations2, effects, clock2, queues2 = {}, frozen2 = []) {
     super();
     this.#clock = clock2;
@@ -533,11 +566,28 @@ var DummyAgent = class extends Emitter {
     if (!this.#messages.has(agentId)) return;
     this.#runs.get(agentId)?.steers.splice(0);
     this.stop(agentId);
+    const agent = this.#agent(agentId);
+    const messages = this.#messages.get(agentId);
+    if (agent.kind === "cone" && messages.length) this.#shelve(agent, messages);
     this.#messages.set(agentId, []);
     this.#queues.set(agentId, []);
     this.#suggestions.delete(agentId);
     this.emit("messages", agentId);
   }
+  #shelve(agent, messages) {
+    const id = `${agent.id}-chat-${this.#chats++}`;
+    const first = messages.find((message) => message.role === "user");
+    this.#frozen.unshift({
+      id,
+      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(id, [{ agent: { ...agent, id, status: "idle", unread: 0 }, messages }]);
+    this.emit("frozen", this.frozen());
+  }
   setModel(agentId, model) {
     const agent = this.#agent(agentId);
     if (!agent) return;
@@ -679,7 +729,15 @@ var DummyAgent = class extends Emitter {
       return { ...agent };
     }
     this.#ice.delete(id);
-    this.#frozen = this.#frozen.filter((cone) => cone.id !== id);
+    this.#frozen = this.#frozen.filter((cone2) => cone2.id !== id);
+    const cone = ice[0].agent;
+    const taken = (name) => this.#agents.some((agent) => agent.kind === "cone" && agent.name === name);
+    if (taken(cone.name)) {
+      const base = cone.name;
+      let n = 1;
+      cone.name = `${base} (earlier)`;
+      while (taken(cone.name)) cone.name = `${base} (earlier ${++n})`;
+    }
     for (const { agent, messages } of ice) {
       this.#agents.push(agent);
       this.#messages.set(agent.id, messages);
@@ -1961,8 +2019,8 @@ var DummyFiles = class extends Emitter {
     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);
+      if (change.status === "deleted") this.#contents.delete(change.path);
+      else if (change.after !== null) this.#put(change.path, change.after, 0);
     }
   }
   #mkdirs(path) {
@@ -2037,8 +2095,8 @@ var DummyFiles = class extends Emitter {
     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());
+    if (change.before !== null) this.#put(path, change.before, Date.now());
+    else if (change.status === "added") this.#contents.delete(path);
     this.#announce(path);
   }
   async #mountFolder(mount, point) {
@@ -2982,6 +3040,7 @@ var files2 = {
   "/workspace/harbor/src/lib/cache.ts": cacheBefore,
   "/workspace/harbor/src/lib/units.ts": units2,
   "/workspace/harbor/src/legacy/xml.ts": legacyXml,
+  "/workspace/harbor/static/radar.png": "\x89PNG\r\n\n",
   "/workspace/harbor/test/units.test.ts": unitsTest,
   "/workspace/skills/release-notes/SKILL.md": skill,
   "/workspace/skills/release-notes/scripts/collect.jsh": collect,
@@ -3027,8 +3086,23 @@ var pending = [
     before: legacyXml,
     after: null,
     agentId: "cone-harbor"
+  },
+  {
+    path: "/workspace/harbor/static/radar.png",
+    status: "modified",
+    before: null,
+    after: null,
+    agentId: "scoop-otter"
   }
 ];
+var skillEdit = {
+  path: "/workspace/skills/release-notes/SKILL.md",
+  status: "modified",
+  before: skill,
+  after: `${skill}4. Link each change to its pull request.
+`,
+  agentId: null
+};
 var models = [
   { id: "claude-opus-5-5", label: "Claude Opus 5.5", provider: "Anthropic", images: true },
   { id: "claude-sonnet-5-5", label: "Claude Sonnet 5.5", provider: "Anthropic", images: true },
@@ -3527,11 +3601,13 @@ var DummyMonitor = class extends Emitter {
     model.agent.on("agents", update);
     model.terminals.on("terminals", update);
     model.browser.on("tabs", update);
-    model.files.on("changes", update);
+    const changes = model.changes ?? model.files;
+    changes.on("changes", update);
     model.tray.on("status", update);
   }
   snapshot() {
     const { agent, terminals: terminals2, browser, files: files3, sprinkles: sprinkles2, tray: tray2 } = this.#model;
+    const changes = this.#model.changes ?? files3;
     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;
@@ -3616,7 +3692,11 @@ var DummyMonitor = class extends Emitter {
         {
           id: "changes",
           label: "Pending changes",
-          rows: files3.changes().map((change) => ({ name: change.path, meta: change.status, status: "warn" }))
+          rows: (changes.unavailable?.() ? [] : changes.changes()).map((change) => ({
+            name: change.path,
+            meta: change.status,
+            status: "warn"
+          }))
         },
         {
           id: "sprinkles",
@@ -3655,7 +3735,8 @@ function networkFixtures(scenario, now2 = Date.now()) {
       health: "ok",
       detail: "slicc-node on localhost:5710 reaches every site.",
       failures: [],
-      extensionUrl
+      extensionUrl,
+      browser: { via: "proxy", detail: "Chrome on localhost:9222." }
     };
   }
   if (scenario === "limited") {
@@ -3675,7 +3756,8 @@ function networkFixtures(scenario, now2 = Date.now()) {
           at: now2 - 14 * minute
         }
       ],
-      extensionUrl
+      extensionUrl,
+      browser: { via: null }
     };
   }
   return {
@@ -3699,7 +3781,8 @@ function networkFixtures(scenario, now2 = Date.now()) {
         at: now2 - 75 * minute
       }
     ],
-    extensionUrl
+    extensionUrl,
+    browser: { via: null }
   };
 }
 var DummyNetwork = class extends Emitter {
@@ -4171,11 +4254,13 @@ function createDummyModel({
   storage = null,
   updates = "current",
   mounts = "off",
-  network = "limited"
+  network = "limited",
+  changes = "files"
 } = {}) {
   const time = clock(delay);
   const mount = mounts === "off" ? null : { scenario: mounts, point: mountPoint, files: mounted };
-  const files3 = new DummyFiles(files2, directories, pending, time, mount);
+  const pending2 = changes === "git" ? [...pending, skillEdit] : pending;
+  const files3 = new DummyFiles(files2, directories, pending2, time, mount);
   const browser = new DummyBrowser(tabs, time);
   const agent = new DummyAgent(
     agents,
@@ -4205,11 +4290,13 @@ function createDummyModel({
     sprinkles: new DummySprinkles(sprinkles, agent, files3),
     tray: new DummyTray(tray, time),
     updates: new DummyUpdates(updates, time),
-    ...network === "off" ? {} : { network: new DummyNetwork(network, time) }
+    ...network === "off" ? {} : { network: new DummyNetwork(network, time) },
+    ...changes === "files" ? {} : { changes: new DummyChanges(files3, changes === "git") }
   };
   return { ...base, monitor: new DummyMonitor(base) };
 }
 export {
+  DummyChanges,
   DummyNetwork,
   DummyUpdates,
   createDummyModel,