@opencode-cockpit/subagents 0.7.0 → 0.7.1

package/README.md

@@ -10,8 +10,8 @@ Part of [opencode-cockpit](https://github.com/Codestz/opencode-cockpit). Install
 through the bundle. Works on OpenCode 1.18+ and 2.0.15+.
 
 ```sh
-opencode plugin @opencode-cockpit/subagents@0.7.0 --global --force     # OpenCode 1
-opencode plugin add @opencode-cockpit/subagents@0.7.0                   # OpenCode 2
+opencode plugin @opencode-cockpit/subagents@0.7.1 --global --force     # OpenCode 1
+opencode plugin add @opencode-cockpit/subagents@0.7.1                   # OpenCode 2
 ```
 
 ## What it does

package/dist/core/adapt/v2.js

@@ -360,12 +360,14 @@ export function createV2Translator(unknown = () => {}) {
           counted = true;
         }
       }
+      /** Stamped with the run's own last moment: "now" made a reopened run look like it ended now. */
+      const latest = out.reduce((most, change) => Math.max(most, change.at), 0) || at;
       if (counted) out.push({
         type: "usage",
         id,
         tokens,
         cost,
-        at
+        at: latest
       });
       return out;
     },

package/dist/core/model/model.js

@@ -47,8 +47,8 @@ function applyStatus(s, change) {
     if (change.error) s.error = change.error;
     settle(s, change.at);
   } else if (s.status !== "failed") {
-    /** Idle before it ever worked is a session that has not started, not one that finished. */
-    s.status = s.status === "starting" && s.entries.length === 0 ? "starting" : "done";
+    /** Idle before it ever worked is a session that has not started, not one that finished — live. */
+    s.status = s.status === "starting" && s.entries.length === 0 && !change.settled ? "starting" : "done";
     s.ended = change.at;
     settle(s, change.at);
   }

package/dist/tui/index.js

@@ -621,6 +621,21 @@ export function createSubagentsTui({
       const session = opened();
       if (!session) return;
       if (!busy(session) && session.status !== "waiting") return remove([session.id]);
+      /**
+       * Stopping is only for a run OpenCode says is going. One Cockpit had wrong — shown running after a
+       * reopen — was "stopped", and the main agent was told about work that had long ended.
+       */
+      const said = feed.check(session.id);
+      if (said.some(change => change.type === "status" && change.status !== "busy" && change.status !== "waiting")) {
+        applyAll(model, said);
+        log.info("stop skipped: not running", {
+          id: session.id
+        });
+        return set({
+          notice: `${session.agent} had already finished — nothing to stop. x again removes it.`,
+          stopping: undefined
+        });
+      }
       if (surface.stopping !== session.id) {
         surface.stopping = session.id;
         surface.notice = `Press x again to stop ${session.agent}.`;

package/dist/tui/source.js

@@ -16,14 +16,30 @@ const V1_EVENTS = ["session.created", "session.updated", "session.status", "sess
  */
 // biome-ignore lint/suspicious/noExplicitAny: see above — every access is to a measured field
 
+/** The last moment a stored run did anything: its latest change, or `fallback` when it has none. */
+export function endOf(changes, fallback) {
+  let last = 0;
+  for (const change of changes) {
+    last = Math.max(last, change.at);
+    if (change.type === "tool" && change.ended !== undefined) last = Math.max(last, change.ended);
+  }
+  return last || fallback;
+}
 export function createSource(api, log, emit) {
-  /** Each unexpected shape once, not once per event. */
+  /**
+   * Each unexpected shape once, not once per event. An event we do not use is not news — OpenCode 2
+   * hands every plugin every event in the app (`provider.updated`, `session.viewed`…), and as
+   * warnings they filled doctor's report. A part of a kind we did not expect inside an event we do
+   * use still is: that is a shape that changed under us.
+   */
   const told = new Set();
   const unknown = (what, detail) => {
     const key = `${what} ${JSON.stringify(detail)}`;
     if (told.has(key)) return;
     told.add(key);
-    log.warn("unrecognised event", {
+    if (what === "event") log.debug("unused event", {
+      ...detail
+    });else log.warn("unrecognised event", {
       what,
       ...detail
     });
@@ -64,17 +80,39 @@ export function createSource(api, log, emit) {
           for (const child of Array.isArray(children) ? children : []) {
             const id = child.id;
             const messages = v1.state.session.messages(id) ?? [];
-            const history = messages.map(info => ({
+            let history = messages.map(info => ({
               info,
               parts: v1.state.part(info.id) ?? []
             }));
+            /**
+             * The interface's store holds the messages of sessions it has loaded, which in a long
+             * conversation is not every subagent. Read from the server when it has none.
+             */
+            if (history.length === 0) {
+              const fetched = await v1.client.session.messages({
+                sessionID: id
+              }).catch(error => {
+                log.warn("history fetch failed", {
+                  id,
+                  error
+                });
+                return undefined;
+              });
+              const list = fetched?.data ?? fetched ?? [];
+              if (Array.isArray(list)) history = list;
+              log.debug("history fetched", {
+                id,
+                messages: history.length
+              });
+            }
             const status = v1.state.session.status(id);
             /**
              * Busy only when the host says so. A finished subagent is not in the host's status store at
              * all — reading "no status" as "unknown" left every old subagent running forever.
              */
             const busy = status?.type === "busy" || status?.type === "retry";
-            emit([...translate.session(child), ...translate.history(history), busy ? {
+            const past = translate.history(history);
+            emit([...translate.session(child), ...past, busy ? {
               type: "status",
               id,
               status: "busy",
@@ -83,7 +121,8 @@ export function createSource(api, log, emit) {
               type: "status",
               id,
               status: "idle",
-              at: Number(child.time?.updated) || Date.now()
+              settled: true,
+              at: endOf(past, Number(child.time?.updated) || Date.now())
             }]);
             await visit(id, depth + 1);
           }
@@ -137,14 +176,19 @@ export function createSource(api, log, emit) {
         });
       },
       check(id) {
+        /**
+         * OpenCode 1 keeps a status only while a session works: a finished one has none (measured on a
+         * reopened conversation). Read as "unknown", a subagent stuck at running was never corrected.
+         */
         const status = v1.state.session.status(id);
-        return status ? translate.event({
-          type: "session.status",
-          properties: {
-            sessionID: id,
-            status
-          }
-        }) : [];
+        if (status?.type === "busy" || status?.type === "retry") return [];
+        return [{
+          type: "status",
+          id,
+          status: "idle",
+          settled: true,
+          at: Date.now()
+        }];
       },
       dispose: () => {
         for (const off of offs.splice(0)) off();
@@ -171,13 +215,20 @@ export function createSource(api, log, emit) {
           }));
           messages = v2.data.session.message.list(id) ?? [];
         }
-        const status = translate.status(id, v2.data.session.status(id));
-        emit([...translate.session(info), ...translate.history(id, messages), /** Not known to the host is not running: the same lesson as OpenCode 1's store. */
-        ...(status.length > 0 ? status : [{
+        const past = translate.history(id, messages);
+        /** When its work ended, not when the store was last touched — reopening touches it. */
+        const ended = endOf(past, Number(info.time?.updated) || Date.now());
+        const status = translate.status(id, v2.data.session.status(id), ended);
+        emit([...translate.session(info), ...past, /** Not known to the host is not running: the same lesson as OpenCode 1's store. */
+        ...(status.length > 0 ? status.map(change => ({
+          ...change,
+          settled: true
+        })) : [{
           type: "status",
           id,
           status: "idle",
-          at: Number(info.time?.updated) || Date.now()
+          settled: true,
+          at: ended
         }])]);
       }
     },
@@ -219,7 +270,10 @@ export function createSource(api, log, emit) {
       });
     },
     check(id) {
-      return translate.status(id, v2.data.session.status(id));
+      return translate.status(id, v2.data.session.status(id)).map(change => ({
+        ...change,
+        settled: true
+      }));
     },
     dispose: () => {
       for (const each of offs.splice(0)) each();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/subagents",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "See what your subagents are doing: in the sidebar, full screen, and message them",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/client": "0.7.0",
+    "@opencode-cockpit/client": "0.7.1",
     "@opencode-ai/plugin": "1.18.31"
   },
   "devDependencies": {

package/types/core/model/changes.d.ts

@@ -37,6 +37,12 @@ export type Change =
     id: string;
     status: "busy" | "idle" | "failed" | "waiting";
     error?: string;
+    /**
+     * Said about a stored run — loaded, or checked after it went quiet — rather than live. Idle then
+     * means finished even with nothing recorded: a subagent whose history did not load is not one
+     * about to start, and read that way it showed as running for good.
+     */
+    settled?: boolean;
     at: number;
 }
 /** Something said *to* it: the first is the task it was given, the rest are messages. */

package/types/tui/source.d.ts

@@ -42,4 +42,6 @@ export interface Source {
     check: (id: string) => Change[];
     dispose: () => void;
 }
+/** The last moment a stored run did anything: its latest change, or `fallback` when it has none. */
+export declare function endOf(changes: readonly Change[], fallback: number): number;
 export declare function createSource(api: Host, log: Log, emit: (changes: Change[]) => void): Source;