opencode-courier 0.6.0 → 0.7.0

package/README.md

@@ -14,10 +14,9 @@ polling.
 [![License: MIT](https://img.shields.io/npm/l/opencode-courier)](LICENSE)
 [![Supported OpenCode V2 version](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fivopogace%2Fopencode-courier%2Fmain%2Fpackage.json&query=%24.peerDependencies%5B%27%40opencode%2Fplugin%27%5D&label=opencode&color=blue)](#supported-opencode-version)
 
-![A parent spawns two slow children, writes a README itself, and is woken by each report](docs/demo-async-tui.gif)
+https://github.com/user-attachments/assets/74a50b9c-462a-43f5-8737-bc7dd1917988
 
-A parent writes a README while two slow children work, and each report wakes it ([the
-prompt](#demos)).
+The edge cases on the live terminal UI, narrated ([what it shows](#demos)).
 
 ## Quickstart
 
@@ -80,21 +79,18 @@ idle); `queue: true` waits until the current turn ends.
 
 ## Demos
 
-**The parent does not wait.** Prompt: *"Spawn two children: one runs `sleep 30` then lists the
-exports of math.js, the other runs `sleep 45` then lists the exports of text.js. Don't wait for
-them: meanwhile write a short README.md for this folder yourself, and add their reports to it when
-they arrive."* The recording at the top is this run: the parent writes its README and finishes its
-turn 16 seconds in, while both children still sleep; each report (the `Message from ses_…` line)
-then starts a new turn on its own, and the parent folds it into the README.
+The video at the top (1:46, narrated) is the TUI driven in `tmux` on the scripted stand-in model of
+the live test, with `e2e/tui.sh`'s setup, so each scene is real plugin behaviour:
 
-**A child's question reaches you.** Prompt: *"Spawn a child session to add a multiply function to
-math.js. It must ask me first whether to name it multiply, times or product."*
-
-![A child's question opens as a form in the parent's session, times is picked, and the child carries on](docs/demo-question-tui.gif)
-
-The child's question opens in the parent's session as OpenCode's own question form, `times` is
-picked, and the child adds `times` to math.js and reports. Both recordings are real runs with a free
-model on [OpenCode Zen](https://opencode.ai/zen) (Muse Spark 1.3).
+- **A join group:** one member reports and its report is held with the group, while the other waits
+  on a permission request, so the footer says one is waiting on you. You allow it from the asks inbox
+  (`ctrl+x k`), and both reports reach the parent in one message.
+- **A child whose turn fails:** OpenCode shows "Session failed", the parent is told, and the
+  `/courier tree` row reads `failed`.
+- **A child that ends its turn without a report:** the parent is told, and the row says so.
+- **`/courier stop`:** pick the session, confirm, and it is stopped.
+- **A form only you can answer:** a child's web search shows a form; the footer, the panel row and
+  the asks inbox point to it, and answering it there wakes the parent.
 
 ## Recursive orchestration
 
@@ -117,7 +113,7 @@ line to the server log naming both ([more](docs/reference.md#the-opencode-versio
 
 | opencode-courier | OpenCode V2 (`opencode` and `@opencode/plugin`) |
 |---|---|
-| 0.5.0, 0.6.0 | 2.0.29 |
+| 0.5.0, 0.6.0, 0.7.0 | 2.0.29 |
 | 0.4.0, 0.4.1 | 2.0.28 |
 | 0.2.3, 0.3.0 | 2.0.26 |
 | 0.2.2 | 2.0.24 |
@@ -213,6 +209,11 @@ Each tool's parameters: [the reference](docs/reference.md#the-tools).
   plugin, with the error or its last reply, waking it if idle; one that waits on a request, its own
   children, a scheduled message or a webhook is not, nor is one that answers what you typed in its
   session. [More](docs/reference.md#a-child-that-fails).
+- **A message that fails to wake its session is sent again.** A report, notice or scheduled message
+  that waits in an idle session's inbox for 30 seconds without a turn starting for it is sent once
+  more under the same inbox id, which OpenCode takes for the same message, not a second one. If the
+  session still does not take it, the footer and the tree panel show it as `stalled`, for you to
+  prompt it. [More](docs/reference.md#a-missed-wake).
 - **Permission requests and questions reach you.** A child's request or question is passed to the
   session at the top of its tree, any number of levels down. For a request, that session proposes an
   answer with `courier_answer`, and OpenCode asks you in its own permission prompt, in that session
@@ -257,8 +258,9 @@ does not. Each spawned session's brief says when to split its task and when to d
 
 The package ships a part for OpenCode's terminal UI, which the TUI loads from the server's plugin
 list; the server half behaves the same whether or not a TUI is attached. In a session that started
-sessions, the prompt's footer shows what the tree under it is doing: how many run, wait on you (a
-permission request, a question or a form they show) or are idle, and for each [join group](docs/reference.md#join-groups) how many of its members have
+sessions, the prompt's footer shows what the tree under it is doing: how many wait on you (a
+permission request, a question or a form they show), are [stalled](docs/reference.md#a-missed-wake),
+run or are idle, and for each [join group](docs/reference.md#join-groups) how many of its members have
 reported:
 
 ```
@@ -267,7 +269,7 @@ courier 1 waiting on you · 2 running · group pair 1/2
 
 `/courier tree` opens a panel beside the session with the tree under it, a row per session indented
 by depth, with what it does, its report and its group's standing; a session waiting on you gets a line per
-request or form (`shows a form: Web Search`), a session that started others gets
+request or form (`shows a form: Web Search`), a stalled one since when its message waits, a session that started others gets
 a bar of the parts reported, a leaf how long it ran, its last tool call and its cost. A tree that has
 started more than `maxTotal` sessions over time is listed live ones first, then newest, and the header
 says how many older ones are left out; the footer counts them all. `↑`/`↓` select,

package/dist/index.js

@@ -9,7 +9,7 @@ import { builtVersions, versionNotice } from "./platform/version.js";
 import { addSchedulingTools, cancelScheduled, dueJob, isScheduled } from "./scheduling/index.js";
 import { addPersonTools, asksPermission, asksQuestion, formsShown, joinRelay, noticeCutOff, pendingOf, pendingQuestions, personEvents, portsAt, registerPersonRpc, relayQuestions, } from "./person/index.js";
 import { addSkill } from "./skill.js";
-import { addTreeTools, deliverReleased, dirtyOf, headOf, inspectWorktree, pruneExpired, readLimits, readNativeChildren, registerTreeRpc, shapeContext, together, treeEvents, waitsOn, } from "./tree/index.js";
+import { addTreeTools, deliverReleased, wakeMissed, dirtyOf, headOf, inspectWorktree, pruneExpired, readLimits, readNativeChildren, registerTreeRpc, shapeContext, together, treeEvents, waitsOn, } from "./tree/index.js";
 import { addWebhookTools, joinReceiver, readConfig, receiving, subscribedSince, } from "./webhook/index.js";
 /** The spawns under way in the process, outside the hub, so spawns in other locations, copies and hub versions count them. */
 const gate = sharedState("spawning", () => ({ reserved: new Set(), turn: Promise.resolve() }));
@@ -19,11 +19,12 @@ const inbox = sharedState("inbox", () => new Map());
 const shown = sharedState("formsShown", () => new Map());
 /**
  * What each tick of the scheduler does, in order, through the first loaded member, of whichever copy:
- * due `courier_later` messages, then released join groups. Every hub-v2 member's `later` is its LaterPorts.
+ * due `courier_later` messages, released join groups, then missed wakes. Every hub-v2 member's `later` is its LaterPorts.
  */
 const jobs = [
     dueJob,
     (owner, claimed) => deliverReleased(owner.later, claimed),
+    (owner, claimed) => wakeMissed(owner.later, claimed),
 ];
 const { join, track, nudge } = openInProcess(jobs);
 /** The permission domains of the loaded instances: every member's is its location's, whichever copy joined it. */

package/dist/tree/events.js

@@ -6,6 +6,7 @@ import { awaited, reportOf, stoppedSincePrompt } from "./report.js";
 import { childStore, groupStore } from "./store.js";
 import { lastReply } from "./status.js";
 import { failureNotice, silentNotice } from "./text.js";
+import { forgetWakes, settleWake, wakeEnded, wakeStarted, watchWake } from "./wake.js";
 /**
  * Tells the parent of a child whose turn failed, since a child that cannot reach its model cannot
  * call courier_send. Returns the parents told.
@@ -193,13 +194,37 @@ function routeTree(ports, state, outside, event) {
         return noteDeleted(ports, event);
     return undefined;
 }
+/** The events that move a courier message waiting in a session's inbox: enqueued, taken, cancelled, and the turns around it. */
+function routeWake(ports, event) {
+    if (event.type === "session.inbox.enqueued")
+        return watchWake(ports, event);
+    if (event.type === "session.inbox.delivered" || event.type === "session.inbox.cancelled")
+        return settleWake(ports, event);
+    if (event.type === "session.execution.started")
+        return wakeStarted(ports, event);
+    if (TURN_ENDS.has(event.type))
+        return wakeEnded(ports, event);
+    if (event.type === "session.deleted")
+        return forgetWakes(ports, event.data.sessionID);
+    return undefined;
+}
+/** The tree's handling of an event alongside the wake watch's, which touches other keys and never fails the tree's. */
+async function route(ports, state, outside, event) {
+    const watched = routeWake(ports, event)?.catch((error) => ports.log(`courier watch: wake of ${event.type}: ${String(error)}`));
+    try {
+        return await routeTree(ports, state, outside, event);
+    }
+    finally {
+        await watched;
+    }
+}
 /**
  * Tells parents of a child's failed or silent turn, unless it waits on what `outside` says, and notes
  * its prompts, interruptions and deletion; `after` a turn's end, seals the groups of its session.
  */
 export function treeEvents(state, outside) {
     return {
-        handle: (ports, event) => routeTree(ports, state, outside, event),
+        handle: (ports, event) => route(ports, state, outside, event),
         // After: a silent end is judged while the group the nudge may deliver is still there to wait on.
         after: (ports, event) => (TURN_ENDS.has(event.type) ? sealGroups(ports, event) : undefined),
     };

package/dist/tree/index.d.ts

@@ -8,3 +8,4 @@ export { allEntries, answeringTop, lineage, pruneExpired, RETENTION_MS } from ".
 export { subtree } from "./subtree.js";
 export { registerTreeRpc } from "./rpc-handlers.js";
 export { addTreeTools } from "./tools.js";
+export { wakeMissed } from "./wake.js";

package/dist/tree/index.js

@@ -1,4 +1,4 @@
-// What the rest of the plugin uses of the session tree: its tools, RPC, event module, context hook and tick job
+// What the rest of the plugin uses of the session tree: its tools, RPC, event module, context hook and tick jobs
 // for `src/index.ts`, and the lineage and subtree queries and types `person/` reads.
 export { dirtyOf, headOf, inspectWorktree } from "./cleanup.js";
 export { shapeContext } from "./context.js";
@@ -9,3 +9,4 @@ export { allEntries, answeringTop, lineage, pruneExpired, RETENTION_MS } from ".
 export { subtree } from "./subtree.js";
 export { registerTreeRpc } from "./rpc-handlers.js";
 export { addTreeTools } from "./tools.js";
+export { wakeMissed } from "./wake.js";

package/dist/tree/panel.d.ts

@@ -12,7 +12,7 @@ export declare const waitOf: (pending: Pending) => Wait;
 export declare const formWait: (form: ShownForm) => Wait;
 /**
  * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
- * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out.
+ * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
  */
 export declare function panel(ports: CourierPorts, rootID: string): Promise<Tree>;
 export {};

package/dist/tree/panel.js

@@ -3,6 +3,7 @@ import { lastStatus, stoppedSincePrompt } from "./report.js";
 import { standingIn } from "./status.js";
 import { childStore } from "./store.js";
 import { readTree } from "./subtree.js";
+import { stalledAmong } from "./wake.js";
 /** The last tool call in a session's messages, and when it was made. */
 export function lastTool(messages) {
     for (const message of messages.toReversed()) {
@@ -30,16 +31,21 @@ function reportRow(report, status) {
         return { report: { state: "ended", progressed: report.progressed } };
     return { report: { state: "reported", progressed: report.progressed, ...(status ? { status } : {}) } };
 }
-/** What a session does: waiting on a request to the person or a form it shows them, running, idle, or gone when OpenCode no longer knows it. */
-function stateOf(info, waits, running) {
+/**
+ * What a session does: waiting on a request to the person or a form it shows them, stalled, running, idle, or gone when
+ * OpenCode no longer knows it. A message waiting in its inbox makes a stalled session look busy.
+ */
+function stateOf(info, waits, stalled, running) {
     if (!info)
         return "gone";
     if (waits)
         return "waiting";
+    if (stalled)
+        return "stalled";
     return running ? "running" : "idle";
 }
 /** One session of the panel: what it is doing, its report and group standing, its last tool call and its cost. */
-async function row(ports, { entry, depth, info, pending, forms, report }) {
+async function row(ports, { entry, depth, info, pending, forms, report }, stalled) {
     const { sessionID } = entry;
     const [messages, status, standing, stopped] = await Promise.all([
         ports.session.context({ sessionID }).catch(() => []),
@@ -54,7 +60,8 @@ async function row(ports, { entry, depth, info, pending, forms, report }) {
         parentID: entry.parentID,
         title: info?.title ?? entry.title,
         depth,
-        state: stateOf(info, pending.length + forms.length, running),
+        state: stateOf(info, pending.length + forms.length, stalled !== undefined, running),
+        ...(stalled !== undefined ? { stalled } : {}),
         ...(info?.outcome ? { outcome: info.outcome } : {}),
         ...(stopped ? { stopped } : {}),
         ...reportRow(report, status),
@@ -69,10 +76,12 @@ async function row(ports, { entry, depth, info, pending, forms, report }) {
 }
 /**
  * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
- * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out.
+ * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
  */
 export async function panel(ports, rootID) {
     const { kept, leftOut } = await readTree(ports, rootID);
-    const rows = await Promise.all(kept.map((node) => row(ports, node)));
-    return { rows, ...(leftOut ? { truncated: leftOut } : {}) };
+    const stalled = await stalledAmong(ports, [rootID, ...kept.map((node) => node.entry.sessionID)]);
+    const rows = await Promise.all(kept.map((node) => row(ports, node, stalled.get(node.entry.sessionID))));
+    const own = stalled.get(rootID);
+    return { rows, ...(leftOut ? { truncated: leftOut } : {}), ...(own !== undefined ? { stalled: own } : {}) };
 }

package/dist/tree/ports.d.ts

@@ -80,6 +80,35 @@ export interface ChildStore {
     /** Removes report keys `reported` found, each best effort. */
     dropReported(keys: ReadonlyArray<string>): Promise<void>;
 }
+/**
+ * A courier message waiting in a session's inbox, watched until it is delivered: `running` while the session runs a
+ * turn, which takes it at its next step; `idleAt` since the session was last seen idle with it waiting.
+ */
+export interface Wake {
+    readonly sessionID: string;
+    readonly inboxID: string;
+    /** When OpenCode enqueued it. */
+    readonly at: number;
+    /** Its text and description, which waking the session again sends under the same inbox id. */
+    readonly text: string;
+    readonly description?: string;
+    readonly running: boolean;
+    readonly idleAt?: number;
+    /** When the scheduler woke the session again, the message still waiting. */
+    readonly rewoken?: number;
+    /** When the session was found still not woken after that: it is stalled. */
+    readonly stalled?: number;
+}
+export interface WakeStore {
+    /** Writes a watched message, replacing what was kept of it. */
+    put(wake: Wake): Promise<void>;
+    /** The messages watched in a session's inbox. */
+    of(sessionID: string): Promise<Wake[]>;
+    /** Every message watched. */
+    all(): Promise<Wake[]>;
+    /** Stops watching a message: delivered, cancelled, or its session gone. */
+    remove(sessionID: string, inboxID: string): Promise<void>;
+}
 /** A member of a join group with where it is kept. */
 export interface Membership extends Member {
     readonly parentID: string;

package/dist/tree/rpc-handlers.d.ts

@@ -14,26 +14,29 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
             }>;
             readonly output: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly running: number;
-                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
+                readonly waiting: number;
+                readonly stalled?: number | undefined;
             }, {
                 readonly running: number;
-                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
+                readonly waiting: number;
+                readonly stalled?: number | undefined;
             }> & import("effect/Schema").Struct<{
                 readonly running: import("effect/Schema").Int;
                 readonly waiting: import("effect/Schema").Int;
                 readonly idle: import("effect/Schema").Int;
+                readonly stalled: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
                 readonly groups: import("effect/Schema").$Array<import("effect/Schema").Struct<{
                     readonly name: import("effect/Schema").String;
                     readonly reported: import("effect/Schema").Int;
@@ -57,7 +60,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly depth: number;
                     readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -80,6 +83,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly state: "reported" | "ended" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
+                    readonly stalled?: number | undefined;
                     readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly tool?: {
                         readonly name: string;
@@ -87,6 +91,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     } | undefined;
                     readonly cost?: number | undefined;
                 }[];
+                readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
             }, {
                 readonly rows: readonly {
@@ -96,7 +101,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly depth: number;
                     readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -119,6 +124,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly state: "reported" | "ended" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
+                    readonly stalled?: number | undefined;
                     readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly tool?: {
                         readonly name: string;
@@ -126,6 +132,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     } | undefined;
                     readonly cost?: number | undefined;
                 }[];
+                readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
             }> & import("effect/Schema").Struct<{
                 readonly rows: import("effect/Schema").$Array<import("effect/Schema").Struct<{
@@ -133,7 +140,8 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly parentID: import("effect/Schema").String;
                     readonly title: import("effect/Schema").String;
                     readonly depth: import("effect/Schema").Int;
-                    readonly state: import("effect/Schema").Literals<readonly ["running", "waiting", "idle", "gone"]>;
+                    readonly state: import("effect/Schema").Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+                    readonly stalled: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
                     readonly outcome: import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["succeeded", "failed", "interrupted"]>>;
                     readonly stopped: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
                     readonly report: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
@@ -166,6 +174,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     }>]>>;
                 }>>;
                 readonly truncated: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+                readonly stalled: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
             }>;
         };
         readonly stop: {

package/dist/tree/rpc.d.ts

@@ -7,6 +7,8 @@ declare const Summary: Schema.Struct<{
     readonly waiting: Schema.Int;
     /** Not running: done, or waiting for a message. */
     readonly idle: Schema.Int;
+    /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
+    readonly stalled: Schema.optionalKey<Schema.Int>;
     readonly groups: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
         readonly reported: Schema.Int;
@@ -33,8 +35,13 @@ declare const Row: Schema.Struct<{
     readonly title: Schema.String;
     /** A child of the panel's session is at depth 1. */
     readonly depth: Schema.Int;
-    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
-    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+    /**
+     * `waiting` on a request to the person or a form it shows them; `stalled` when a courier message waits in its inbox and
+     * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+     */
+    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+    /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+    readonly stalled: Schema.optionalKey<Schema.Number>;
     /** How its last turn ended. */
     readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
     /** Set when courier_stop stopped it since its last prompt. */
@@ -81,8 +88,13 @@ declare const Tree: Schema.Struct<{
         readonly title: Schema.String;
         /** A child of the panel's session is at depth 1. */
         readonly depth: Schema.Int;
-        /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
-        readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+        /**
+         * `waiting` on a request to the person or a form it shows them; `stalled` when a courier message waits in its inbox and
+         * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+         */
+        readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+        /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+        readonly stalled: Schema.optionalKey<Schema.Number>;
         /** How its last turn ended. */
         readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
         /** Set when courier_stop stopped it since its last prompt. */
@@ -123,6 +135,8 @@ declare const Tree: Schema.Struct<{
     }>>;
     /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
     readonly truncated: Schema.optionalKey<Schema.Int>;
+    /** Since when a courier message has waited in the panel's own session, when that session is stalled. */
+    readonly stalled: Schema.optionalKey<Schema.Number>;
 }>;
 export type Row = typeof Row.Type;
 export type Tree = typeof Tree.Type;
@@ -159,22 +173,24 @@ export declare const treeRpc: {
             }>;
             readonly output: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly running: number;
-                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
+                readonly waiting: number;
+                readonly stalled?: number | undefined;
             }, {
                 readonly running: number;
-                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
+                readonly waiting: number;
+                readonly stalled?: number | undefined;
             }> & Schema.Struct<{
                 /** Running, and waiting on no request or form. */
                 readonly running: Schema.Int;
@@ -182,6 +198,8 @@ export declare const treeRpc: {
                 readonly waiting: Schema.Int;
                 /** Not running: done, or waiting for a message. */
                 readonly idle: Schema.Int;
+                /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
+                readonly stalled: Schema.optionalKey<Schema.Int>;
                 readonly groups: Schema.$Array<Schema.Struct<{
                     readonly name: Schema.String;
                     readonly reported: Schema.Int;
@@ -205,7 +223,7 @@ export declare const treeRpc: {
                     readonly depth: number;
                     readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -228,6 +246,7 @@ export declare const treeRpc: {
                         readonly state: "reported" | "ended" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
+                    readonly stalled?: number | undefined;
                     readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly tool?: {
                         readonly name: string;
@@ -235,6 +254,7 @@ export declare const treeRpc: {
                     } | undefined;
                     readonly cost?: number | undefined;
                 }[];
+                readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
             }, {
                 readonly rows: readonly {
@@ -244,7 +264,7 @@ export declare const treeRpc: {
                     readonly depth: number;
                     readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -267,6 +287,7 @@ export declare const treeRpc: {
                         readonly state: "reported" | "ended" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
+                    readonly stalled?: number | undefined;
                     readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly tool?: {
                         readonly name: string;
@@ -274,6 +295,7 @@ export declare const treeRpc: {
                     } | undefined;
                     readonly cost?: number | undefined;
                 }[];
+                readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
             }> & Schema.Struct<{
                 readonly rows: Schema.$Array<Schema.Struct<{
@@ -282,8 +304,13 @@ export declare const treeRpc: {
                     readonly title: Schema.String;
                     /** A child of the panel's session is at depth 1. */
                     readonly depth: Schema.Int;
-                    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
-                    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+                    /**
+                     * `waiting` on a request to the person or a form it shows them; `stalled` when a courier message waits in its inbox and
+                     * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+                     */
+                    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+                    /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+                    readonly stalled: Schema.optionalKey<Schema.Number>;
                     /** How its last turn ended. */
                     readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
                     /** Set when courier_stop stopped it since its last prompt. */
@@ -324,6 +351,8 @@ export declare const treeRpc: {
                 }>>;
                 /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
                 readonly truncated: Schema.optionalKey<Schema.Int>;
+                /** Since when a courier message has waited in the panel's own session, when that session is stalled. */
+                readonly stalled: Schema.optionalKey<Schema.Number>;
             }>;
         };
         /** Stops `sessionID` and everything under it, as courier_stop called from `by`, which must be above it. */

package/dist/tree/rpc.js

@@ -15,6 +15,8 @@ const Summary = Schema.Struct({
     waiting: Count,
     /** Not running: done, or waiting for a message. */
     idle: Count,
+    /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
+    stalled: Schema.optionalKey(Count),
     groups: Schema.Array(Group),
 });
 /** A request a session waits on until the person answers it: a permission request, its first question, or a form it shows. */
@@ -30,8 +32,13 @@ const Row = Schema.Struct({
     title: Schema.String,
     /** A child of the panel's session is at depth 1. */
     depth: Count,
-    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
-    state: Schema.Literals(["running", "waiting", "idle", "gone"]),
+    /**
+     * `waiting` on a request to the person or a form it shows them; `stalled` when a courier message waits in its inbox and
+     * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+     */
+    state: Schema.Literals(["running", "waiting", "idle", "stalled", "gone"]),
+    /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+    stalled: Schema.optionalKey(Schema.Number),
     /** How its last turn ended. */
     outcome: Schema.optionalKey(Schema.Literals(["succeeded", "failed", "interrupted"])),
     /** Set when courier_stop stopped it since its last prompt. */
@@ -55,6 +62,8 @@ const Tree = Schema.Struct({
     rows: Schema.Array(Row),
     /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
     truncated: Schema.optionalKey(Count),
+    /** Since when a courier message has waited in the panel's own session, when that session is stalled. */
+    stalled: Schema.optionalKey(Schema.Number),
 });
 /** What a stop did to each session, deepest first, as courier_stop reports it. */
 const Stopped = Schema.Struct({

package/dist/tree/stop.js

@@ -4,6 +4,7 @@ import { cleanup } from "./cleanup.js";
 import { childStore } from "./store.js";
 import { subtree } from "./subtree.js";
 import { stoppedNotice } from "./text.js";
+import { forgetWakes } from "./wake.js";
 /** Rounds of looking again for sessions started while others were being stopped. */
 const ROUNDS = 3;
 /**
@@ -62,6 +63,7 @@ async function silence(ports, sessionID, cancelled) {
     catch (error) {
         log(`courier_stop: could not cancel the messages scheduled for ${sessionID}: ${String(error)}`);
     }
+    await forgetWakes(ports.courier, sessionID).catch((error) => log(`courier_stop: could not drop the wake watch of ${sessionID}: ${String(error)}`));
 }
 async function interrupt(ports, { entry, depth }) {
     const { sessionID, title } = entry;

package/dist/tree/store.d.ts

@@ -1,5 +1,5 @@
 import { type Storage } from "../platform/storage.js";
-import type { ChildStore, GroupStore } from "./ports.js";
+import type { ChildStore, GroupStore, WakeStore } from "./ports.js";
 /**
  * What the reverse index holds for a child: the sessions above it, its parent first and the top
  * session, which courier_spawn did not start, last; each is the parent of the one before it.
@@ -18,7 +18,10 @@ export declare const memberKey: (parentID: string, group: string, sessionID: str
 /** The key prefix of a parent's groups, and of one group's members. */
 export declare const groupsPrefix: (parentID: string) => string;
 export declare const groupPrefix: (parentID: string, group: string) => string;
+export declare const wakeKey: (sessionID: string, inboxID: string) => string;
 /** The `ChildStore` over the plugin's storage. */
 export declare function childStore(storage: Storage): ChildStore;
 /** The `GroupStore` over the plugin's storage. */
 export declare function groupStore(storage: Storage): GroupStore;
+/** The `WakeStore` over the plugin's storage. */
+export declare function wakeStore(storage: Storage): WakeStore;

package/dist/tree/store.js

@@ -42,6 +42,12 @@ export const memberKey = (parentID, group, sessionID) => `${GROUP_PREFIX}${paren
 /** The key prefix of a parent's groups, and of one group's members. */
 export const groupsPrefix = (parentID) => `${GROUP_PREFIX}${parentID}/`;
 export const groupPrefix = (parentID, group) => `${groupsPrefix(parentID)}${group}/`;
+/**
+ * The courier messages waiting in a session's inbox, each under `wake/<sessionID>/<inboxID>` until it is delivered, for
+ * the scheduler to wake a session whose wake was missed. docs/maintainers/architecture.md, § Storage.
+ */
+const WAKE_PREFIX = "wake/";
+export const wakeKey = (sessionID, inboxID) => `${WAKE_PREFIX}${sessionID}/${inboxID}`;
 function isReverse(value) {
     const ancestors = value?.ancestors;
     return Array.isArray(ancestors) && ancestors.length > 0 && ancestors.every((id) => typeof id === "string");
@@ -262,3 +268,48 @@ export function groupStore(storage) {
         },
     };
 }
+/** A watched message as stored under its key's session and inbox id; one that cannot be read is left out. */
+function readWake(sessionID, inboxID, value) {
+    const given = obj(value);
+    const at = num(given.at);
+    const text = str(given.text);
+    if (at === undefined || text === undefined || typeof given.running !== "boolean")
+        return undefined;
+    const optional = (field) => {
+        const time = num(given[field]);
+        return time === undefined ? {} : { [field]: time };
+    };
+    const description = str(given.description);
+    return {
+        sessionID,
+        inboxID,
+        at,
+        text,
+        ...(description !== undefined ? { description } : {}),
+        running: given.running,
+        ...optional("idleAt"),
+        ...optional("rewoken"),
+        ...optional("stalled"),
+    };
+}
+/** The `WakeStore` over the plugin's storage. */
+export function wakeStore(storage) {
+    const under = async (prefix) => {
+        const entries = await scanEntries(storage, prefix);
+        return entries.flatMap(({ key, value }) => {
+            const parts = `${prefix.slice(WAKE_PREFIX.length)}${key}`.split("/");
+            const wake = parts.length === 2 ? readWake(parts[0], parts[1], value) : undefined;
+            return wake ? [wake] : [];
+        });
+    };
+    return {
+        async put({ sessionID, inboxID, ...wake }) {
+            await storage.set(wakeKey(sessionID, inboxID), { ...wake });
+        },
+        of: (sessionID) => under(`${WAKE_PREFIX}${sessionID}/`),
+        all: () => under(WAKE_PREFIX),
+        async remove(sessionID, inboxID) {
+            await storage.remove(wakeKey(sessionID, inboxID));
+        },
+    };
+}

package/dist/tree/summary.d.ts

@@ -1,7 +1,7 @@
 import type { CourierPorts } from "./ports.js";
 import type { Summary } from "./rpc.js";
 /**
- * Every session started under a session, counted by what it is doing, and its open join groups, those of its own
- * children, with how far each has reported.
+ * Every session started under a session, counted by what it is doing (the session itself too, when it is stalled), and its
+ * open join groups, those of its own children, with how far each has reported.
  */
 export declare function summary(ports: CourierPorts, sessionID: string): Promise<Summary>;

package/dist/tree/summary.js

@@ -2,26 +2,35 @@ import { busy } from "./domain.js";
 import { groupStandings } from "./group.js";
 import { groupStore } from "./store.js";
 import { lookUp } from "./subtree.js";
-/** What a session is doing: waiting on a request it made or a form it shows, running, or idle; undefined when OpenCode no longer knows it. */
-function activity({ info, pending, forms }) {
+import { stalledAmong } from "./wake.js";
+/**
+ * What a session is doing: waiting on a request it made or a form it shows, stalled, running, or idle; undefined when
+ * OpenCode no longer knows it. A message waiting in its inbox makes a stalled session look busy.
+ */
+function activity({ info, pending, forms, entry }, stalled) {
     if (!info)
         return undefined;
     if (pending.length || forms.length)
         return "waiting";
+    if (stalled.has(entry.sessionID))
+        return "stalled";
     return busy(info.time) ? "running" : "idle";
 }
 /**
- * Every session started under a session, counted by what it is doing, and its open join groups, those of its own
- * children, with how far each has reported.
+ * Every session started under a session, counted by what it is doing (the session itself too, when it is stalled), and its
+ * open join groups, those of its own children, with how far each has reported.
  */
 export async function summary(ports, sessionID) {
     const [looked, standings] = await Promise.all([lookUp(ports, sessionID), groupStandings(groupStore(ports.storage), sessionID)]);
-    const activities = looked.map(activity);
+    const stalled = await stalledAmong(ports, [sessionID, ...looked.map((one) => one.entry.sessionID)]);
+    const activities = looked.map((one) => activity(one, stalled));
     const count = (kind) => activities.filter((item) => item === kind).length;
+    const stalls = count("stalled") + (stalled.has(sessionID) ? 1 : 0);
     return {
         running: count("running"),
         waiting: count("waiting"),
         idle: count("idle"),
+        ...(stalls ? { stalled: stalls } : {}),
         groups: standings.map(({ name, reported, members }) => ({ name, reported, members })),
     };
 }

package/dist/tree/tui.d.ts

@@ -34,11 +34,15 @@ export declare function waitLine(wait: Wait): string;
 export declare function statusLine(row: Row): string;
 /** A leaf's activity: how long it has run, its last tool call and how long ago, and its cost. */
 export declare function activityLine(row: Row, now: number): string;
-/** The lines a row shows under its title: an orchestrator's bar, a paused session's requests, or else a live leaf's activity. */
+/** What a stalled session's row, or the panel of one, says of it: "a message waits in its inbox since 2m 05s, woken again in vain". */
+export declare function stalledLine(since: number, now: number): string;
+/** The lines a row shows under its title: an orchestrator's bar, a paused or stalled session's wait, or else a live leaf's activity. */
 export declare function detailLines(row: Row, rows: ReadonlyArray<Row>, now: number): string[];
+/** How often the footer and the panel ask again with no event: the scheduler flags a stalled session without one. */
+export declare const REREAD_MS = 15000;
 /**
  * Adds the tree's entry to the prompt's footer: what the sessions under the open session do, asked of the RPC after each
- * change; nothing on the home screen. Clicked while some wait on the person, it calls `onWaiting` with the open session.
+ * change and every `REREAD_MS`; nothing on the home screen. Clicked while some wait on the person, it calls `onWaiting`.
  */
 export declare function addTreeStatus(ctx: Context, onWaiting?: (sessionID: string) => void): () => void;
 /** The toast after a stop: how many sessions were interrupted, and how many scheduled messages were cancelled. */

package/dist/tree/wake.d.ts

@@ -0,0 +1,68 @@
+import type { GroupPorts, Wake, WatchPorts } from "./ports.js";
+/** How long a courier message may wait in an idle session's inbox before its wake counts as missed. */
+export declare const WAKE_MS = 30000;
+/** OpenCode's `session.inbox.enqueued`, with the item's payload, which carries the courier's metadata. */
+export interface Enqueued {
+    readonly created?: number;
+    readonly data: {
+        readonly sessionID: string;
+        readonly inboxID: string;
+        readonly item: {
+            readonly type: string;
+            readonly payload?: {
+                readonly text?: unknown;
+                readonly description?: unknown;
+                readonly metadata?: {
+                    readonly source?: unknown;
+                };
+            };
+        };
+    };
+}
+/** OpenCode's `session.inbox.delivered` and `session.inbox.cancelled`. */
+export interface InboxSettled {
+    readonly data: {
+        readonly sessionID: string;
+        readonly inboxID: string;
+    };
+}
+/** OpenCode's `session.execution.*` events, which frame a session's busy period. */
+export interface Execution {
+    readonly created?: number;
+    readonly data: {
+        readonly sessionID: string;
+    };
+}
+/**
+ * Watches a courier message enqueued for a session until it is delivered, noting whether the session runs: a running
+ * turn takes it at its next step, an idle session is woken for it. Returns whether it is watched.
+ */
+export declare function watchWake(ports: WatchPorts, event: Enqueued): Promise<boolean>;
+/** Stops watching a message once it is delivered or cancelled. */
+export declare function settleWake(ports: Pick<WatchPorts, "storage">, event: InboxSettled): Promise<void>;
+/** A turn started in a session: the messages waiting there are its to take. */
+export declare function wakeStarted(ports: Pick<WatchPorts, "storage">, event: Execution): Promise<void>;
+/**
+ * A session's turn ended: a message it took is no longer watched, as its delivery may have been missed by this
+ * subscription; one still waiting is watched as waiting in an idle session from now.
+ */
+export declare function wakeEnded(ports: WatchPorts, event: Execution & {
+    readonly data: {
+        readonly reason?: string;
+    };
+}): Promise<void>;
+/** Forgets the messages watched in a session's inbox: it was deleted, or stopped, which nothing is to wake again. */
+export declare function forgetWakes(ports: Pick<WatchPorts, "storage">, sessionID: string): Promise<void>;
+/** The ports the scheduler's tick wakes sessions through: what every hub member's `later` ports have. */
+export type WakePorts = GroupPorts & {
+    readonly now: () => number;
+};
+/**
+ * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, and flags
+ * stalled one still waiting `WAKE_MS` later; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
+ */
+export declare function wakeMissed(ports: WakePorts, claimed: Set<string>): Promise<void>;
+/** Whether a message has waited in an idle session past `WAKE_MS`, and since a wake again, if one was sent; a stalled one is done. */
+export declare function missed(wake: Wake, now: number): boolean;
+/** The sessions among `sessionIDs` flagged stalled, each with when its oldest stalled message was enqueued. */
+export declare function stalledAmong(ports: Pick<WatchPorts, "storage">, sessionIDs: ReadonlyArray<string>): Promise<Map<string, number>>;

package/dist/tree/wake.js

@@ -0,0 +1,119 @@
+import { wakeStore } from "./store.js";
+/** How long a courier message may wait in an idle session's inbox before its wake counts as missed. */
+export const WAKE_MS = 30_000;
+/** Whether a session's stored messages end with the marker of an ended turn; one with none yet is taken to run. */
+const endsIdle = (messages) => messages.at(-1)?.type === "idle";
+/**
+ * Watches a courier message enqueued for a session until it is delivered, noting whether the session runs: a running
+ * turn takes it at its next step, an idle session is woken for it. Returns whether it is watched.
+ */
+export async function watchWake(ports, event) {
+    const { sessionID, inboxID, item } = event.data;
+    const payload = item.payload;
+    if (item.type !== "synthetic" || payload?.metadata?.source !== "courier" || typeof payload.text !== "string")
+        return false;
+    const at = event.created ?? ports.now();
+    // Read after the enqueue: a turn it started has stored messages since, and an unknown session is taken to run.
+    const idle = await ports.session.context({ sessionID }).then(endsIdle, () => false);
+    await wakeStore(ports.storage).put({
+        sessionID,
+        inboxID,
+        at,
+        text: payload.text,
+        ...(typeof payload.description === "string" ? { description: payload.description } : {}),
+        running: !idle,
+        ...(idle ? { idleAt: at } : {}),
+    });
+    return true;
+}
+/** Stops watching a message once it is delivered or cancelled. */
+export async function settleWake(ports, event) {
+    await wakeStore(ports.storage).remove(event.data.sessionID, event.data.inboxID);
+}
+/** A turn started in a session: the messages waiting there are its to take. */
+export async function wakeStarted(ports, event) {
+    const store = wakeStore(ports.storage);
+    const waiting = await store.of(event.data.sessionID);
+    await Promise.all(waiting.filter((wake) => !wake.running).map(({ idleAt: _, ...wake }) => store.put({ ...wake, running: true })));
+}
+/**
+ * A session's turn ended: a message it took is no longer watched, as its delivery may have been missed by this
+ * subscription; one still waiting is watched as waiting in an idle session from now.
+ */
+export async function wakeEnded(ports, event) {
+    if (event.data.reason === "shutdown")
+        return;
+    const { sessionID } = event.data;
+    const store = wakeStore(ports.storage);
+    const waiting = await store.of(sessionID);
+    if (!waiting.length)
+        return;
+    const at = event.created ?? ports.now();
+    const stored = new Set((await ports.session.context({ sessionID }).catch(() => [])).map((message) => message.id));
+    await Promise.all(waiting.map((wake) => (stored.has(wake.inboxID) ? store.remove(sessionID, wake.inboxID) : store.put({ ...wake, running: false, idleAt: at }))));
+}
+/** Forgets the messages watched in a session's inbox: it was deleted, or stopped, which nothing is to wake again. */
+export async function forgetWakes(ports, sessionID) {
+    const store = wakeStore(ports.storage);
+    await Promise.all((await store.of(sessionID)).map((wake) => store.remove(sessionID, wake.inboxID)));
+}
+/**
+ * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, and flags
+ * stalled one still waiting `WAKE_MS` later; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
+ */
+export async function wakeMissed(ports, claimed) {
+    const store = wakeStore(ports.storage);
+    const now = ports.now();
+    const due = (await store.all()).filter((wake) => missed(wake, now) && !claimed.has(claimOf(wake)));
+    for (const wake of due)
+        claimed.add(claimOf(wake));
+    await Promise.all(due.map((wake) => wakeAgain(ports, store, wake, now).finally(() => claimed.delete(claimOf(wake)))));
+}
+const claimOf = (wake) => `wake ${wake.sessionID} ${wake.inboxID}`;
+/** Whether a message has waited in an idle session past `WAKE_MS`, and since a wake again, if one was sent; a stalled one is done. */
+export function missed(wake, now) {
+    if (wake.running || wake.stalled !== undefined)
+        return false;
+    const since = Math.max(wake.idleAt ?? wake.at, wake.rewoken ?? 0);
+    return now - since >= WAKE_MS;
+}
+async function wakeAgain(ports, store, wake, now) {
+    try {
+        // Re-read: the message may have been delivered, or the session woken, since the scan.
+        const current = (await store.of(wake.sessionID)).find((one) => one.inboxID === wake.inboxID);
+        if (!current || !missed(current, now))
+            return;
+        if (current.rewoken !== undefined) {
+            ports.log(`courier wake: ${wake.sessionID} has not taken message ${wake.inboxID} since it was woken again; flagged stalled`);
+            return await store.put({ ...current, stalled: now });
+        }
+        // Noted before the send: the turn it starts may take the message, and drop the watch, before the send returns.
+        await store.put({ ...current, rewoken: now });
+        await ports.session.synthetic({
+            sessionID: wake.sessionID,
+            id: wake.inboxID,
+            text: wake.text,
+            ...(wake.description !== undefined ? { description: wake.description } : {}),
+            metadata: { source: "courier", wake: "again" },
+            delivery: "steer",
+        }).catch(async (error) => {
+            await store.put(current);
+            throw error;
+        });
+        ports.log(`courier wake: ${wake.sessionID} left message ${wake.inboxID} waiting while idle; woken again`);
+    }
+    catch (error) {
+        ports.log(`courier wake: could not wake ${wake.sessionID} again for ${wake.inboxID}: ${String(error)}`);
+    }
+}
+/** The sessions among `sessionIDs` flagged stalled, each with when its oldest stalled message was enqueued. */
+export async function stalledAmong(ports, sessionIDs) {
+    const wanted = new Set(sessionIDs);
+    const stalled = new Map();
+    for (const wake of await wakeStore(ports.storage).all()) {
+        if (wake.stalled === undefined || !wanted.has(wake.sessionID))
+            continue;
+        stalled.set(wake.sessionID, Math.min(stalled.get(wake.sessionID) ?? wake.at, wake.at));
+    }
+    return stalled;
+}

package/dist/tui.js

@@ -808,6 +808,7 @@ var Summary = Schema2.Struct({
   running: Count2,
   waiting: Count2,
   idle: Count2,
+  stalled: Schema2.optionalKey(Count2),
   groups: Schema2.Array(Group)
 });
 var Wait = Schema2.Union([
@@ -820,7 +821,8 @@ var Row = Schema2.Struct({
   parentID: Schema2.String,
   title: Schema2.String,
   depth: Count2,
-  state: Schema2.Literals(["running", "waiting", "idle", "gone"]),
+  state: Schema2.Literals(["running", "waiting", "idle", "stalled", "gone"]),
+  stalled: Schema2.optionalKey(Schema2.Number),
   outcome: Schema2.optionalKey(Schema2.Literals(["succeeded", "failed", "interrupted"])),
   stopped: Schema2.optionalKey(Schema2.Boolean),
   report: Schema2.optionalKey(Schema2.Struct({ state: Schema2.Literals(["owed", "reported", "ended"]), status: Schema2.optionalKey(Schema2.String), progressed: Schema2.Boolean })),
@@ -834,7 +836,8 @@ var Row = Schema2.Struct({
 });
 var Tree = Schema2.Struct({
   rows: Schema2.Array(Row),
-  truncated: Schema2.optionalKey(Count2)
+  truncated: Schema2.optionalKey(Count2),
+  stalled: Schema2.optionalKey(Schema2.Number)
 });
 var Stopped = Schema2.Struct({
   stopped: Schema2.Array(Schema2.Struct({ sessionID: Schema2.String, title: Schema2.String, outcome: Schema2.String })),
@@ -878,7 +881,7 @@ var PANEL = "courier-tree";
 var TICK_MS = 1000;
 function summaryLine(summary, maxWidth = Infinity) {
   const groups = summary.groups.map((group) => `group ${group.name} ${group.reported}/${group.members}`);
-  const parts = [summary.waiting ? `${summary.waiting} waiting on you` : "", summary.running ? `${summary.running} running` : "", ...groups, summary.idle ? `${summary.idle} idle` : ""].filter(Boolean);
+  const parts = [summary.waiting ? `${summary.waiting} waiting on you` : "", summary.stalled ? `${summary.stalled} stalled` : "", summary.running ? `${summary.running} running` : "", ...groups, summary.idle ? `${summary.idle} idle` : ""].filter(Boolean);
   if (!parts.length)
     return "";
   const line = (kept) => {
@@ -924,6 +927,8 @@ function statusLine(row) {
 function stateWord(row) {
   if (row.state === "waiting")
     return "waiting on you";
+  if (row.state === "stalled")
+    return "stalled";
   if (row.state === "idle" && row.stopped)
     return "stopped";
   if (row.state === "idle" && (row.outcome === "failed" || row.outcome === "interrupted"))
@@ -943,10 +948,15 @@ var counted = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
 function activityLine(row, now) {
   return [`ran ${duration((row.idle ?? now) - row.created)}`, row.tool ? `last ${row.tool.name} ${duration(now - row.tool.at)} ago` : "no tool call yet", row.cost !== undefined ? `$${row.cost.toFixed(2)}` : ""].filter(Boolean).join(" \xB7 ");
 }
+function stalledLine(since, now) {
+  return `a message waits in its inbox since ${duration(now - since)}, woken again in vain`;
+}
 function detailLines(row, rows, now) {
   const started = parts(rows, row.sessionID);
   if (row.waits.length)
     return [...started.started ? [bar(started)] : [], ...row.waits.map(waitLine)];
+  if (row.stalled !== undefined)
+    return [...started.started ? [bar(started)] : [], stalledLine(row.stalled, now)];
   if (started.started)
     return [bar(started)];
   return row.state === "gone" ? [] : [activityLine(row, now)];
@@ -959,8 +969,10 @@ function courierOf(ctx) {
     location
   };
 }
+var REREAD_MS = 15000;
 function changes(ctx, types, settle) {
   const [changed, setChanged] = createSignal(0);
+  const reread = setInterval(() => setChanged((count) => count + 1), REREAD_MS);
   let settling;
   const unlisten = ctx.data.listen(({
     details
@@ -974,6 +986,7 @@ function changes(ctx, types, settle) {
   });
   return [changed, () => {
     clearTimeout(settling);
+    clearInterval(reread);
     unlisten();
   }];
 }
@@ -1323,15 +1336,17 @@ function TreePanel(props) {
   }));
   const root = () => parts(rows(), view.root);
   const rowColor = (row) => {
+    if (row.state === "stalled")
+      return theme.text.feedback.error.base;
     if (row.state === "waiting")
       return theme.text.feedback.warning.base;
     return row.state === "gone" ? theme.text.muted : theme.text.base;
   };
   return (() => {
-    var _el$4 = _$createElement("box"), _el$5 = _$createElement("box"), _el$6 = _$createElement("text"), _el$13 = _$createElement("scrollbox"), _el$14 = _$createElement("text");
+    var _el$4 = _$createElement("box"), _el$5 = _$createElement("box"), _el$6 = _$createElement("text"), _el$15 = _$createElement("scrollbox"), _el$16 = _$createElement("text");
     _$insertNode(_el$4, _el$5);
-    _$insertNode(_el$4, _el$13);
-    _$insertNode(_el$4, _el$14);
+    _$insertNode(_el$4, _el$15);
+    _$insertNode(_el$4, _el$16);
     _$setProp(_el$4, "flexDirection", "column");
     _$setProp(_el$4, "flexGrow", 1);
     _$setProp(_el$4, "paddingLeft", 1);
@@ -1378,21 +1393,33 @@ function TreePanel(props) {
         _$effect((_$p) => _$setProp(_el$1, "fg", theme.text.feedback.error.base, _$p));
         return _el$1;
       }
-    }), _el$13);
+    }), _el$15);
     _$insert(_el$4, _$createComponent(Show, {
       get when() {
-        return _$memo(() => !!latest()?.tree)() && !rows().length;
+        return latest()?.tree?.stalled;
       },
       get children() {
-        var _el$11 = _$createElement("text");
-        _$insertNode(_el$11, _$createTextNode(`No session started with courier_spawn under this one.`));
-        _$effect((_$p) => _$setProp(_el$11, "fg", theme.text.muted, _$p));
+        var _el$11 = _$createElement("text"), _el$12 = _$createTextNode(`This session is stalled: `);
+        _$insertNode(_el$11, _el$12);
+        _$insert(_el$11, () => stalledLine(latest().tree.stalled, now()), null);
+        _$effect((_$p) => _$setProp(_el$11, "fg", theme.text.feedback.error.base, _$p));
         return _el$11;
       }
-    }), _el$13);
-    _$use((value) => scroll = value, _el$13);
-    _$setProp(_el$13, "flexGrow", 1);
-    _$insert(_el$13, _$createComponent(For, {
+    }), _el$15);
+    _$insert(_el$4, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!latest()?.tree)() && !rows().length;
+      },
+      get children() {
+        var _el$13 = _$createElement("text");
+        _$insertNode(_el$13, _$createTextNode(`No session started with courier_spawn under this one.`));
+        _$effect((_$p) => _$setProp(_el$13, "fg", theme.text.muted, _$p));
+        return _el$13;
+      }
+    }), _el$15);
+    _$use((value) => scroll = value, _el$15);
+    _$setProp(_el$15, "flexGrow", 1);
+    _$insert(_el$15, _$createComponent(For, {
       get each() {
         return rows();
       },
@@ -1400,45 +1427,45 @@ function TreePanel(props) {
         const chosen = () => index() === selected();
         const indent = "  ".repeat(row.depth - 1);
         return (() => {
-          var _el$16 = _$createElement("box"), _el$17 = _$createElement("box"), _el$18 = _$createElement("text"), _el$19 = _$createElement("text"), _el$20 = _$createTextNode(`  `);
-          _$insertNode(_el$16, _el$17);
-          _$setProp(_el$16, "flexDirection", "column");
-          _$setProp(_el$16, "flexShrink", 0);
-          _$insertNode(_el$17, _el$18);
-          _$insertNode(_el$17, _el$19);
-          _$setProp(_el$17, "flexDirection", "row");
-          _$setProp(_el$17, "flexShrink", 0);
-          _$setProp(_el$18, "wrapMode", "none");
-          _$setProp(_el$18, "flexShrink", 1);
-          _$setProp(_el$18, "minWidth", 0);
-          _$insert(_el$18, indent, null);
-          _$insert(_el$18, () => chosen() ? "\u25B8 " : "  ", null);
-          _$insert(_el$18, () => oneLine(row.title), null);
-          _$insert(_el$18, () => row.sessionID === input.sessionID ? " (on screen)" : "", null);
+          var _el$18 = _$createElement("box"), _el$19 = _$createElement("box"), _el$20 = _$createElement("text"), _el$21 = _$createElement("text"), _el$22 = _$createTextNode(`  `);
+          _$insertNode(_el$18, _el$19);
+          _$setProp(_el$18, "flexDirection", "column");
+          _$setProp(_el$18, "flexShrink", 0);
           _$insertNode(_el$19, _el$20);
-          _$setProp(_el$19, "wrapMode", "none");
+          _$insertNode(_el$19, _el$21);
+          _$setProp(_el$19, "flexDirection", "row");
           _$setProp(_el$19, "flexShrink", 0);
-          _$insert(_el$19, () => statusLine(row), null);
-          _$insert(_el$16, _$createComponent(For, {
+          _$setProp(_el$20, "wrapMode", "none");
+          _$setProp(_el$20, "flexShrink", 1);
+          _$setProp(_el$20, "minWidth", 0);
+          _$insert(_el$20, indent, null);
+          _$insert(_el$20, () => chosen() ? "\u25B8 " : "  ", null);
+          _$insert(_el$20, () => oneLine(row.title), null);
+          _$insert(_el$20, () => row.sessionID === input.sessionID ? " (on screen)" : "", null);
+          _$insertNode(_el$21, _el$22);
+          _$setProp(_el$21, "wrapMode", "none");
+          _$setProp(_el$21, "flexShrink", 0);
+          _$insert(_el$21, () => statusLine(row), null);
+          _$insert(_el$18, _$createComponent(For, {
             get each() {
               return detailLines(row, rows(), now());
             },
             children: (line) => (() => {
-              var _el$21 = _$createElement("text"), _el$22 = _$createTextNode(`    `);
-              _$insertNode(_el$21, _el$22);
-              _$setProp(_el$21, "wrapMode", "none");
-              _$insert(_el$21, indent, _el$22);
-              _$insert(_el$21, line, null);
-              _$effect((_$p) => _$setProp(_el$21, "fg", theme.text.muted, _$p));
-              return _el$21;
+              var _el$23 = _$createElement("text"), _el$24 = _$createTextNode(`    `);
+              _$insertNode(_el$23, _el$24);
+              _$setProp(_el$23, "wrapMode", "none");
+              _$insert(_el$23, indent, _el$24);
+              _$insert(_el$23, line, null);
+              _$effect((_$p) => _$setProp(_el$23, "fg", theme.text.muted, _$p));
+              return _el$23;
             })()
           }), null);
           _$effect((_p$) => {
             var _v$3 = `courier-row-${index()}`, _v$4 = chosen() && input.focused ? theme.background.raised.high : undefined, _v$5 = rowColor(row), _v$6 = theme.text.muted;
-            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$16, "id", _v$3, _p$.e));
-            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$16, "backgroundColor", _v$4, _p$.t));
-            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$18, "fg", _v$5, _p$.a));
-            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$19, "fg", _v$6, _p$.o));
+            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$18, "id", _v$3, _p$.e));
+            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$18, "backgroundColor", _v$4, _p$.t));
+            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$20, "fg", _v$5, _p$.a));
+            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$21, "fg", _v$6, _p$.o));
             return _p$;
           }, {
             e: undefined,
@@ -1446,17 +1473,17 @@ function TreePanel(props) {
             a: undefined,
             o: undefined
           });
-          return _el$16;
+          return _el$18;
         })();
       }
     }));
-    _$insertNode(_el$14, _$createTextNode(`\u2191\u2193 select \xB7 enter open \xB7 s stop \xB7 x forget \xB7 r refresh \xB7 f fullscreen \xB7 q close`));
-    _$setProp(_el$14, "wrapMode", "none");
-    _$setProp(_el$14, "flexShrink", 0);
+    _$insertNode(_el$16, _$createTextNode(`\u2191\u2193 select \xB7 enter open \xB7 s stop \xB7 x forget \xB7 r refresh \xB7 f fullscreen \xB7 q close`));
+    _$setProp(_el$16, "wrapMode", "none");
+    _$setProp(_el$16, "flexShrink", 0);
     _$effect((_p$) => {
       var _v$ = theme.text.base, _v$2 = theme.text.muted;
       _v$ !== _p$.e && (_p$.e = _$setProp(_el$6, "fg", _v$, _p$.e));
-      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$14, "fg", _v$2, _p$.t));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$16, "fg", _v$2, _p$.t));
       return _p$;
     }, {
       e: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-courier",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Multi-session orchestration for OpenCode V2: spawn child sessions, be woken by them. No polling.",
   "license": "MIT",
   "author": "Ivo Pogace <71701666+ivopogace@users.noreply.github.com>",