antechamber 0.2.37 → 1.0.1

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.1] - 2026-10-20
+
+### Added
+
+- OmO Work, an OpenChamber 2.x Work Status section (`extensions/omo-work`). For the open session it
+  shows OmO's todo list by phase, terminal monitors with their matched lines, detached eval cells
+  (output peek and Stop), background terminal sessions and the goal continuation timer (Fire now).
+  Its service reaches antechamber through new `/antechamber/work-status` routes, authenticated by a
+  token `serve` writes into its run record.
+
+### Changed
+
+- On OpenChamber 2.x, OmO monitors are no longer listed as subagent sessions; the OmO Work section
+  shows them. OpenChamber 1.24 still sees them as child sessions.
+
+## [1.0.0] - 2026-10-20
+
+- First stable release. No functional changes since 0.2.37.
+
 ## [0.2.37] - 2026-10-20
 
 - fix(questions): drop optional comment field that OpenChamber 2.4 makes mandatory (#45)

package/README.md

@@ -40,6 +40,9 @@ an **external OpenCode server** and sessions run on OmO.
 - An optional OpenChamber extension, **OmO Graph**, that draws the OmO
   sub-agents behind the open session as a live, clickable graph (see
   [OpenChamber extension](#openchamber-extension-omo-graph)).
+- An optional OpenChamber 2.x Work Status section, **OmO Work**, for the
+  session's todo phases, monitors, eval cells and background work (see
+  [OmO Work](#openchamber-extension-omo-work)).
 
 ## Supported backends
 
@@ -234,6 +237,24 @@ OpenChamber clones the repository root, which is antechamber itself, not the
 extension, and refuses it as an invalid manifest. Details:
 [extensions/omo-dag/README.md](extensions/omo-dag/README.md).
 
+## OpenChamber extension: OmO Work
+
+`extensions/omo-work` adds an **OmO Work** section to OpenChamber 2.x's Work
+Status panel (OpenChamber 2.3.2 or newer; 1.x has no extension sections). For
+the open session it shows the OmO todo list grouped by phase, terminal
+monitors with their matched lines, detached eval cells with their output and a
+Stop button, background terminal sessions, and the goal continuation timer
+with a Fire now button. On 2.x, monitors appear here instead of as subagent
+sessions.
+
+Add it like OmO Graph: the folder `antechamber setup` prints
+(`.../extensions/omo-work`, built by `npm run build`), or
+`https://github.com/eliottness/antechamber/releases/latest/download/antechamber-omo-work.zip`.
+Approve its local service. It needs an antechamber version that writes a
+work-status token into its run record (this release or newer) and an
+OpenChamber restart after upgrading. Details:
+[extensions/omo-work/README.md](extensions/omo-work/README.md).
+
 ## OpenChamber extension: OmO Compatibility
 
 `extensions/omo-compat` is a second, code-free extension for OpenChamber 1.24

package/dist/commands/serve.js

@@ -28,10 +28,16 @@ export async function serve(options) {
     process.on("SIGTERM", shutdown);
     await server.start();
     try {
-        forget = recordRunningServer(envSetting("STATE_DIR") ?? defaultStateDir(homedir(), fs.existsSync), { pid: process.pid, version: ADAPTER_VERSION, url: server.url, started: new Date().toISOString() }, fs);
+        forget = recordRunningServer(envSetting("STATE_DIR") ?? defaultStateDir(homedir(), fs.existsSync), {
+            pid: process.pid,
+            version: ADAPTER_VERSION,
+            url: server.url,
+            started: new Date().toISOString(),
+            token: server.extensionToken,
+        }, fs);
     }
     catch (error) {
-        // Only doctor reads the record; serving must not depend on it.
+        // Doctor and the OmO Work extension read the record; serving must not depend on it.
         console.error(`antechamber: cannot record the running version: ${error instanceof Error ? error.message : String(error)}`);
     }
     if (compatible)

package/dist/commands/setup.js

@@ -18,6 +18,12 @@ function omoGraphExtensionDir(ctx) {
     const built = ["package.json", "panel/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
     return built ? dir : undefined;
 }
+/** The bundled OmO Work status-section extension folder, when this installation has its built files. */
+function omoWorkExtensionDir(ctx) {
+    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-work");
+    const built = ["package.json", "status/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
+    return built ? dir : undefined;
+}
 /** The bundled OmO Compatibility extension folder; it is a manifest only, so it needs no build. */
 function omoCompatExtensionDir(ctx) {
     const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-compat");
@@ -179,6 +185,10 @@ export function setup(options, ctx = createContext()) {
     if (extension !== undefined) {
         report(`Optional OmO Graph extension: in OpenChamber, Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${extension}`);
     }
+    const work = omoWorkExtensionDir(ctx);
+    if (work !== undefined) {
+        report(`Optional OmO Work section (todo phases, monitors, eval cells; OpenChamber 2.x): Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${work}`);
+    }
     const compat = omoCompatExtensionDir(ctx);
     if (compat !== undefined) {
         report(`Optional OmO Compatibility extension (eval card headers): Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${compat}`);

package/dist/http.d.ts

@@ -13,11 +13,14 @@ export declare function errorBody(name: string, message: string): {
     };
 };
 export declare function json(res: ServerResponse, status: number, body: unknown): void;
+/** Routes the OmO Work extension service calls with the run-record token instead of the server password. */
+export declare const EXTENSION_ROUTE_PREFIX = "/antechamber/work-status/";
 export declare class Http {
     private serverOrigin?;
     private readonly credentials;
     private readonly maxBodyBytes;
-    constructor(serverOrigin?: (() => string) | undefined);
+    private readonly extensionToken;
+    constructor(serverOrigin?: (() => string) | undefined, extensionToken?: string);
     allowsUpgrade(req: IncomingMessage): boolean;
     route(req: IncomingMessage, res: ServerResponse, handle: () => Promise<void>): Promise<void>;
     body(req: IncomingMessage): Promise<unknown>;

package/dist/http.js

@@ -45,12 +45,17 @@ export function json(res, status, body) {
     const payload = JSON.stringify(body);
     res.writeHead(status, { "Content-Type": "application/json" }).end(payload);
 }
+/** Routes the OmO Work extension service calls with the run-record token instead of the server password. */
+export const EXTENSION_ROUTE_PREFIX = "/antechamber/work-status/";
 export class Http {
     serverOrigin;
     credentials;
     maxBodyBytes;
-    constructor(serverOrigin) {
+    extensionToken;
+    constructor(serverOrigin, extensionToken) {
         this.serverOrigin = serverOrigin;
+        this.extensionToken =
+            extensionToken === undefined ? undefined : createHash("sha256").update(`Bearer ${extensionToken}`).digest();
         const maxBodyBytes = Number(envSetting("MAX_BODY_BYTES"));
         this.maxBodyBytes = Number.isSafeInteger(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
         const password = serverPassword();
@@ -182,6 +187,14 @@ export class Http {
     authorized(req) {
         if (this.credentials === undefined)
             return true;
+        if (this.extensionToken !== undefined && // The router resolves dot segments, %2e and backslashes, so the check must see the same path.
+            new URL(req.url ?? "/", "http://localhost").pathname.startsWith(EXTENSION_ROUTE_PREFIX)) {
+            const supplied = createHash("sha256")
+                .update(req.headers.authorization ?? "")
+                .digest();
+            if (timingSafeEqual(this.extensionToken, supplied))
+                return true;
+        }
         const match = req.headers.authorization?.match(/^Basic\s+([A-Za-z0-9+/]+=*)$/i);
         const supplied = createHash("sha256")
             .update(Buffer.from(match?.[1] ?? "", "base64"))

package/dist/monitor-sessions.d.ts

@@ -17,11 +17,19 @@ export interface MonitorSnapshot {
     fireCount: number;
     lastFiredAtMs: number | null;
 }
-interface MonitorEnding {
+export interface MonitorEnding {
     reason: string;
     exitCode: number | null;
     endedAtMs: number;
 }
+/** One watch of a parent, for the Work Status section. */
+export interface MonitorView {
+    monitor: MonitorSnapshot;
+    ending?: MonitorEnding & {
+        label: string;
+    };
+    lines: string[];
+}
 export declare function parseMonitor(value: unknown): MonitorSnapshot | undefined;
 export declare function monitorSummary(monitor: MonitorSnapshot, ending?: MonitorEnding): string;
 export declare class MonitorSessions {
@@ -33,6 +41,8 @@ export declare class MonitorSessions {
     constructor(sessions: Map<string, ManagedSession>, emit: (directory: string, event: OCEvent) => void);
     wire(parent: ManagedSession): void;
     owns(id: string): boolean;
+    /** A parent's watches, live first then the newest ended ones, with their latest matched lines. */
+    list(parentID: string, maxEnded: number, maxLines: number): MonitorView[];
     messages(id: string): OCMessageWithParts[];
     observe(parent: ManagedSession, ev: Record<string, unknown>): void;
     /** A hidden `senpi-monitor:notification` custom message: append its lines to each watch it names. */
@@ -55,4 +65,3 @@ export declare class MonitorSessions {
     private create;
     private publish;
 }
-export {};

package/dist/monitor-sessions.js

@@ -88,6 +88,20 @@ export class MonitorSessions {
     owns(id) {
         return this.watches.has(id);
     }
+    /** A parent's watches, live first then the newest ended ones, with their latest matched lines. */
+    list(parentID, maxEnded, maxLines) {
+        const watches = [...this.watches.values()].filter((watch) => watch.session.info.parentID === parentID);
+        const live = watches.filter((watch) => watch.ending === undefined);
+        const ended = watches
+            .filter((watch) => watch.ending !== undefined)
+            .sort((a, b) => (b.ending?.endedAtMs ?? 0) - (a.ending?.endedAtMs ?? 0))
+            .slice(0, maxEnded);
+        return [...live.sort((a, b) => b.monitor.startedAtMs - a.monitor.startedAtMs), ...ended].map(({ monitor, ending, lines }) => ({
+            monitor: { ...monitor },
+            ...(ending ? { ending: { ...ending, label: endingLabel(ending) } } : {}),
+            lines: lines.slice(-maxLines),
+        }));
+    }
     messages(id) {
         return this.watches.get(id)?.session.messages ?? [];
     }
@@ -151,12 +165,13 @@ export class MonitorSessions {
         for (const [childID, watch] of this.watches) {
             if (childID !== id && watch.session.info.parentID !== id)
                 continue;
+            // Emitted while the watch is still owned, so the v2 stream keeps hiding it.
+            if (this.sessions.get(childID) === watch.session) {
+                this.emit(watch.session.info.directory, { type: "session.deleted", properties: { info: watch.session.info } });
+                this.sessions.delete(childID);
+            }
             this.watches.delete(childID);
             this.dismissed.add(childID);
-            if (this.sessions.get(childID) !== watch.session)
-                continue;
-            this.sessions.delete(childID);
-            this.emit(watch.session.info.directory, { type: "session.deleted", properties: { info: watch.session.info } });
         }
     }
     running(parentID) {

package/dist/pi-event-translation.d.ts

@@ -4,6 +4,7 @@ import type { ManagedSession } from "./sessions.js";
 import type { SessionStore } from "./session-store.js";
 import { type SubagentBridge } from "./subagents.js";
 import { type MonitorSessions } from "./monitor-sessions.js";
+import type { WorkStatusBridge } from "./work-status.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
     input?: number;
@@ -40,6 +41,7 @@ interface PiEventServices {
     readonly emit: (directory: string, event: OCEvent | TodoUpdated) => void;
     readonly subagents: SubagentBridge;
     readonly monitors: MonitorSessions;
+    readonly workStatus: Pick<WorkStatusBridge, "observe">;
     readonly store: Pick<SessionStore, "update">;
     readonly dirtyDiffs: Set<string>;
     readonly ensureMessages: (s: ManagedSession) => OCMessageWithParts[];

package/dist/pi-event-translation.js

@@ -311,6 +311,7 @@ export class PiEventTranslator {
             case "extension_event":
                 this.services.monitors.observe(s, ev);
                 this.services.subagents.observe(s, ev);
+                this.services.workStatus.observe(s, ev);
                 break;
             default:
                 break; // turn_start, queue_update — future milestones

package/dist/routes-v2.js

@@ -233,7 +233,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
     }
     // Read-only inventories OpenChamber loads at bootstrap. OmO has no OpenCode-style shells or
     // web-search providers, so each is an honest empty list (mutations stay 400);
-    // OmO monitors appear as child sessions instead (monitor-sessions.ts).
+    // OmO monitors appear in the OmO Work status section instead (work-status.ts).
     if ((path === "/api/shell" || path === "/api/websearch/provider") && method === "GET") {
         json(res, 200, withLocation([]));
         return;
@@ -328,7 +328,9 @@ export async function handleV2(services, req, res, url, path, method, directory)
         const parentID = url.searchParams.get("parentID");
         const order = url.searchParams.get("order") === "asc" ? "asc" : "desc";
         const limit = numberParam(url.searchParams.get("limit"));
-        let infos = dir !== null && dir !== "" ? services.sessions.list(dir) : services.sessions.listAll();
+        let infos = (dir !== null && dir !== "" ? services.sessions.list(dir) : services.sessions.listAll()).filter(
+        // OmO monitors are a child session only for v1 clients; 2.x shows them in the OmO Work section.
+        (session) => !services.sessions.monitors.owns(session.id));
         if (search)
             infos = infos.filter((s) => s.title.toLowerCase().includes(search.toLowerCase()));
         if (parentID !== null)
@@ -373,7 +375,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
     if (path === "/api/session/active" && method === "GET") {
         const data = {};
         for (const [id, status] of Object.entries(services.sessions.statuses())) {
-            if (status.type !== "idle")
+            if (status.type !== "idle" && !services.sessions.monitors.owns(id))
                 data[id] = { type: "running" };
         }
         json(res, 200, { data });

package/dist/running-servers.d.ts

@@ -9,6 +9,8 @@ export interface RunningServer {
     readonly version: string;
     readonly url: string;
     readonly started: string;
+    /** Bearer token for the `/antechamber/work-status` routes; the file is 0600 in a 0700 directory. */
+    readonly token?: string;
 }
 type Fs = Pick<typeof fs, "existsSync" | "mkdirSync" | "readdirSync" | "readFileSync" | "rmSync" | "writeFileSync">;
 /** Writes the record and returns its remover; a crash leaves a stale record that readers skip by PID. */

package/dist/server.d.ts

@@ -20,6 +20,8 @@ export declare class AdapterServer {
     private nextWebSocketEventID;
     private catalogPromise;
     private actualPort;
+    /** Bearer token for the `/antechamber/work-status` routes, published in the run record for the OmO Work extension. */
+    readonly extensionToken: string;
     private readonly http;
     constructor(options: AdapterServerOptions);
     private catalog;

package/dist/server.js

@@ -1,5 +1,5 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
@@ -9,6 +9,7 @@ import { SSE } from "./sse.js";
 import { handleV1 } from "./routes-v1.js";
 import { handleV2 } from "./routes-v2.js";
 import { selfUpdate } from "./self-update.js";
+import { handleWorkStatus } from "./work-status.js";
 export { isLoopbackHost, serverPassword } from "./http.js";
 export class AdapterServer {
     options;
@@ -21,10 +22,12 @@ export class AdapterServer {
     nextWebSocketEventID = 0;
     catalogPromise;
     actualPort;
-    http = new Http(() => this.url);
+    /** Bearer token for the `/antechamber/work-status` routes, published in the run record for the OmO Work extension. */
+    extensionToken = randomBytes(32).toString("base64url");
+    http = new Http(() => this.url, this.extensionToken);
     constructor(options) {
         this.options = options;
-        this.sse = new SSE(options, this.sseClients);
+        this.sse = new SSE(options, this.sseClients, (id) => this.sessions.monitors.owns(id));
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
         this.server = createServer((req, res) => void this.route(req, res));
         this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
@@ -197,6 +200,10 @@ export class AdapterServer {
             this.handleSSE(req, res, "v2", directory, directoryQuery === null && headerDirectory === undefined);
             return;
         }
+        if (path.startsWith("/antechamber/work-status/")) {
+            await handleWorkStatus(this.sessions, req, res, url, method);
+            return;
+        }
         const services = {
             sessions: this.sessions,
             defaultDirectory: this.options.defaultDirectory,

package/dist/sessions.d.ts

@@ -10,6 +10,7 @@ import type { TodoBridge, Todo, TodoUpdated } from "./todo-bridge.js";
 import { type SessionTreeState } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
+import { WorkStatusBridge } from "./work-status.js";
 import { SessionStore, type TitleSource } from "./session-store.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCModelRef, OCPart, OCPromptPart, OCSession, OCSessionStatus, OCToolPart } from "./types.js";
 export { ADAPTER_VERSION } from "./version.js";
@@ -90,6 +91,7 @@ export declare class SessionManager {
     readonly lifecycle: SessionLifecycle;
     readonly subagents: SubagentBridge;
     readonly monitors: MonitorSessions;
+    readonly workStatus: WorkStatusBridge;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     private scanCache;
     /** freshness of the all-directories scan (see listAll). */

package/dist/sessions.js

@@ -17,6 +17,7 @@ import { RequestBodyError } from "./http.js";
 import { bindMessageEntries, durableShellTree, followExternalAppends, forkConversation, getEntries, navigate, recordTurn, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
+import { WorkStatusBridge } from "./work-status.js";
 import { sessionDiff } from "./session-diff.js";
 import { announceSessionNotice, skillCommandText, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionTitle, } from "./session-store.js";
@@ -45,6 +46,7 @@ export class SessionManager {
     lifecycle;
     subagents;
     monitors;
+    workStatus;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     scanCache = new Map();
     /** freshness of the all-directories scan (see listAll). */
@@ -56,10 +58,12 @@ export class SessionManager {
         this.lifecycle = new SessionLifecycle(() => this.sessions.values(), lifecycleOptions);
         this.subagents = new SubagentBridge(this.store, this.sessions, this.emit, (session, raw) => parsePiSessionText(session, getAgentName(), raw));
         this.monitors = new MonitorSessions(this.sessions, this.emit);
+        this.workStatus = new WorkStatusBridge(this.monitors);
         this.events = new PiEventTranslator({
             emit: this.emit,
             subagents: this.subagents,
             monitors: this.monitors,
+            workStatus: this.workStatus,
             store: this.store,
             dirtyDiffs: this.dirtyDiffs,
             ensureMessages: (s) => this.ensureMessages(s),
@@ -254,6 +258,7 @@ export class SessionManager {
             // Its task cards end with the run; the tasks themselves may still run in OmO's shared host.
             this.subagents.finishCalls(s.info.id, true);
             this.monitors.stopParent(s.info.id);
+            this.workStatus.stopParent(s.info.id);
             void this.lifecycle
                 .dormant(s)
                 .catch((error) => console.error("[lifecycle] exit cleanup failed:", error));
@@ -348,6 +353,7 @@ export class SessionManager {
         const piPath = this.subagents.owns(sessionId) || this.monitors.owns(sessionId) ? undefined : (s.piPath ?? s.restored?.piPath);
         const child = this.subagents.remove(sessionId);
         this.monitors.remove(sessionId);
+        this.workStatus.stopParent(sessionId);
         if (piPath !== undefined) {
             try {
                 unlinkSync(piPath);

package/dist/sse.d.ts

@@ -7,10 +7,14 @@ export type SSESubscriber = {
     directory?: string;
     global: boolean;
 };
+/** The session an event belongs to, when it names one. */
+export declare function eventSessionID(event: OCEvent | TodoUpdated): string | undefined;
 export declare class SSE {
     private options;
     /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
     readonly clients: Map<ServerResponse, SSESubscriber>;
+    /** Sessions v2 clients must not see (OmO monitor children, shown by the OmO Work section). */
+    private hiddenFromV2;
     private v2events;
     private nextEventID;
     private replay;
@@ -18,7 +22,9 @@ export declare class SSE {
         defaultDirectory: string;
     }, 
     /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
-    clients: Map<ServerResponse, SSESubscriber>);
+    clients: Map<ServerResponse, SSESubscriber>, 
+    /** Sessions v2 clients must not see (OmO monitor children, shown by the OmO Work section). */
+    hiddenFromV2?: (sessionID: string) => boolean);
     close(): void;
     broadcast(directory: string, event: OCEvent | TodoUpdated): void;
     writeSSE(res: ServerResponse, frame: string): boolean;

package/dist/sse.js

@@ -5,17 +5,35 @@ import { V2EventTranslator } from "./v2.js";
 const MAX_SSE_SUBSCRIBERS = 64;
 const MAX_SSE_PENDING_BYTES = 8 * 1024 * 1024;
 const MAX_SSE_REPLAY_RECORDS = 1024;
+/** The session an event belongs to, when it names one. */
+export function eventSessionID(event) {
+    const properties = event.properties;
+    const nested = (key) => {
+        const value = properties[key];
+        return value !== null && typeof value === "object" ? value : undefined;
+    };
+    if (event.type === "session.created" || event.type === "session.updated" || event.type === "session.deleted")
+        return event.properties.info.id;
+    const info = nested("info");
+    const part = nested("part");
+    const id = properties.sessionID ?? info?.sessionID ?? part?.sessionID;
+    return typeof id === "string" ? id : undefined;
+}
 export class SSE {
     options;
     clients;
+    hiddenFromV2;
     v2events = new V2EventTranslator();
     nextEventID = 0;
     replay = [];
     constructor(options, 
     /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
-    clients) {
+    clients, 
+    /** Sessions v2 clients must not see (OmO monitor children, shown by the OmO Work section). */
+    hiddenFromV2 = () => false) {
         this.options = options;
         this.clients = clients;
+        this.hiddenFromV2 = hiddenFromV2;
     }
     close() {
         for (const res of this.clients.keys()) {
@@ -24,9 +42,12 @@ export class SSE {
         }
     }
     broadcast(directory, event) {
-        const v2Frames = event.type === "todo.updated"
-            ? [{ id: `evt_${randomUUID()}`, type: event.type, location: { directory }, data: event.properties }]
-            : this.v2events.translate(directory, event);
+        const hidden = this.hiddenFromV2(eventSessionID(event) ?? "");
+        const v2Frames = hidden
+            ? []
+            : event.type === "todo.updated"
+                ? [{ id: `evt_${randomUUID()}`, type: event.type, location: { directory }, data: event.properties }]
+                : this.v2events.translate(directory, event);
         const records = v2Frames.length === 0
             ? [this.record(directory, { v1: event })]
             : v2Frames.map((v2, index) => this.record(directory, index === 0 ? { v1: event, v2 } : { v2 }));

package/dist/todo-bridge.d.ts

@@ -5,6 +5,14 @@ export interface Todo {
     readonly status: "pending" | "in_progress" | "completed" | "cancelled";
     readonly priority: "medium";
 }
+/** One todo phase as OmO groups it, in its own order (the Work Status section's waves). */
+export interface TodoPhase {
+    readonly name: string;
+    readonly tasks: ReadonlyArray<{
+        readonly content: string;
+        readonly status: Todo["status"];
+    }>;
+}
 export interface TodoUpdated {
     type: "todo.updated";
     properties: {
@@ -12,11 +20,14 @@ export interface TodoUpdated {
         todos: Todo[];
     };
 }
+/** The `senpi.todo-state` phases, keeping only well-formed phases and tasks. */
+export declare function todoPhases(data: unknown): TodoPhase[];
 export declare function flattenTodos(sessionID: string, data: unknown): Todo[];
 /** Per-session snapshots; each card retains the state produced by its own call. */
 export declare class TodoBridge {
     private readonly sessionID;
     todos: Todo[];
+    phases: TodoPhase[];
     private awaitingState;
     constructor(sessionID: string);
     track(part: OCToolPart, args: unknown): void;

package/dist/todo-bridge.js

@@ -3,43 +3,42 @@ import { toolMappers } from "./tool-map.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-export function flattenTodos(sessionID, data) {
+function todoStatus(value) {
+    switch (value) {
+        case "in_progress":
+            return "in_progress";
+        case "completed":
+            return "completed";
+        case "abandoned":
+        case "dropped":
+        case "cancelled":
+            return "cancelled";
+        default:
+            return "pending";
+    }
+}
+/** The `senpi.todo-state` phases, keeping only well-formed phases and tasks. */
+export function todoPhases(data) {
     if (!record(data) || !Array.isArray(data.phases))
         return [];
-    const phases = data.phases.filter(record);
-    return phases.flatMap((phase) => {
+    return data.phases.filter(record).flatMap((phase) => {
         if (typeof phase.name !== "string" || !Array.isArray(phase.tasks))
             return [];
-        return phase.tasks.filter(record).flatMap((task) => {
-            if (typeof task.content !== "string")
-                return [];
-            let status;
-            switch (task.status) {
-                case "in_progress":
-                    status = "in_progress";
-                    break;
-                case "completed":
-                    status = "completed";
-                    break;
-                case "abandoned":
-                case "dropped":
-                case "cancelled":
-                    status = "cancelled";
-                    break;
-                default:
-                    status = "pending";
-            }
-            return [
-                {
-                    id: createHash("md5").update(`${sessionID}|${phase.name}|${task.content}`).digest("hex").slice(0, 16),
-                    content: phases.length === 1 ? task.content : `${phase.name}: ${task.content}`,
-                    status,
-                    priority: "medium",
-                },
-            ];
-        });
+        const tasks = phase.tasks
+            .filter(record)
+            .flatMap((task) => typeof task.content === "string" ? [{ content: task.content, status: todoStatus(task.status) }] : []);
+        return [{ name: phase.name, tasks }];
     });
 }
+export function flattenTodos(sessionID, data) {
+    const phases = todoPhases(data);
+    return phases.flatMap((phase) => phase.tasks.map((task) => ({
+        id: createHash("md5").update(`${sessionID}|${phase.name}|${task.content}`).digest("hex").slice(0, 16),
+        content: phases.length === 1 ? task.content : `${phase.name}: ${task.content}`,
+        status: task.status,
+        priority: "medium",
+    })));
+}
 toolMappers.todo = (args) => ({
     tool: "todowrite",
     input: { todos: Array.isArray(args.todos) ? args.todos : [] },
@@ -49,6 +48,7 @@ toolMappers.todo = (args) => ({
 export class TodoBridge {
     sessionID;
     todos = [];
+    phases = [];
     awaitingState = [];
     constructor(sessionID) {
         this.sessionID = sessionID;
@@ -68,6 +68,7 @@ export class TodoBridge {
         if (!record(entry) || entry.type !== "custom" || entry.customType !== "senpi.todo-state")
             return undefined;
         this.todos = flattenTodos(this.sessionID, entry.data);
+        this.phases = todoPhases(entry.data);
         const part = this.awaitingState.shift();
         if (part !== undefined) {
             part.state.input = { todos: this.todos };