@ai-ecoverse/slicc-spectrum 1.96.1 → 1.97.0

package/README.md

@@ -303,6 +303,7 @@ Between the header and the transcript, a `<slicc-notices>` shows the model's not
 On a follower without Control, or while the agent port's `readOnly()` returns a line, a note (`p[data-follow="watch"]`, that line first, else the follow-based one) takes the composer's place, the header shows the model's name instead of the pickers and New conversation, and there's no suggested follow-up.
 An empty chat says "No messages yet.
 Ask sliccy something." with the agent's name, and only "No messages yet." while watch-only.
+While the agent port's `starting()` returns a line, the chat has no empty state (`[data-empty]`): the embedder's notice says what's going on.
 With the model's `seat` set, the chat is a guest's page: the header shows only the cone's name (`[data-seat-cone]`) and its status, with no pickers, meter or New conversation; the guest's own messages (`origin` `guest` whose `seat` is the seat's `id`, or, without a `seat`, whose `from` is its `label`) read as the reader's own, with no name, while other guests keep "From {label}" and the host's messages read "From the host"; an open question or a permission request takes the normal card border, without its buttons, form, countdown or pile (no `data-pending`), and says "The host answers this."
 (`[data-host-answers]`, subdued); once answered, it shows the answer as everyone sees it; a reviewed guest message's outcome (a notice titled "It was approved.", "Nobody approved this in time.", "It was declined." or "It was withdrawn.", with the message as its text) reads as the quoted message, cut to one line, then the outcome (`.marker[data-ended]`); an approved one shows only "It was approved.", since the delivered message follows right after it; inline sprinkles inert with "View only on this device", error cards have no action and there's no suggested follow-up; the models aren't settled, and files can't be dropped.
 An empty guest chat says "No messages yet.
@@ -345,6 +346,11 @@ There's no row of key hints: the keys are the field's accessible description ("E
 The field's status icon, which is decorative, follows the input: the AI logo when empty, a pencil while typing, a brush for a moment after <kbd>Backspace</kbd> or <kbd>Delete</kbd>, a microphone while dictating; it stays the AI logo while a reply streams, and it swaps without animation.
 Drafts are kept per agent.
 On a follower while the link reconnects, the field is disabled and says so; the draft stays.
+While the agent port's `starting()` returns a line (no agent yet, but one is on its way), the composer stays usable: its placeholder is that line, there are no `/` or `@` popups, and sending, attachments included, adds a row above the field that reads "Sent when the agent starts" (`li.queued[data-mode="starting"]`), which can be dropped (`data-action="unqueue"`); a row with text and files says how many files go with it (`[data-files]`).
+Whenever the model changes or its agent port fires `starting` or `agents`, and the current model's port has no line (`null`, or no `starting` at all) and `agent.list()` has an agent, the composer sends the rows in order to that model's active agent (else the first one) through `agent.send`, the first like a normal send and the rest with `mode: 'queue'`, and the rows go; if the line clears with no agent, the rows stay until one comes.
+A line that comes back closes an open `/` or `@` popup.
+The rows are kept for the page (for the `<slicc-app>` the composer is in, else for the document), not for the model, so a model swap (an embedder that puts a new `SliccModel` on `<slicc-app>` once the agent is there), a layout switch and a dock rebuild keep them; a page reload drops them.
+Text typed but not sent while it starts is kept for the page the same way, and stays in the field once the agent arrives.
 While the agent holds tool results for the vault (`agent.hold()`), a status line above it says "Waiting for the vault" or "Unlock the vault to continue", with how many results are held, and offers the vault's **Unlock** button when locked and the model has a `vault`; if the browser blocks the vault window, the line says to allow pop-ups.
 With the model's `seat` set it's a guest's composer: <kbd>Enter</kbd> and the send button send through `agent.send(cone, text)`, <kbd>Shift</kbd>+<kbd>Enter</kbd> adds a line and <kbd>↑</kbd>/<kbd>↓</kbd> walk the guest's own messages; there's no steer, queue, Stop, attachments (the field is `collapsed`, so its + is hidden and inert, and pasted files are ignored), `/` commands, `@` mentions, + menu or push to talk, and it never reads files; its description is "Enter sends, Shift+Enter adds a new line."
 A rejected send shows the rejection's message above the field (`[data-send-error]`, `role="alert"`) and puts the draft back, ahead of anything typed since.
@@ -705,6 +711,7 @@ Assistant messages stream: the same message is re-emitted as its parts grow and
 The optional `toolLabel(agentId, callIds)` resolves with a short label for a cluster of tool runs (`callIds` in order), such as "Compare the docs with the live API", or `null`; the agent dedupes, caches and persists it.
 Spectrum asks once a cluster forms and again each time it grows, once per set of ids, and shows the label at the end of the strip.
 The optional `readOnly()` returns a line, or `null`, with a `readOnly` event when it changes: while it's a non-empty string, such as when this follower runs a different major version from its owner, every surface is watch-only just as a follower without Control is (no composer, no cone or conversation actions, no pickers, no Stop, no Accept or Revert in Changes, inline sprinkles view only, no model settling), and the line takes the place of the follow-based watch-only note under the chat.
+The optional `starting()` returns a line, or `null`, with a `starting` event when it changes: while it's a non-empty string, there's no agent yet but one is on its way (such as while seven installs its first agent, or replaces one), the chat drops its empty state and the composer queues what's sent until an agent is there (see `<slicc-composer>`); without it, or at `null`, nothing changes.
 
 #### `files`
 
@@ -980,6 +987,10 @@ The SLICC you follow runs a newer version.
 Update this one to send prompts.", and shows a warning notice without a close button (`[data-notice="readonly"]`) in place of any other notices.
 `model.agent.setReadOnly(text)` changes it, and `null` ends it.
 
+`createDummyModel({ agent: 'starting' | 'waiting' })` (`?agent=` on `/ui/`, default `ready`) starts with no agents while `starting()` returns "Seven is installing its agent.", and shows an info notice without a close button (`[data-notice="starting"]`) that goes with the line; `<slicc-app>` opens the chat with no agent (the `chat` panel, as `show('chat')` does) when it starts while `starting()` has a line and its layout has no chat; once an agent is active, that agent's chat takes the `chat` panel's place in the dock, focused if focus was in it, and the `chat` panel closes, also when a saved layout brings it back.
+With `starting`, after 100 ticks of the dummy clock (3 s at the default delay) the usual cones arrive and the line clears; `waiting` waits for `model.agent.arrive()`, which does the same.
+`model.agent.setStarting(line)` changes the line (and `null` clears it with no agent), and either one cancels the scheduled arrival.
+
 `createDummyModel({ import: 'v6' | 'again' | 'fail' | 'cancel-check' })` (`?import=` on `/ui/`, off by default) adds `importProfile`, `importCancel` and `importing` to the agent: any zip previews an invented export from www.sliccy.ai (3 cones, 14 scoops, 2 frozen, Anthropic and OpenAI to sign in to again, 2 mounts and a flagged `files/cones/cone/.env`), and the import ticks to 14 in a few steps and adds 3 frozen cones with `v6: true` and the report `/root/v6-import-2026-10-18.md`; a second preview says when, and **Import again** adds fresh copies. `again` starts with an earlier import, `fail` rejects with "That zip isn’t a SLICC 6 profile export.", and `cancel-check` checks slowly. `DummyImport` and its fixtures (`importPreview`, `importCones`, `importReport`, …) are exported from `/dummy`.
 
 The kitchen sink's “docs-pass failed” card is an expired-session error for the invented `ai-adobe` account (Adobe AI, harbor-ops@example.com, `expired`, OAuth): **Log in** goes `signing-in`, then `connected` after a short wait, and the dummy records each `connect` in `settings.connects` (`{ id, gesture }`, whether `navigator.userActivation.isActive` was true at the call); inbox-triage's “Tickets connector” card names `mcp:tickets`, a token account, so its **Log in** opens Settings at that row; `createDummyModel({ login: 'fail' })` (`?login=fail` on `/ui/`) makes OAuth sign-ins reject with “The sign-in window was closed before it finished.”

package/dist/slicc-dummy.js

@@ -1507,6 +1507,9 @@ var DummyAgent = class extends Emitter {
   #frozen = [];
   #hold = null;
   #readOnly = null;
+  #starting = null;
+  #absent = [];
+  #arrival = 0;
   #ice = /* @__PURE__ */ new Map();
   #suggestions = /* @__PURE__ */ new Map();
   #runs = /* @__PURE__ */ new Map();
@@ -1985,6 +1988,34 @@ var DummyAgent = class extends Emitter {
     this.#readOnly = text || null;
     this.emit("readOnly", this.#readOnly);
   }
+  starting() {
+    return this.#starting;
+  }
+  setStarting(line) {
+    this.#arrival++;
+    this.#starting = line || null;
+    this.emit("starting", this.#starting);
+  }
+  withhold(line, ticks2) {
+    this.#absent = [...this.#absent, ...this.#agents];
+    this.#agents = [];
+    this.#active = "";
+    this.#changed();
+    this.setStarting(line);
+    if (ticks2 === void 0) return;
+    const arrival = this.#arrival;
+    void this.#clock.sleep(ticks2).then(() => {
+      if (arrival === this.#arrival) this.arrive();
+    });
+  }
+  arrive() {
+    this.#agents = [...this.#agents, ...this.#absent];
+    this.#absent = [];
+    this.#active = this.#agents[0]?.id ?? "";
+    this.#changed();
+    this.emit("active", this.#active);
+    this.setStarting(null);
+  }
   frozen() {
     const live = this.#agents.filter((agent) => !agent.frozen).map((agent) => {
       const messages = this.#messages.get(agent.id);
@@ -4467,6 +4498,7 @@ var DummyNetwork = class extends Emitter {
 
 // src/dummy/notices.ts
 var readOnlyText = "Watch only. The SLICC you follow runs a newer version. Update this one to send prompts.";
+var startingText = "Seven is installing its agent.";
 var noticeFixtures = {
   storage: {
     id: "storage",
@@ -4489,6 +4521,14 @@ var noticeFixtures = {
     body: "The SLICC you follow moved to a newer version. Until you update SLICC on this device, it can only watch.",
     actions: [],
     dismissible: false
+  },
+  starting: {
+    id: "starting",
+    tone: "info",
+    title: "Seven is installing its agent",
+    body: "The chat starts once the agent is installed. Messages you send now wait for it.",
+    actions: [],
+    dismissible: false
   }
 };
 var DummyNotices = class extends Emitter {
@@ -4499,7 +4539,7 @@ var DummyNotices = class extends Emitter {
     super();
     this.#scenario = scenario;
     this.#time = time;
-    this.#notices = scenario === "mixed" ? [noticeFixtures.storage, noticeFixtures.welcome] : scenario === "readonly" ? [noticeFixtures.readonly] : [noticeFixtures.storage];
+    this.#notices = scenario === "mixed" ? [noticeFixtures.storage, noticeFixtures.welcome] : scenario === "readonly" || scenario === "starting" ? [noticeFixtures[scenario]] : [noticeFixtures.storage];
   }
   list() {
     return this.#notices;
@@ -4515,13 +4555,19 @@ var DummyNotices = class extends Emitter {
     this.#remove(id);
   }
   readOnly(on) {
-    const shown = this.#notices.some((notice) => notice.id === "readonly");
+    this.#toggle("readonly", on);
+  }
+  starting(on) {
+    this.#toggle("starting", on);
+  }
+  #toggle(id, on) {
+    const shown = this.#notices.some((notice) => notice.id === id);
     if (on === shown) return;
     if (on) {
-      this.#notices = [noticeFixtures.readonly, ...this.#notices];
+      this.#notices = [noticeFixtures[id], ...this.#notices];
       this.emit("notices", this.#notices);
     } else {
-      this.#remove("readonly");
+      this.#remove(id);
     }
   }
   #remove(id) {
@@ -6050,6 +6096,15 @@ function importPort(scenario, agent, time) {
   agent.importCancel = port.importCancel.bind(port);
   agent.importing = port.importing.bind(port);
 }
+function noticesPort(agent, time, notices, readonly, arrival) {
+  if (readonly !== "off") agent.setReadOnly(readOnlyText);
+  if (arrival !== "ready") agent.withhold(startingText, arrival === "starting" ? 100 : void 0);
+  const notice = readonly !== "off" ? "readonly" : arrival !== "ready" ? "starting" : notices;
+  const port = notice === "off" ? null : new DummyNotices(notice, time);
+  if (port && readonly !== "off") agent.on("readOnly", (text) => port.readOnly(Boolean(text)));
+  if (port && arrival !== "ready") agent.on("starting", (line) => port.starting(Boolean(line)));
+  return port;
+}
 function createDummyModel({
   delay = 30,
   storage = null,
@@ -6074,6 +6129,7 @@ function createDummyModel({
   transport,
   hold = "off",
   readonly = "off",
+  agent: arrival = "ready",
   browser: scenario = "idle",
   sprinkles: sprinkles2 = "builtin",
   monitor = "dummy",
@@ -6103,12 +6159,7 @@ function createDummyModel({
   };
   importPort(imports, agent, time);
   if (hold !== "off") agent.setHold({ reason: hold, held: 2 });
-  if (readonly !== "off") agent.setReadOnly(readOnlyText);
-  const notice = readonly !== "off" ? "readonly" : notices;
-  const noticePort = notice === "off" ? null : new DummyNotices(notice, time);
-  if (noticePort && readonly !== "off") {
-    agent.on("readOnly", (text) => noticePort.readOnly(Boolean(text)));
-  }
+  const noticePort = noticesPort(agent, time, notices, readonly, arrival);
   if (scenario === "driving") void browser.run(drive);
   const base = {
     agent,