@xingular/harness 1.1.1 → 1.3.1-unstable.0

package/dist/sdk/terminal/subagentMonitor.js

@@ -1,3 +1,6 @@
+import { usagePayloadSchema } from "../sessions/contracts.js";
+/** The main agent's row: the parent run itself, shown by name rather than by a profile. */
+export const MAIN_PROFILE = { name: 'main', color: 'main' };
 export const ACTIVE_SUBAGENT_STATUSES = new Set(['queued', 'running', 'waiting_for_approval', 'waiting_for_input']);
 export function terminalSubagentDuration(activity, now = Date.now()) {
     const start = Date.parse(activity.startedAt);
@@ -41,7 +44,7 @@ function stringOf(value) {
 function latestTool(tools) {
     return [...tools.values()].sort((left, right) => right.sequence - left.sequence)[0]?.text;
 }
-/** Volatile, read-only activity projection for the active terminal parent run. */
+/** Volatile, read-only activity projection for the latest terminal parent run. */
 export class SubagentMonitor {
     parentRunId = null;
     activities = new Map();
@@ -49,8 +52,11 @@ export class SubagentMonitor {
         this.parentRunId = parentRunId;
         this.activities.clear();
     }
+    /** Folds one event of the tracked parent (`main`) or one of its descendants; `null` seeds the row. */
     observe(parentRunId, run, event) {
-        if (this.parentRunId !== parentRunId || run.relation !== 'subagent')
+        if (this.parentRunId !== parentRunId)
+            return;
+        if ((run.relation === 'main') !== (run.id === parentRunId))
             return;
         const row = this.activities.get(run.id) ?? {
             id: run.id,
@@ -62,21 +68,34 @@ export class SubagentMonitor {
             startedAt: run.startedAt,
             endedAt: run.endedAt,
             activity: statusActivity(run.status),
-            checklist: null,
+            todo: null,
             profile: run.profile ?? null,
+            accountLabel: run.accountLabel ?? null,
+            model: run.model ?? null,
+            effort: run.effort ?? null,
+            usage: null,
             tools: new Map(),
             lastTool: null
         };
         row.parentRunId = run.parentRunId;
         if (run.profile !== undefined)
             row.profile = run.profile;
+        if (run.accountLabel !== undefined)
+            row.accountLabel = run.accountLabel;
+        if (run.model !== undefined && !row.usage?.model)
+            row.model = run.model;
+        if (run.effort !== undefined)
+            row.effort = run.effort;
         row.title = run.title;
         row.goal = run.goal;
         row.status = run.status;
         row.startedAt = run.startedAt;
         row.endedAt = run.endedAt;
-        const payload = payloadOf(event);
-        if (event.type === 'tool.started') {
+        const payload = event ? payloadOf(event) : {};
+        if (!event) {
+            // A seeded row keeps what it already folded.
+        }
+        else if (event.type === 'tool.started') {
             const toolCallId = stringOf(payload.toolCallId);
             const name = stringOf(payload.name) ?? 'Tool';
             if (toolCallId)
@@ -94,22 +113,55 @@ export class SubagentMonitor {
             row.lastTool = null;
             row.activity = 'Responding';
         }
-        else if (event.type === 'checklist.updated') {
+        else if (event.type === 'usage.updated') {
+            const parsed = usagePayloadSchema.safeParse(payload);
+            if (parsed.success) {
+                const usage = parsed.data;
+                row.usage = {
+                    ...(usage.provider === undefined ? {} : { provider: usage.provider }),
+                    ...(usage.model === undefined ? {} : { model: usage.model }),
+                    ...(usage.inputTokens === undefined ? {} : { inputTokens: usage.inputTokens }),
+                    ...(usage.outputTokens === undefined ? {} : { outputTokens: usage.outputTokens }),
+                    ...(usage.cacheReadTokens === undefined ? {} : { cacheReadTokens: usage.cacheReadTokens }),
+                    ...(usage.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: usage.cacheWriteTokens }),
+                    ...(usage.reasoningTokens === undefined ? {} : { reasoningTokens: usage.reasoningTokens }),
+                    ...(usage.costUsd === undefined ? {} : { costUsd: usage.costUsd }),
+                    ...(usage.costSource === undefined ? {} : { costSource: usage.costSource }),
+                    ...(usage.requests === undefined ? {} : { requests: usage.requests }),
+                    ...(usage.contextTokens === undefined ? {} : { contextTokens: usage.contextTokens }),
+                    ...(usage.contextWindow === undefined ? {} : { contextWindow: usage.contextWindow })
+                };
+            }
+        }
+        else if (event.type === 'todo.updated' || event.type === 'checklist.updated') {
             const items = Array.isArray(payload.items) ? payload.items : [];
-            row.checklist = items.length ? { done: items.filter(item => item?.status === 'completed').length, total: items.length } : null;
+            row.todo = items.length ? { done: items.filter(item => item?.status === 'completed').length, total: items.length } : null;
         }
         if (run.status !== 'running')
             row.tools.clear();
         row.activity = run.status === 'running'
-            ? latestTool(row.tools) ?? row.lastTool?.text ?? (event.type === 'message.delta' ? 'Responding' : 'Working')
+            ? latestTool(row.tools) ?? row.lastTool?.text ?? (event?.type === 'message.delta' || (!event && row.activity === 'Responding') ? 'Responding' : 'Working')
             : statusActivity(run.status);
         this.activities.set(run.id, row);
     }
+    /**
+     * Rebuilds the rows of a parent run that is no longer live, such as the latest one of a reopened
+     * conversation, by folding each run's saved events. Rows keep their final status.
+     */
+    restore(parentRunId, runs) {
+        this.begin(parentRunId);
+        for (const { run, events } of runs) {
+            this.observe(parentRunId, run, null);
+            for (const event of events)
+                this.observe(parentRunId, run, event);
+        }
+    }
+    /** The main row first, then children in start order. */
     snapshot(parentRunId) {
         if (this.parentRunId !== parentRunId)
             return [];
         return [...this.activities.values()]
-            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
+            .sort((left, right) => Number(right.relation === 'main') - Number(left.relation === 'main') || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
             .map(({ tools: _tools, lastTool: _lastTool, ...activity }) => activity);
     }
     clear(parentRunId) {

package/dist/sdk/terminal/terminals.d.ts

@@ -22,6 +22,8 @@ import type { World } from "../world/world.js";
 import type { Worktrees } from "../worktrees/service.js";
 import type { AnnotationCapture } from "../annotations/capture.js";
 import type { NoteDeliveries } from "../annotations/delivery.js";
+import type { Usage } from "../usage/service.js";
+import type { UsageLimits } from "../usage/limits/service.js";
 /** The files a terminal session needs on disk, outside this process. */
 export interface TerminalAssets {
     /** The Node binary that runs the commands. */
@@ -103,6 +105,10 @@ export interface TerminalsOptions {
     noteCapture?: AnnotationCapture;
     /** Page notes on their way to a session (PROP-0018). */
     pageNotes?: NoteDeliveries;
+    /** Usage analytics over the derived ledger (`/usage:analysis`). */
+    usage?: Usage;
+    /** Provider plan windows, balances and rate limits (`/usage:limit`). */
+    usageLimits?: UsageLimits;
 }
 /** What `/plugins` in a terminal can do. Each takes the session's folder, account and project. */
 export interface PluginControl {
@@ -144,13 +150,27 @@ export declare class Terminals {
     /** Each child's profile name and colour, looked up once per child run. */
     private readonly childProfiles;
     private subagentProfile;
+    /** Account, model and effort for a monitor row, from the run record. */
+    private monitorRuntime;
+    /**
+     * Shows the reopened conversation's latest parent run again: the last owner on its native branch
+     * that ran in this folder, with every descendant flat, as each ended.
+     */
+    private hydrateMonitor;
     constructor(options: TerminalsOptions);
     /** The commands a terminal session finds on PATH. Rewritten only when they change. */
     private ensureCommands;
-    /** The broker's tools, then the world tools whose plugins are on for this session. */
+    /**
+     * The harness's own History, Wiki and skill tools, then the broker's, then the world tools whose
+     * plugins are on for this session: the same tools a structured session has (INV-PAR-1).
+     */
     private tools;
+    private readonly ownNames;
+    private ownTools;
     /** The world tools a new session will have, named in its instructions. */
     private worldToolNames;
+    /** The harness's own History, Wiki and skill tools a new session will have. */
+    private ownToolNames;
     /** Whether a world tool's plugin is switched on for a session's folder, account and project. */
     private worldOn;
     private appsCall;
@@ -169,7 +189,9 @@ export declare class Terminals {
     private agentsCall;
     /** `/worktree`: the managed worktrees of the repository this session works in. */
     private worktreesCall;
-    /** `/plugin:notes` and `/plugin:annotate`: the page notes a person keeps, and the visible browser they capture them in. */
+    /** `/usage:analysis` and `/usage:limit`: usage for this session's own account, project or session. */
+    private usageCall;
+    /** `/annotate:notes` and `/annotate:`: Web annotations and their visible capture browser. */
     private annotationsCall;
     /** The account a session asked to switch to. Taken once, after its Pi process has ended and before `dispose`. */
     takeRelaunch(sessionId: string): TerminalRelaunch | null;
@@ -179,6 +201,8 @@ export declare class Terminals {
     /** The run a native turn reports into: the one reserved by `send`, or a new one for what the person typed. */
     private begin;
     private decide;
+    private workspaceEscape;
+    private workspaceBoundaryBypass;
     private subagentsCall;
     private componentsCall;
     private trajectoryCall;