@ccmsg/cli 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",

package/src/instance/instance.ts

@@ -421,6 +421,9 @@ export class Instance {
       onActivity: () => {
         this.#sessions.refresh();
       },
+      onMoved: (sid) => {
+        this.#sessions.gatewayMoved(sid);
+      },
       log: (msg, fields) => {
         this.log.write(msg, fields);
       },

package/src/sessions/registry.ts

@@ -536,14 +536,52 @@ export class Sessions implements UpstreamResource {
       ...[...own.present]
         .filter((sid) => !this.#connected.has(sid))
         .map((sid) => this.#unconnected(sid, now, own)),
-      ...this.#lastLive.entries(now).map((entry) => ({
-        ...entry,
-        state: this.classify(entry.sid, now, own) ?? "disappeared",
-        pinned: this.#pinned(entry.sid),
-      })),
+      ...this.#lastLive.entries(now).map((entry) => this.#lost(entry, now, own)),
     ];
   }
 
+  /** One row of `peers`, for a producer that knows which session moved.
+   *
+   * The same three sources the list is built from, asked about one sid: a
+   * connection here, a session the harness names, an entry among the sessions
+   * this instance has lost. A sid none of them holds is one this instance has
+   * no row for, and it says so rather than inventing one. */
+  #peerRow(sid: Sid, now: Timestamp, own: Own): PeerInfo | undefined {
+    const held = this.#connected.get(sid);
+    if (held !== undefined) return this.#peer(held, now, own);
+    if (own.present.has(sid)) return this.#unconnected(sid, now, own);
+    const entry = this.#lastLive.get(sid);
+    return entry === undefined ? undefined : this.#lost(entry, now, own);
+  }
+
+  /** A session this instance has lost, as a row: what was observed of it,
+   * with the two fields a row derives worked out at read time (M4). */
+  #lost(entry: StoredEntry, now: Timestamp, own: Own): PeerInfo {
+    return {
+      ...entry,
+      state: this.classify(entry.sid, now, own) ?? "disappeared",
+      pinned: this.#pinned(entry.sid),
+    };
+  }
+
+  /** The gateway saw inference for one session again (§5.1).
+   *
+   * What moved is one attribute of one row, so that row is what goes out. The
+   * sessions domain is not recomputed for it: which sessions there are has not
+   * changed, and the whole of that work would be spent to restate a clock.
+   *
+   * A sid this instance has no row for publishes nothing. The gateway sits
+   * above every config home and its events name only a session id, so one
+   * belonging to another config home must not become a row here — the same
+   * narrowing the row's own reading of the gateway makes. */
+  gatewayMoved(sid: Sid): void {
+    const now = Date.now();
+    const row = this.#peerRow(sid, now, this.#own());
+    if (row === undefined) return;
+    const peers = this.#sentPeers.diffRow(row) as PeerElement[];
+    if (peers.length > 0) this.deps.publish("peers", { peers });
+  }
+
   /** Every row `agents` states: the harness's own view, as it stated it. */
   agentRows(own: Own = this.#own()): AgentInfo[] {
     return [...own.rows.values()];

package/src/upstream/gateway.ts

@@ -114,6 +114,9 @@ export interface GatewayDeps {
   /** The gateway saw something happen for a session, which is an input of the
    * sessions domain (§5.1) rather than of either topic. */
   readonly onActivity?: () => void;
+  /** A session already known to be running was seen again: its clock moved,
+   * and the row that carries it is what says so. */
+  readonly onMoved?: (sid: Sid) => void;
   readonly log?: (msg: string, fields?: Record<string, unknown>) => void;
   /** Replaces the outward read in tests. */
   readonly fetch?: typeof fetch;
@@ -139,6 +142,7 @@ export class Gateway {
       self: deps.self,
       publish: deps.publish,
       ...(deps.onActivity === undefined ? {} : { onActivity: deps.onActivity }),
+      ...(deps.onMoved === undefined ? {} : { onMoved: deps.onMoved }),
     });
     this.status =
       deps.setup.statusUrl === undefined

package/src/upstream/requests.ts

@@ -14,16 +14,23 @@ export interface LlmRequestsDeps {
   /** The one way a value reaches subscribers (§6.1). */
   readonly publish: (topic: string, data: unknown) => void;
   /** An event moved when a session was last seen running inference, which is
-   * an input of the sessions domain (§5.1) and not of this topic. */
+   * an input of the sessions domain (§5.1) and not of this topic. Told when
+   * the window opened, which is the moment the classification can change. */
   readonly onActivity?: () => void;
+  /** The same session seen again inside a window already open: one attribute
+   * of one row moved. Told apart from the above because what it asks for is
+   * that row restated rather than the whole domain recomputed. */
+  readonly onMoved?: (sid: Sid) => void;
 }
 
 /** Which of a session's gateway facts moved.
  *
- * `live` is the only one the sessions domain has to hear: it is the moment the
- * classification of §5.1 can change, because the window either opened or
- * closed. `clock` is the same session seen again inside a window that was
- * already open — the value of an attribute, not a section anything is in. */
+ * `live` is the moment the classification of §5.1 can change, because the
+ * window either opened or closed, and the sessions domain recomputes for it.
+ * `clock` is the same session seen again inside a window that was already open
+ * — the value of an attribute, not a section anything is in — so what it asks
+ * for is that one row restated. Both reach a subscriber; they differ in how
+ * much work is done to say so. */
 type GatewayMove = "live" | "clock" | "none";
 
 /** Series remembered at once. The prune below already holds this near the
@@ -77,7 +84,7 @@ export class LlmRequests implements UpstreamResource {
    * near-ordered in practice, but a redelivery can put an older one after a
    * newer, and a countdown must not walk backwards. */
   record(info: LlmRequestObservation): void {
-    if (this.active(info.sid, info.received_at) === "live") this.deps.onActivity?.();
+    this.moved(info.sid, this.active(info.sid, info.received_at));
     const key = seriesKey(info.sid, info.prefix);
     const held = this.#series.get(key);
     if (held !== undefined && held.info.received_at >= info.received_at) return;
@@ -99,7 +106,13 @@ export class LlmRequests implements UpstreamResource {
    * the window belongs to the request that opened it — and only says the
    * session was still running inference at that instant. */
   note(sid: Sid, at: Timestamp): void {
-    if (this.active(sid, at) === "live") this.deps.onActivity?.();
+    this.moved(sid, this.active(sid, at));
+  }
+
+  /** Tell whoever holds the row what this event moved for that session. */
+  private moved(sid: Sid, move: GatewayMove): void {
+    if (move === "live") this.deps.onActivity?.();
+    else if (move === "clock") this.deps.onMoved?.(sid);
   }
 
   /** When the gateway last saw inference for a session (§5.1). Undefined once
@@ -148,11 +161,10 @@ export class LlmRequests implements UpstreamResource {
 
   /** Note the session was seen, and say what that moved.
    *
-   * A session already inside its window moves its clock and nothing else. The
-   * sessions domain is told about `live` alone, because telling it about every
-   * event would restate the whole of `peers` once per call a session makes:
-   * inference is observed several times a second and the row it lands on
-   * differs only in an attribute (§5.2). */
+   * A session already inside its window moves its clock and nothing else, so
+   * the row it lands on is restated on its own: inference is observed several
+   * times a second, and recomputing the domain for each would spend the whole
+   * of that work on one attribute of one row (§5.2). */
   private active(sid: Sid, at: Timestamp): GatewayMove {
     const held = this.#activeAt.get(sid);
     if (held !== undefined && held >= at) return "none";