opencode-courier 0.13.8 → 0.15.0

package/dist/memory/record.js

@@ -1,35 +1,24 @@
 import { finite, isNotFound, millis } from "../platform/json.js";
 import { contextOf, reportState, stalledAmong, subtree, turnIn, turnOf, waitsInInbox } from "../tree/index.js";
-import { isSettled, isStated, mergeParts, NOT_STATED, partStatus, replacingMention, revise, splitLinesOf, splitOf, unreadPart } from "./domain.js";
+import { isSettled, isStated, mergeParts, NOT_STATED, partStatus, subagentStatus, replacingMention, revise, splitLinesOf, splitOf, unreadPart } from "./domain.js";
 import { memoryStore } from "./store.js";
-/** A session's replies, in order, each with when it was created, for its split lines; only the `finished` ones when asked. */
 const repliesOf = (messages, finished) => messages.flatMap((message) => message.type === "assistant" && (!finished || message.time?.completed !== undefined)
     ? [{ text: message.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n"), at: finite(millis(message.time?.created)) }]
     : []);
-/** The lines in the replies that begin with `split:`, each with its reply's time. */
 const statedIn = (replies) => replies.flatMap(({ text, at }) => splitLinesOf(text).map((line) => (at === undefined ? { text: line } : { text: line, at })));
-/** How many courier_spawn calls of a session failed, refused by a limit mostly. */
 const refusedIn = (messages) => messages.reduce((n, message) => (message.type === "assistant" ? n + message.content.filter((part) => part.type === "tool" && part.name === "courier_spawn" && part.state.status === "error").length : n), 0);
-/** A part's context use and refused spawns, as its messages show them. */
 function useOf(messages, windows) {
     const context = contextOf(messages, windows);
     const refused = refusedIn(messages);
     return { ...(context !== undefined ? { context: Math.round(context * 100) / 100 } : {}), ...(refused ? { refused } : {}) };
 }
-/** A part's use as last recorded. */
 const keptUse = (last) => ({
     ...(last?.context !== undefined ? { context: last.context } : {}),
     ...(last?.refused ? { refused: last.refused } : {}),
 });
-/** A session's info, or `gone` when OpenCode no longer knows it; neither when it could not be read for another reason. */
 const infoOf = (ports, sessionID) => ports.session.get({ sessionID }).then((info) => ({ info, gone: false }), (error) => ({ gone: isNotFound(error) }));
-/**
- * One session of the tree as its record keeps it, without its use when its messages were not read for it (only when its turn
- * `ended` or it is `known` to no record yet), without a duration when its info was not, and whether it runs or is owed a turn.
- */
-async function part(ports, windows, { entry, depth }, stalled, at, known, ended) {
+async function part(ports, windows, { entry, depth, subagent }, stalled, at, known, ended) {
     const { sessionID } = entry;
-    // Read once: for its use, and for whether it runs when its times do not show rest.
     const readAt = Date.now();
     const messages = ended || !known ? ports.session.context({ sessionID }) : undefined;
     const [{ info, gone, running, endedAt }, use, report, waiting] = await Promise.all([
@@ -40,7 +29,7 @@ async function part(ports, windows, { entry, depth }, stalled, at, known, ended)
             return { ...one, ...(await turn) };
         }),
         messages?.then((read) => useOf(read, windows), () => undefined),
-        reportState(ports.storage, sessionID).catch(() => undefined),
+        subagent ? undefined : reportState(ports.storage, sessionID).catch(() => undefined),
         waitsInInbox(ports, sessionID).catch(() => true),
     ]);
     const created = finite(millis(info?.time.created)) ?? entry.createdAt;
@@ -51,31 +40,25 @@ async function part(ports, windows, { entry, depth }, stalled, at, known, ended)
         title: info?.title ?? entry.title,
         depth,
         isolated: entry.isolated,
+        ...(subagent ? { subagent } : {}),
         ...(entry.group ? { group: entry.group } : {}),
-        status: partStatus({ stopped: report?.stopped ?? false, stalled, report }),
+        status: subagent ? subagentStatus({ running, stalled, outcome: info?.outcome }) : partStatus({ stopped: report?.stopped ?? false, stalled, report }),
         ...(info ? { duration: Math.max(0, end - created) } : {}),
         ...(cost !== undefined ? { cost } : {}),
     };
-    // A courier message waiting to be taken keeps it unfinished, unless OpenCode no longer knows it, which then takes none.
     return { record, use, running: running || (waiting && !gone), unread: info === undefined, gone };
 }
-/** Of the parts last recorded, those the roster has forgotten before they settled whose session OpenCode no longer knows. */
 async function goneSince(ports, parts, onRoster) {
     const unsettled = parts.filter((one) => !onRoster.has(one.sessionID) && !isSettled(one.status));
     const looked = await Promise.all(unsettled.map(async ({ sessionID }) => ({ sessionID, ...(await infoOf(ports, sessionID)) })));
     return new Set(looked.flatMap((one) => (one.gone ? [one.sessionID] : [])));
 }
-/** The top's turn: from the transcript read at `readAt`, unless a stamp since then moved its times, which `turnOf` reads again. */
 async function topTurnAfter(ports, top, info, messages, readAt) {
     const fresh = await ports.session.get({ sessionID: top }).catch(() => undefined);
     if (fresh && millis(fresh.time.updated) > readAt)
         return turnOf(ports.session, top, fresh.time);
     return messages ? turnIn(ports.session, top, info.time, messages, readAt) : turnOf(ports.session, top, info.time);
 }
-/**
- * Writes the record of the tree under `top` as it stands at `at`, after the turn of `ended`; a part the roster has forgotten
- * keeps its last recorded state, unless found gone before it settled. Nothing for a top unknown to OpenCode or with memory off.
- */
 export async function refresh(ports, state, top, at, ended) {
     let info;
     try {
@@ -89,9 +72,7 @@ export async function refresh(ports, state, top, at, ended) {
     if (state.off.has(info.location.directory))
         return undefined;
     const store = memoryStore(ports.storage);
-    const [previous, { nodes }] = await Promise.all([store.get(info.projectID, top), subtree(ports.storage, top)]);
-    // The split lines are in the top's own replies, so only its own turn end can revise one stated already; another's reads
-    // them while none is stated, and only the replies finished, never a line the top is still writing.
+    const [previous, { nodes }] = await Promise.all([store.get(info.projectID, top), subtree(ports.storage, top, undefined, ports.session)]);
     const own = ended === top;
     const topReadAt = Date.now();
     const topMessages = own || !isStated(previous?.split ?? NOT_STATED) ? ports.session.context({ sessionID: top }) : undefined;
@@ -103,11 +84,8 @@ export async function refresh(ports, state, top, at, ended) {
         Promise.all(nodes.map((node) => part(ports, windows, node, stalled.has(node.entry.sessionID), at, known.has(node.entry.sessionID), node.entry.sessionID === ended))),
         goneSince(ports, previous?.parts ?? [], new Set(nodes.map((node) => node.entry.sessionID))),
     ]);
-    // A courier message waiting in the top's inbox is a turn its transcript does not show yet, as for a part; a store that
-    // cannot be read counts as one waiting, as `runs` counts a transcript it cannot read as running.
     const topTurn = topTurnAfter(ports, top, info, topMessages, topReadAt);
     const [said, topRunning, topOwed] = await Promise.all([replies, topTurn.then((turn) => turn.running), waitsInInbox(ports, top).catch(() => true)]);
-    // Read again just before the write: a courier_recall or courier_note call, or another turn end's refresh, wrote meanwhile.
     const latest = (await store.get(info.projectID, top).catch(() => previous)) ?? previous;
     const last = new Map(latest?.parts.map((one) => [one.sessionID, one]));
     const current = read.map(({ record, use, unread, gone }) => {
@@ -118,15 +96,14 @@ export async function refresh(ports, state, top, at, ended) {
     const parts = mergeParts(latest?.parts ?? [], [...current, ...forgotten]);
     const recalled = latest?.recalled ?? previous?.recalled;
     const lesson = latest?.lesson ?? previous?.lesson;
-    // The first stated line stays even when compaction has dropped its reply; a later one is a revision.
+    // the transcript starts at the last compaction (api-notes)
     const first = latest?.split ?? NOT_STATED;
     const found = splitOf(first, said.map((reply) => reply.text).join("\n"));
     const stated = statedIn(said);
     const replaced = found !== first;
     const { split, revisions: recorded } = replaced ? replacingMention(found, latest?.revisions) : { split: first, revisions: latest?.revisions };
-    // The line that replaced a mention is the first stated, so beside revisions already recorded it is not one of them too.
     const since = replaced && recorded ? stated.slice(1) : stated;
-    const revisions = split === NOT_STATED ? undefined : revise({ split, revisions: recorded }, since, at, parts.length);
+    const revisions = split === NOT_STATED ? undefined : revise({ split, revisions: recorded }, since, at, parts.filter((one) => !one.subagent).length);
     const record = {
         startedAt: finite(millis(info.time.created)) ?? previous?.startedAt ?? at,
         movedAt: at,

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

@@ -1,14 +1,8 @@
 import type { Plugin } from "@opencode/plugin";
 import type { MemoryPorts } from "./ports.js";
 import { type Records } from "./rpc.js";
-/** What the memory's RPC runs on: one instance's ports. */
 export type MemoryRpcPorts = Pick<MemoryPorts, "storage" | "projectID" | "memory" | "now">;
-/**
- * The records of the ports' project, pinned first and then newest first, as the memory view lists them; nothing, and
- * `memory` false, with the option off. Read from the store alone: unlike courier_recall, a look from the terminal is noted on no record.
- */
 export declare function records(ports: Pick<MemoryRpcPorts, "storage" | "projectID" | "memory">): Promise<Records>;
-/** Serves the memory's RPC at the plugin's location, after the tree's and the person's; disposed with the plugin. */
 export declare function registerMemoryRpc(rpc: Pick<Plugin.Context["rpc"], "register">, ports: MemoryRpcPorts): Promise<import("@opencode/plugin/promise/rpc").RpcRegistration<{
     readonly id: "courier-memory";
     readonly methods: {
@@ -32,6 +26,7 @@ export declare function registerMemoryRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                         readonly depth: number;
                         readonly context?: number | undefined;
                         readonly group?: string | undefined;
+                        readonly subagent?: boolean | undefined;
                         readonly cost?: number | undefined;
                         readonly refused?: number | undefined;
                         readonly duration?: number | undefined;
@@ -72,6 +67,7 @@ export declare function registerMemoryRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                         readonly depth: number;
                         readonly context?: number | undefined;
                         readonly group?: string | undefined;
+                        readonly subagent?: boolean | undefined;
                         readonly cost?: number | undefined;
                         readonly refused?: number | undefined;
                         readonly duration?: number | undefined;
@@ -126,6 +122,7 @@ export declare function registerMemoryRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                         readonly title: import("effect/Schema").String;
                         readonly depth: import("effect/Schema").Int;
                         readonly isolated: import("effect/Schema").Boolean;
+                        readonly subagent: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
                         readonly group: import("effect/Schema").optionalKey<import("effect/Schema").String>;
                         readonly status: import("effect/Schema").Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
                         readonly duration: import("effect/Schema").optionalKey<import("effect/Schema").Number>;

package/dist/memory/rpc-handlers.js

@@ -3,19 +3,13 @@ import { forget } from "./forget.js";
 import { pin } from "./pin.js";
 import { memoryRpc } from "./rpc.js";
 import { memoryStore } from "./store.js";
-/** A stored record as the RPC gives it: without its project, which the listing names once, nor the split line's revisions, which its schema lacks. */
 const toRecord = ({ projectID: _project, revisions: _revisions, ...record }) => record;
-/**
- * The records of the ports' project, pinned first and then newest first, as the memory view lists them; nothing, and
- * `memory` false, with the option off. Read from the store alone: unlike courier_recall, a look from the terminal is noted on no record.
- */
 export async function records(ports) {
     const { projectID } = ports;
     if (!ports.memory)
         return { memory: false, projectID, records: [] };
     return { memory: true, projectID, records: pinnedFirst(await memoryStore(ports.storage).ofProject(projectID)).map(toRecord) };
 }
-/** Serves the memory's RPC at the plugin's location, after the tree's and the person's; disposed with the plugin. */
 export function registerMemoryRpc(rpc, ports) {
     return rpc.register(memoryRpc, {
         records: () => records(ports),

package/dist/memory/rpc.d.ts

@@ -1,13 +1,11 @@
 import { Schema } from "effect";
-/** A part's statuses, as `memory/domain.ts`'s `PART_STATUSES` has them; a unit test keeps the two equal. */
 export declare const PART_STATUSES: readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"];
-/** One session started in a tree, as its record keeps it: durations in milliseconds, context use a share of the model's window. */
 declare const Part: Schema.Struct<{
     readonly sessionID: Schema.String;
     readonly title: Schema.String;
-    /** 1 for a session the top started. */
     readonly depth: Schema.Int;
     readonly isolated: Schema.Boolean;
+    readonly subagent: Schema.optionalKey<Schema.Boolean>;
     readonly group: Schema.optionalKey<Schema.String>;
     readonly status: Schema.Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
     readonly duration: Schema.optionalKey<Schema.Number>;
@@ -15,13 +13,11 @@ declare const Part: Schema.Struct<{
     readonly context: Schema.optionalKey<Schema.Number>;
     readonly refused: Schema.optionalKey<Schema.Int>;
 }>;
-/** The one line the tree's orchestrator wrote with courier_note: when, and from which depth when not the top's own. */
 declare const Lesson: Schema.Struct<{
     readonly text: Schema.String;
     readonly at: Schema.Number;
     readonly depth: Schema.optionalKey<Schema.Int>;
 }>;
-/** A tree's record as `courier_recall` reads it, with the top session it is kept under; times in epoch milliseconds. */
 declare const Record: Schema.Struct<{
     readonly sessionID: Schema.String;
     readonly startedAt: Schema.Number;
@@ -38,22 +34,20 @@ declare const Record: Schema.Struct<{
         readonly at: Schema.Number;
         readonly depth: Schema.optionalKey<Schema.Int>;
     }>>;
-    /** How often other trees' courier_recall calls listed the record and gave it in full, and when one last did. */
     readonly reads: Schema.optionalKey<Schema.Struct<{
         readonly shown: Schema.Int;
         readonly read: Schema.Int;
         readonly at: Schema.Number;
     }>>;
-    /** The person's pin, when; a pinned record is listed first and never swept. */
     readonly pinned: Schema.optionalKey<Schema.Struct<{
         readonly at: Schema.Number;
     }>>;
     readonly parts: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
         readonly title: Schema.String;
-        /** 1 for a session the top started. */
         readonly depth: Schema.Int;
         readonly isolated: Schema.Boolean;
+        readonly subagent: Schema.optionalKey<Schema.Boolean>;
         readonly group: Schema.optionalKey<Schema.String>;
         readonly status: Schema.Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
         readonly duration: Schema.optionalKey<Schema.Number>;
@@ -62,7 +56,6 @@ declare const Record: Schema.Struct<{
         readonly refused: Schema.optionalKey<Schema.Int>;
     }>>;
 }>;
-/** The records of the project of the location asked, pinned first and then newest first; none, and `memory` false, when the option is off there. */
 declare const Records: Schema.Struct<{
     readonly memory: Schema.Boolean;
     readonly projectID: Schema.String;
@@ -82,22 +75,20 @@ declare const Records: Schema.Struct<{
             readonly at: Schema.Number;
             readonly depth: Schema.optionalKey<Schema.Int>;
         }>>;
-        /** How often other trees' courier_recall calls listed the record and gave it in full, and when one last did. */
         readonly reads: Schema.optionalKey<Schema.Struct<{
             readonly shown: Schema.Int;
             readonly read: Schema.Int;
             readonly at: Schema.Number;
         }>>;
-        /** The person's pin, when; a pinned record is listed first and never swept. */
         readonly pinned: Schema.optionalKey<Schema.Struct<{
             readonly at: Schema.Number;
         }>>;
         readonly parts: Schema.$Array<Schema.Struct<{
             readonly sessionID: Schema.String;
             readonly title: Schema.String;
-            /** 1 for a session the top started. */
             readonly depth: Schema.Int;
             readonly isolated: Schema.Boolean;
+            readonly subagent: Schema.optionalKey<Schema.Boolean>;
             readonly group: Schema.optionalKey<Schema.String>;
             readonly status: Schema.Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
             readonly duration: Schema.optionalKey<Schema.Number>;
@@ -107,11 +98,9 @@ declare const Records: Schema.Struct<{
         }>>;
     }>>;
 }>;
-/** What a forget did: removed the record, dropped only its lesson, or found nothing to forget. */
 declare const Forgotten: Schema.Struct<{
     readonly outcome: Schema.Literals<readonly ["record", "lesson", "none"]>;
 }>;
-/** What a pin did: pinned the record, unpinned it, or found no record to pin. */
 declare const Pinned: Schema.Struct<{
     readonly outcome: Schema.Literals<readonly ["pinned", "unpinned", "none"]>;
 }>;
@@ -139,6 +128,7 @@ export declare const memoryRpc: {
                         readonly title: string;
                         readonly depth: number;
                         readonly isolated: boolean;
+                        readonly subagent?: boolean | undefined;
                         readonly group?: string | undefined;
                         readonly duration?: number | undefined;
                         readonly cost?: number | undefined;
@@ -179,6 +169,7 @@ export declare const memoryRpc: {
                         readonly title: string;
                         readonly depth: number;
                         readonly isolated: boolean;
+                        readonly subagent?: boolean | undefined;
                         readonly group?: string | undefined;
                         readonly duration?: number | undefined;
                         readonly cost?: number | undefined;
@@ -226,22 +217,20 @@ export declare const memoryRpc: {
                         readonly at: Schema.Number;
                         readonly depth: Schema.optionalKey<Schema.Int>;
                     }>>;
-                    /** How often other trees' courier_recall calls listed the record and gave it in full, and when one last did. */
                     readonly reads: Schema.optionalKey<Schema.Struct<{
                         readonly shown: Schema.Int;
                         readonly read: Schema.Int;
                         readonly at: Schema.Number;
                     }>>;
-                    /** The person's pin, when; a pinned record is listed first and never swept. */
                     readonly pinned: Schema.optionalKey<Schema.Struct<{
                         readonly at: Schema.Number;
                     }>>;
                     readonly parts: Schema.$Array<Schema.Struct<{
                         readonly sessionID: Schema.String;
                         readonly title: Schema.String;
-                        /** 1 for a session the top started. */
                         readonly depth: Schema.Int;
                         readonly isolated: Schema.Boolean;
+                        readonly subagent: Schema.optionalKey<Schema.Boolean>;
                         readonly group: Schema.optionalKey<Schema.String>;
                         readonly status: Schema.Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
                         readonly duration: Schema.optionalKey<Schema.Number>;
@@ -252,7 +241,6 @@ export declare const memoryRpc: {
                 }>>;
             }>;
         };
-        /** Forgets the record of the tree under `sessionID` in the project asked, or with `lesson` only its lesson, keeping the facts. */
         readonly forget: {
             readonly input: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly sessionID: string;
@@ -272,7 +260,6 @@ export declare const memoryRpc: {
                 readonly outcome: Schema.Literals<readonly ["record", "lesson", "none"]>;
             }>;
         };
-        /** Pins the record of the tree under `sessionID` in the project asked, or with `pinned` false unpins it. */
         readonly pin: {
             readonly input: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly sessionID: string;

package/dist/memory/rpc.js

@@ -1,19 +1,13 @@
-/**
- * The memory's RPC, the contract its TUI part, the memory view, and its server half share. Standard Schema values, as
- * the tree's and the person's; imports only `@opencode/plugin/rpc` and `effect`.
- */
 import { Rpc } from "@opencode/plugin/rpc";
 import { Schema } from "effect";
 const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-/** A part's statuses, as `memory/domain.ts`'s `PART_STATUSES` has them; a unit test keeps the two equal. */
 export const PART_STATUSES = ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"];
-/** One session started in a tree, as its record keeps it: durations in milliseconds, context use a share of the model's window. */
 const Part = Schema.Struct({
     sessionID: Schema.String,
     title: Schema.String,
-    /** 1 for a session the top started. */
     depth: Count,
     isolated: Schema.Boolean,
+    subagent: Schema.optionalKey(Schema.Boolean),
     group: Schema.optionalKey(Schema.String),
     status: Schema.Literals(PART_STATUSES),
     duration: Schema.optionalKey(Schema.Number),
@@ -21,9 +15,7 @@ const Part = Schema.Struct({
     context: Schema.optionalKey(Schema.Number),
     refused: Schema.optionalKey(Count),
 });
-/** The one line the tree's orchestrator wrote with courier_note: when, and from which depth when not the top's own. */
 const Lesson = Schema.Struct({ text: Schema.String, at: Schema.Number, depth: Schema.optionalKey(Count) });
-/** A tree's record as `courier_recall` reads it, with the top session it is kept under; times in epoch milliseconds. */
 const Record = Schema.Struct({
     sessionID: Schema.String,
     startedAt: Schema.Number,
@@ -33,21 +25,16 @@ const Record = Schema.Struct({
     finished: Schema.Boolean,
     recalled: Schema.optionalKey(Schema.Struct({ at: Schema.optionalKey(Schema.Number), calls: Count })),
     lesson: Schema.optionalKey(Lesson),
-    /** How often other trees' courier_recall calls listed the record and gave it in full, and when one last did. */
     reads: Schema.optionalKey(Schema.Struct({ shown: Count, read: Count, at: Schema.Number })),
-    /** The person's pin, when; a pinned record is listed first and never swept. */
     pinned: Schema.optionalKey(Schema.Struct({ at: Schema.Number })),
     parts: Schema.Array(Part),
 });
-/** The records of the project of the location asked, pinned first and then newest first; none, and `memory` false, when the option is off there. */
 const Records = Schema.Struct({
     memory: Schema.Boolean,
     projectID: Schema.String,
     records: Schema.Array(Record),
 });
-/** What a forget did: removed the record, dropped only its lesson, or found nothing to forget. */
 const Forgotten = Schema.Struct({ outcome: Schema.Literals(["record", "lesson", "none"]) });
-/** What a pin did: pinned the record, unpinned it, or found no record to pin. */
 const Pinned = Schema.Struct({ outcome: Schema.Literals(["pinned", "unpinned", "none"]) });
 export const memoryRpc = Rpc.define({
     id: "courier-memory",
@@ -56,12 +43,10 @@ export const memoryRpc = Rpc.define({
             input: Schema.toStandardSchemaV1(Schema.Struct({})),
             output: Schema.toStandardSchemaV1(Records),
         },
-        /** Forgets the record of the tree under `sessionID` in the project asked, or with `lesson` only its lesson, keeping the facts. */
         forget: {
             input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, lesson: Schema.optionalKey(Schema.Boolean) })),
             output: Schema.toStandardSchemaV1(Forgotten),
         },
-        /** Pins the record of the tree under `sessionID` in the project asked, or with `pinned` false unpins it. */
         pin: {
             input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, pinned: Schema.Boolean })),
             output: Schema.toStandardSchemaV1(Pinned),

package/dist/memory/store.d.ts

@@ -2,13 +2,8 @@ import { type Storage } from "../platform/storage.js";
 import { type TreeRecord } from "./domain.js";
 import type { MemoryStore } from "./ports.js";
 export declare const recordKey: (projectID: string, sessionID: string) => string;
-/** The key prefix of a project's records. */
 export declare const projectPrefix: (projectID: string) => string;
-/** The person's pin on a record, `{ at }`; the key's presence pins. */
 export declare const pinKey: (projectID: string, sessionID: string) => string;
-/** The reads of a record by the tree under `by`, `{ shown, read, at }`, written only by that tree's sessions. */
 export declare const readsKey: (projectID: string, sessionID: string, by: string) => string;
-/** A record as stored, or undefined for a value that is not one; its reads and pin lie beside it (`beside`). */
 export declare function readRecord(value: unknown): TreeRecord | undefined;
-/** The `MemoryStore` over the plugin's storage. */
 export declare function memoryStore(storage: Storage): MemoryStore;

package/dist/memory/store.js

@@ -1,17 +1,11 @@
 import { finite, num, obj, str } from "../platform/json.js";
 import { scanEntries } from "../platform/storage.js";
 import { isPartStatus, lessonText, MAX_REVISIONS, NOT_STATED, noteRead, sumReads, } from "./domain.js";
-// The memory's storage: the only file that knows its keys and layout. A record is read leniently, as one written by hand
-// with `e2e/kv.ts set` is; beside it, under its key and each with its own writer, lie the person's pin and each reader tree's reads.
 const PREFIX = "memory/";
 export const recordKey = (projectID, sessionID) => `${PREFIX}${projectID}/${sessionID}`;
-/** The key prefix of a project's records. */
 export const projectPrefix = (projectID) => `${PREFIX}${projectID}/`;
-/** The key prefix of what lies beside a record: its pin and its reads. */
 const besidePrefix = (projectID, sessionID) => `${recordKey(projectID, sessionID)}/`;
-/** The person's pin on a record, `{ at }`; the key's presence pins. */
 export const pinKey = (projectID, sessionID) => `${besidePrefix(projectID, sessionID)}pin`;
-/** The reads of a record by the tree under `by`, `{ shown, read, at }`, written only by that tree's sessions. */
 export const readsKey = (projectID, sessionID, by) => `${besidePrefix(projectID, sessionID)}reads/${by}`;
 function readPart(value) {
     const given = obj(value);
@@ -28,6 +22,7 @@ function readPart(value) {
         title: str(given.title) ?? "",
         depth: num(given.depth) ?? 1,
         isolated: given.isolated === true,
+        ...(given.subagent === true ? { subagent: true } : {}),
         ...(group ? { group } : {}),
         status: isPartStatus(given.status) ? given.status : "out",
         ...optional("duration"),
@@ -44,7 +39,6 @@ function readRecalled(value) {
     const at = num(given.at);
     return at === undefined ? { calls } : { at, calls };
 }
-/** A lesson as `{ text, at, depth }`, or as a bare string written by hand, dated `movedAt`; none for an empty text. */
 function readLesson(value, movedAt) {
     const given = typeof value === "string" ? { text: value } : obj(value);
     const { text } = lessonText(str(given.text) ?? "");
@@ -53,7 +47,6 @@ function readLesson(value, movedAt) {
     const depth = num(given.depth);
     return { text, at: num(given.at) ?? movedAt, ...(depth !== undefined && Number.isInteger(depth) && depth > 0 ? { depth } : {}) };
 }
-/** The revisions as `{ text, at, parts }`, the newest `MAX_REVISIONS`, leaving out an entry without a text, a time or a count of parts. */
 function readRevisions(value) {
     if (!Array.isArray(value))
         return [];
@@ -66,7 +59,6 @@ function readRevisions(value) {
     });
     return revisions.slice(-MAX_REVISIONS);
 }
-/** A record as stored, or undefined for a value that is not one; its reads and pin lie beside it (`beside`). */
 export function readRecord(value) {
     const given = obj(value);
     if (!Array.isArray(given.parts))
@@ -87,7 +79,6 @@ export function readRecord(value) {
         parts: given.parts.map(readPart).filter((part) => part !== undefined),
     };
 }
-/** One tree's reads as `{ shown, read, at }`; a count missing is 0, an entry without a time is none. */
 function readReads(value) {
     const given = obj(value);
     const at = num(given.at);
@@ -96,17 +87,13 @@ function readReads(value) {
     const count = (field) => Math.max(0, Math.floor(num(given[field]) ?? 0));
     return { shown: count("shown"), read: count("read"), at };
 }
-/** The pin as `{ at }`: any value under the key pins, dated 0 when it says no time. */
 const readPinned = (value) => ({ at: num(obj(value).at) ?? 0 });
-/** A record with what lies beside it: its readers' reads as one, and its pin. */
 function beside(record, { pinned, reads }) {
     const { parts, ...facts } = record;
     const summed = sumReads(reads);
     return { ...facts, ...(summed ? { reads: summed } : {}), ...(pinned ? { pinned } : {}), parts };
 }
-/** The key's path under `memory/`, split: `[projectID, sessionID]` a record, then `pin`, or `reads` and the reader. */
 const pathOf = (prefix, key) => `${prefix.slice(PREFIX.length)}${key}`.split("/");
-/** Sorts a scan's entries by record: the record's value, when the scan held it, and what lies beside it. */
 function group(prefix, entries) {
     const groups = new Map();
     const of = (projectID, sessionID) => {
@@ -134,7 +121,6 @@ function group(prefix, entries) {
         return { projectID, sessionID, ...found };
     });
 }
-/** The `MemoryStore` over the plugin's storage. */
 export function memoryStore(storage) {
     const scanned = async (prefix) => group(prefix, await scanEntries(storage, prefix));
     const under = async (prefix) => (await scanned(prefix)).flatMap(({ projectID, sessionID, record: value, beside: others }) => {
@@ -147,7 +133,6 @@ export function memoryStore(storage) {
             const record = readRecord(value);
             return record && beside(record, others[0]?.beside ?? { reads: [] });
         },
-        // What lies beside the record is never written with it, so no refresh or note can write over a pin or a count.
         async put(projectID, sessionID, { reads: _reads, pinned: _pinned, ...record }) {
             await storage.set(recordKey(projectID, sessionID), { ...record, parts: record.parts.map((part) => ({ ...part })) });
         },

package/dist/memory/sweep.d.ts

@@ -1,7 +1,3 @@
 import type { Storage } from "../platform/storage.js";
 import { type StoredRecord } from "./domain.js";
-/**
- * On loading: drops, per project, the records `keep` does not at `now`, the pinned never among them, and the reads or
- * pin left beside a record removed meanwhile. Returns the records dropped.
- */
 export declare function sweepRecords(storage: Storage, now: number): Promise<StoredRecord[]>;

package/dist/memory/sweep.js

@@ -1,9 +1,5 @@
 import { keep } from "./domain.js";
 import { memoryStore } from "./store.js";
-/**
- * On loading: drops, per project, the records `keep` does not at `now`, the pinned never among them, and the reads or
- * pin left beside a record removed meanwhile. Returns the records dropped.
- */
 export async function sweepRecords(storage, now) {
     const store = memoryStore(storage);
     const byProject = new Map();

package/dist/memory/text.d.ts

@@ -1,46 +1,21 @@
 import { type Lesson, type StoredRecord } from "./domain.js";
-/** The tool's name, which the skill and the role part name too. */
 export declare const RECALL_TOOL = "courier_recall";
-/** The lesson tool's name, which the skill's last step names. */
 export declare const NOTE_TOOL = "courier_note";
-/** A duration in milliseconds as a model reads it: seconds under half a minute, else whole minutes, else hours and minutes. */
 export declare function duration(ms: number): string;
-/** How long ago a record last moved: a duration under a day, else whole days, which a record kept for months is read in. */
 export declare function age(ms: number): string;
-/** A lesson as the listing and the note's result show it: dated, and from which depth when a session below the top wrote it. */
 export declare function lessonLine(lesson: Lesson): string;
-/**
- * One record as the listing shows it: its top, when it started, its title, its split line and its latest revision as prose,
- * its parts, how long it ran, how long ago it last moved, what it cost, and whether the person pinned it.
- */
 export declare function recordLine(record: StoredRecord, top: string, now: number): string;
-/** What courier_recall says when the memory option is off. */
 export declare const RECALL_OFF = "Memory is off: the plugin's memory option is false, so no record of a session tree is kept or listed in this project. Decide from the task alone.";
-/**
- * The listing: every record of the project, the pinned first and then newest first, the caller's own tree marked, each
- * aged against `now`.
- */
 export declare function recallListText(records: ReadonlyArray<StoredRecord>, top: string, now: number): string;
-/** One record in full, as JSON: durations in milliseconds, times in epoch milliseconds, context use as a share of the model's window. */
 export declare function recallRecordText(record: StoredRecord): string;
 export declare const recallMissingText: (sessionID: string) => string;
-/** What courier_note says once the lesson is written: where, and what it replaced. */
 export declare function noteText(top: string, lesson: Lesson, replaced: Lesson | undefined): string;
-/** What courier_note says when the memory option is off. */
 export declare const NOTE_OFF = "Not noted: the plugin's memory option is false, so no record of a session tree is kept in this project to write a lesson on.";
-export declare const noteLeafRefusal: (depth: number, maxDepth: number) => string;
+export declare const noteBelowRefusal: (depth: number, top: string) => string;
 export declare const NOTE_EMPTY = "Not noted: text is empty. Write one line, what the next orchestrator in this project should know about running a tree like this one, with the job it comes from and the reason, or nothing.";
-/** The refusal of a lesson longer than `LESSON_MAX` as one line: nothing is written, and the earlier lesson stays. */
 export declare const noteLongRefusal: (length: number) => string;
 export declare const noteUnrecordedRefusal: (top: string) => string;
-/** The key of the session instruction entry carrying the project's lessons, `<context key="lessons">`. */
 export declare const LESSONS_KEY = "lessons";
-/** How every lessons entry begins. */
 export declare const LESSONS_PREFIX = "opencode-courier lessons:";
-/** How many lessons the entry carries: the records' order, pinned first, then newest first. */
 export declare const LESSONS_MAX = 5;
-/**
- * The lessons entry: the lessons of the project's records as courier_recall lists them, pinned first and then newest first,
- * at most `LESSONS_MAX`, each with its tree's title; undefined while no record holds one.
- */
 export declare function lessonsEntry(records: ReadonlyArray<StoredRecord>): string | undefined;