@ccmsg/cli 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ccmsg/protocol": "1.15.0"
+    "@ccmsg/protocol": "1.18.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.0",

package/src/daemon/registry.ts

@@ -115,12 +115,16 @@ const STARTING_PRESETS = [
   {
     name: "howto",
     description: "調査のノウハウだけ。何を考えて何を叩いて何を読み書きしたか",
-    opts: { types: ["thinking", "message:user", "message:sub", "tool:Bash", "@file"] },
+    opts: {
+      types: ["thinking", "message:user", "message:parent", "message:sub", "tool:Bash", "@file"],
+    },
   },
   {
     name: "journal",
     description: "日記用。人との往復と worker の答え、思考は要点だけ",
-    opts: { types: ["message:user", "message:sub:in", "thinking"] },
+    opts: {
+      types: ["message:user", "message:parent", "message:sub:in", "message:team:in", "thinking"],
+    },
   },
   {
     name: "handoff",

package/src/sessions/registry.ts

@@ -227,6 +227,18 @@ export class Sessions implements UpstreamResource {
         ? undefined
         : new TerminalCache(deps.terminals, () => this.changed());
     this.#live = this.#liveNow(Date.now(), this.#own());
+    this.#reclaim(this.#live);
+  }
+
+  /** Drop the `last_live` entry of every session that is live, which is what
+   * keeps one session off both lists.
+   *
+   * Registering is one way a session comes back and is handled where it
+   * happens; the harness naming it again is the other, and it is the only one
+   * on a restart — nothing greets a daemon that was not there when the session
+   * started. */
+  #reclaim(live: ReadonlyMap<Sid, StoredEntry>): void {
+    for (const sid of live.keys()) this.#lastLive.remove(sid);
   }
 
   /** `hello`, which is where a session becomes something this instance can
@@ -483,9 +495,15 @@ export class Sessions implements UpstreamResource {
     return this.#harness.running;
   }
 
-  /** The `peers` payload: what is connected now, and what was connected when
-   * this instance last saw it. Both travel together because registering is
-   * exactly what moves a session from the second list to the first.
+  /** The `peers` payload: what is live now, and what was live when this
+   * instance last saw it. Both travel together because coming back is exactly
+   * what moves a session from the second list to the first.
+   *
+   * Live is not the same as connected (§5.2). A session the harness names is
+   * live whether or not it ever greeted us, and it has to be on this list for
+   * the same reason it is classified at all: a restart forgets every greeting,
+   * and a list that showed only what had greeted this daemon would show a host
+   * full of running sessions as empty.
    *
    * Every row states its `state` and its `pinned`. The contract lets an
    * instance leave them out, and a client then shows a session it cannot group
@@ -504,7 +522,12 @@ export class Sessions implements UpstreamResource {
   ): { peers: PeerInfo[]; last_live: LastLiveSession[]; instances?: InstanceInfo[] } {
     const instances = this.deps.mesh?.instances();
     return {
-      peers: [...this.#connected.values()].map((session) => this.#peer(session, now, own)),
+      peers: [
+        ...[...this.#connected.values()].map((session) => this.#peer(session, now, own)),
+        ...[...own.present]
+          .filter((sid) => !this.#connected.has(sid))
+          .map((sid) => this.#unconnected(sid, now, own)),
+      ],
       last_live: this.#lastLive.entries(now).map((entry) => ({
         ...entry,
         state: this.classify(entry.sid, now, own) ?? "disappeared",
@@ -597,6 +620,7 @@ export class Sessions implements UpstreamResource {
       // comes back says them again.
       this.#stated.delete(sid);
     }
+    this.#reclaim(live);
     this.#live = live;
     this.deps.publish("peers", this.peers(now, own));
     this.deps.publish("agents", this.agents(own));
@@ -661,6 +685,36 @@ export class Sessions implements UpstreamResource {
     };
   }
 
+  /** A session the harness names that holds no connection here (§5.1).
+   *
+   * It is on the same list as the connected ones because it is live in the same
+   * sense: the classification is what separates them, and a client groups on
+   * that field alone (§5.2). What it cannot carry is everything a greeting
+   * states — the session never said where it works, so the working directory
+   * comes from the harness's own row and the display names it does not know are
+   * simply absent.
+   *
+   * The connection fields go with the connection: `connected_at`,
+   * `last_activity_at` and the client's build and generation are things about a
+   * client of this session, and there is none. */
+  #unconnected(sid: Sid, now: Timestamp, own: Own): PeerInfo {
+    const row = own.rows.get(sid);
+    const userInput = this.deps.transcript?.facts(sid).last_user_input_at;
+    const gatewayActiveAt = this.#gatewayActiveAt(sid, true);
+    return {
+      sid,
+      instance: this.deps.self,
+      // The harness knows a title for a session that stated none itself, and
+      // what the session said about itself overrides it.
+      ...(row?.name === undefined ? {} : { title: row.name }),
+      ...this.#where(sid, own),
+      state: this.classify(sid, now, own) ?? "live",
+      pinned: this.#pinned(sid),
+      ...(userInput === undefined ? {} : { last_user_input_at: userInput }),
+      ...(gatewayActiveAt === undefined ? {} : { gateway_active_at: gatewayActiveAt }),
+    };
+  }
+
   /** When the gateway last saw inference for a session, for a session this
    * instance knows (§5.1).
    *

package/src/transcript/items/classify.ts

@@ -117,6 +117,17 @@ export class Classification {
   #turn = 0;
   /** The last slash command invoked, which is what its output belongs to. */
   #slash: string | undefined;
+  /** Whose file this is, which decides who is at the other end of a plain
+   * line. A session's own transcript has a person there; a file written for an
+   * agent has whoever started it, and calling that `user` would have a reader
+   * take a machine for a person.
+   *
+   * The file says so itself — every record of an agent's transcript is marked
+   * as one — so nothing has to be passed in beside it. It is remembered once
+   * seen rather than read per record: a file is one subject's throughout, and a
+   * record that omitted the mark would otherwise change who the subject is
+   * mid-read. */
+  #subject: "session" | "agent" = "session";
 
   /** The records of one chunk as the items they were read as, oldest first.
    *
@@ -147,6 +158,7 @@ export class Classification {
   read(record: Row, source: { offset: number; bytes: number }): void {
     const type = str(record["type"]);
     if (type === undefined || NOT_ITEMS.has(type)) return;
+    if (record["isSidechain"] === true) this.#subject = "agent";
     // A record the harness wrote without an id of its own still happened, and
     // an item is pointed at by the record it came from — so where the record
     // stands in the file stands in for the id it lacks. The `@` says which of
@@ -239,7 +251,12 @@ export class Classification {
       }
       if (kind === "text") {
         const said = str(fields["text"])?.trim();
-        if (said !== undefined && said !== "") make("message:user:out", { text: said });
+        // An agent's words are addressed to whoever started it — the last of
+        // them is the answer it was started for, and the ones before are what
+        // it hands back mid-flight. No call carries them, which is why
+        // `parent:out` is prose as well as a call.
+        const kind = this.#subject === "agent" ? "message:parent:out" : "message:user:out";
+        if (said !== undefined && said !== "") make(kind, { text: said });
         continue;
       }
       if (kind === "tool_use") this.#call(fields, make);
@@ -267,29 +284,51 @@ export class Classification {
     });
     let message: Draft | undefined;
     if (SPAWNS.has(name)) {
-      message = make("message:sub:out", {
-        role: "use",
-        tool_use_id: id,
-        prompt: str(input["prompt"]) ?? "",
-        ...optional("subagent_type", str(input["subagent_type"])),
-        ...optional("name", str(input["name"])),
-        ...optional("description", str(input["description"])),
-      });
+      // A name is what makes an agent a teammate: it stands under that name,
+      // can be written to again, and answers whenever it writes back. An agent
+      // started without one is an errand — it runs once, answers the call that
+      // started it, and is done.
+      const named = str(input["name"]) ?? str(input["team_name"]);
+      message =
+        named === undefined
+          ? make("message:sub:out", {
+              role: "use",
+              tool_use_id: id,
+              prompt: str(input["prompt"]) ?? "",
+              ...optional("subagent_type", str(input["subagent_type"])),
+              ...optional("description", str(input["description"])),
+            })
+          : make("message:team:out", {
+              role: "use",
+              tool_use_id: id,
+              text: str(input["prompt"]) ?? "",
+              harness_name: named,
+              ...optional("subagent_type", str(input["subagent_type"])),
+              ...optional("description", str(input["description"])),
+            });
     } else if (name === "SendMessage") {
       const to = str(input["to"]) ?? "";
-      // A sid is the harness's own uuid; anything else is a name, and a name
-      // is how an agent below this session is addressed.
-      make(addressed(to) ? "message:session:out" : "message:sub:out", {
-        ...(addressed(to) ? {} : { role: "use", tool_use_id: id }),
-        ...(addressed(to)
-          ? { text: text(input["message"]) ?? "", to }
-          : // Writing to an agent is one direction of a correspondence, not a
-            // call that returns: what the agent says back arrives as its own
-            // message whenever it chooses to send one, under nothing that
-            // names this. So the brief says it is waiting for nothing, and a
-            // reader is not left watching for an answer that has no way in.
-            { prompt: text(input["message"]) ?? "", name: to, one_way: true }),
-      });
+      // A sid is the harness's own uuid, so a message addressed by one goes to
+      // another session. Everything else is a name: the one above answers to
+      // the names a harness gives a lead, and any other name is somebody
+      // standing alongside.
+      if (addressed(to)) {
+        make("message:session:out", { text: text(input["message"]) ?? "", to });
+      } else {
+        // Writing to an agent is one direction of a correspondence, not a call
+        // that returns: what it says back arrives as its own message whenever
+        // it chooses to send one, under nothing that names this. So the
+        // message says it is waiting for nothing, and a reader is not left
+        // watching for an answer that has no way in.
+        make(LEADS.has(to) ? "message:parent:out" : "message:team:out", {
+          role: "use",
+          tool_use_id: id,
+          text: text(input["message"]) ?? "",
+          harness_name: to,
+          ...optional("summary", str(input["summary"])),
+          one_way: true,
+        });
+      }
     } else if (name === "Bash" && isCcmsgSend(str(input["command"]))) {
       make("message:session:out", { text: str(input["command"]) ?? "" });
     }
@@ -375,7 +414,7 @@ export class Classification {
     // decides is whether an answer came back, not which tool was called.
     const said = answered(result["content"]);
     if (said === undefined) return;
-    const reply = make("message:sub:in", {
+    const reply = make(answers(call.message), {
       role: "result",
       parent_item: call.message.id,
       parent_tool_use_id: id,
@@ -434,17 +473,32 @@ export class Classification {
     // stands, being told what to do is not the same as being written to.
     if (record["parentUuid"] === null) {
       this.#turn += 1;
-      make("message:user:in", { text: said });
+      make(this.#subject === "agent" ? "message:parent:in" : "message:user:in", {
+        text: said,
+        ...(this.#subject === "agent" ? envelope(said) : {}),
+      });
       return;
     }
-    if (said.includes("<cross-session-message") || said.includes("<teammate-message")) {
+    if (said.includes("<cross-session-message")) {
       make("message:session:in", {
         text: said,
-        ...optional("from", attribute(said, "from") ?? attribute(said, "teammate_id")),
+        ...optional("from", attribute(said, "from")),
         ...optional("msg_id", attribute(said, "mid")),
       });
       return;
     }
+    if (said.includes("<teammate-message")) {
+      // Who wrote decides which it is. A lead is the one above, whatever the
+      // subject's own place in the team; anyone else writing under their own
+      // name is somebody standing alongside, and what they send is a message
+      // of its own rather than the answer to anything.
+      const from = attribute(said, "teammate_id");
+      make(LEADS.has(from ?? "") ? "message:parent:in" : "message:team:in", {
+        text: said,
+        ...envelope(said),
+      });
+      return;
+    }
     if (record["isMeta"] === true) {
       make("system:unknown", { record });
       return;
@@ -471,7 +525,7 @@ export class Classification {
     const call = this.#calls.get(key);
     if (answer !== undefined && call !== undefined) {
       const asked = call.message ?? call.tool;
-      const item = make("message:sub:in", {
+      const item = make(answers(asked), {
         role: "result",
         parent_item: asked.id,
         parent_tool_use_id: key,
@@ -503,6 +557,30 @@ function addressed(to: string): boolean {
   return SID.test(to);
 }
 
+/** The names a harness gives the one above. They are the harness's own words
+ * rather than a relation anyone chose, which is why they are matched here and
+ * not carried into the type: what the type says is that this is the parent,
+ * and the spelling stays on the item as the name it was addressed by. */
+const LEADS = new Set(["main", "team-lead"]);
+
+/** Who a message came from and under which id, as the envelope the harness
+ * wraps one in says it. The name is the harness's own spelling and not a sid,
+ * which is why it travels as `harness_name`: what the type already said is
+ * which party this was, and the name is only what that party was called. */
+function envelope(said: string): Record<string, unknown> {
+  return {
+    ...optional("harness_name", attribute(said, "teammate_id")),
+    ...optional("msg_id", attribute(said, "mid")),
+  };
+}
+
+/** The type an agent's answer arrives under, which is the other half of
+ * whatever asked for it: a teammate's run ending answers the call that started
+ * it, an errand's answer is the errand's result. */
+function answers(asked: Draft): string {
+  return asked.type === "message:team:out" ? "message:team:in" : "message:sub:in";
+}
+
 /** Whether a shell command is this session speaking to another one. */
 function isCcmsgSend(command: string | undefined): boolean {
   if (command === undefined) return false;

package/src/transcript/items/document.ts

@@ -83,7 +83,7 @@ function heading(file: SessionDumpFile, view: DumpView): string[] {
 function draw(item: Item, child: Item | undefined, view: DumpView, parent?: string): string[] {
   const own = fragment(item);
   const answer = child === undefined ? undefined : fragment(child);
-  const nested = child !== undefined && child.type.startsWith("message:sub");
+  const nested = child !== undefined && spoken(child.type);
   const link = isResult(item)
     ? arrow("←", parent)
     : (arrow("→", fields(item)["result_item"]) ?? waiting(item));
@@ -240,7 +240,7 @@ function pair(items: readonly Item[]): {
     // A pair the reader would have to scroll between is left where each half
     // happened, unless it is an agent's: what an agent was asked and what it
     // answered are one exchange whatever fell between them.
-    if (!item.type.startsWith("message:sub") && call !== at - 1) continue;
+    if (!spoken(item.type) && call !== at - 1) continue;
     child.set(call, at);
     folded.add(at);
   }
@@ -248,10 +248,19 @@ function pair(items: readonly Item[]): {
 }
 
 /** The key an exchange is joined on. One call the harness gave a key to is two
- * items where it started an agent — the call and the brief beside it — so the
- * side of the exchange goes into the key: a tool's answer belongs to the call
- * and an agent's to the brief, and the harness's key alone would not say
- * which. */
+ * items where it also addressed somebody — the call and the message beside it
+ * — so the side of the exchange goes into the key: a tool's answer belongs to
+ * the call and an agent's to the message, and the harness's key alone would
+ * not say which. */
 function joined(item: Item, key: string): string {
-  return `${item.type.startsWith("message:sub") ? "sub" : "tool"}\n${key}`;
+  return `${item.type.startsWith("message:") ? "message" : "tool"}\n${key}`;
+}
+
+/** Whether an item is the conversation half of starting an agent, as opposed
+ * to the call's own half. What was asked and what came back is one exchange
+ * however many turns fell between them, so these are drawn together wherever
+ * they ended up — a conversation split across the page is one nobody can
+ * follow. */
+function spoken(type: string): boolean {
+  return type.startsWith("message:sub") || type.startsWith("message:team");
 }

package/src/transcript/items/render.ts

@@ -88,6 +88,44 @@ const ITEMS: Record<string, Draw> = {
     body: lines(str(item, "text")),
   }),
 
+  // The one above and the ones alongside. A name is on the heading wherever
+  // the record gave one — an answer handed back as prose names nobody, and a
+  // heading that invented a name for it would say more than the file does.
+  "message:parent:in": (item) => ({
+    head: words(field(item, "harness_name", "from="), mid(item)),
+    body: lines(str(item, "text")),
+  }),
+
+  "message:parent:out": (item) => ({
+    head: words(field(item, "harness_name", "to="), str(item, "summary")),
+    body: lines(str(item, "text")),
+  }),
+
+  "message:team:out": (item) => ({
+    head: words(
+      field(item, "harness_name", "to="),
+      field(item, "agent_id", "agent="),
+      field(item, "subagent_type", "type="),
+      str(item, "description"),
+      str(item, "summary"),
+    ),
+    body: lines(str(item, "text")),
+  }),
+
+  // Both halves of a teammate's correspondence arrive under one type: a letter
+  // it wrote, which names who wrote it, and its run ending, which names how it
+  // ended. Each heading says whichever of those the item carried.
+  "message:team:in": (item) => ({
+    head: words(
+      field(item, "harness_name", "from="),
+      mid(item),
+      field(item, "agent_id", "agent="),
+      field(item, "status", "status="),
+      elapsed(num(item, "duration_ms")),
+    ),
+    body: lines(str(item, "text")),
+  }),
+
   "message:session:out": (item) => ({
     head: words(field(item, "to", "to="), field(item, "reply_to", "reply_to="), mid(item)),
     body: lines(str(item, "text")),