@xingular/harness 1.2.0 → 1.3.1-unstable.1

package/dist/sdk/terminal/opentui/subagentsWidget.js

@@ -21,24 +21,26 @@ function mark(status, frame) {
         case 'running': return { mark: frame, tone: 'warning' };
     }
 }
-export function subagentTasks(checklist) {
-    return checklist && checklist.total > 0 ? `${checklist.done} of ${checklist.total} tasks` : null;
+export function subagentTasks(todo) {
+    return todo && todo.total > 0 ? `${todo.done} of ${todo.total} tasks` : null;
 }
 /**
  * The compact live roster shown under the status line: active children first, at most three
  * rows. The session name is cut first when the terminal is narrow.
  */
 export function subagentRoster(items, width, frame = getWorkingSpinnerFrames()[0] ?? '') {
-    if (!items.length || width < 1)
+    // The status line already describes the main agent; its row is only on the /subagents page.
+    const children = items.filter(item => item.relation !== 'main');
+    if (!children.length || width < 1)
         return null;
-    const ordered = [...items].sort((left, right) => {
+    const ordered = [...children].sort((left, right) => {
         const active = Number(ACTIVE_SUBAGENT_STATUSES.has(right.status)) - Number(ACTIVE_SUBAGENT_STATUSES.has(left.status));
         return active || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id);
     });
     const rows = ordered.slice(0, MAX_VISIBLE_ROWS).map((item) => {
         const status = mark(item.status, frame);
         const profile = cut(safe(item.profile?.name ?? '') || 'subagent', Math.max(1, Math.min(24, width - 2)));
-        const tasks = subagentTasks(item.checklist);
+        const tasks = subagentTasks(item.todo);
         const used = 2 + visibleWidth(profile) + GAP.length + (tasks ? GAP.length + tasks.length : 0);
         const title = cut(safe(item.title) || 'Subagent', Math.max(1, width - used));
         return { id: item.id, mark: status.mark, tone: status.tone, profile, color: item.profile?.color ?? null, title, tasks };

package/dist/sdk/terminal/opentui/theme.d.ts

@@ -17,6 +17,8 @@ export interface OpenTuiTheme {
     questionActionText: string;
     primary: string;
     accent: string;
+    /** A link under the pointer, one step brighter than the link itself. */
+    linkHover: string;
     success: string;
     warning: string;
     error: string;

package/dist/sdk/terminal/opentui/theme.js

@@ -17,6 +17,7 @@ export const opentuiTheme = {
     questionActionText: '#f7fff8',
     primary: '#fab283',
     accent: '#8ab4f8',
+    linkHover: '#c9ddff',
     success: '#a6da95',
     warning: '#eed49f',
     error: '#ed8796',
@@ -37,6 +38,7 @@ export function profileColor(theme, name) {
         case 'cyan': return theme.cyan;
         case 'orange': return theme.primary;
         case 'purple': return theme.purple;
+        case 'main': return theme.primary;
         default: return theme.accent;
     }
 }

package/dist/sdk/terminal/piExtension.js

@@ -2,25 +2,26 @@
 // session does to the harness, asks before each tool call, takes instructions the harness
 // queues for it, and gives the session the harness's own tools. It runs in the `pi` process,
 // so everything it knows about the harness comes through the session socket.
-import { createBashTool, createEditTool, createWriteTool } from '@earendil-works/pi-coding-agent';
+import { createBashTool, createEditTool, createPowerShellTool, createWriteTool } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { connectionFromEnv, socketCall, terminalCall } from "./client.js";
 import { controlCall } from "./control.js";
 import { SPAWN_SUBAGENT, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, subagentHistory } from "../sessions/subagents.js";
 import { PLAN_RESEARCH_TOOLS } from "../agents/planResearch.js";
 import { askUserTool } from "../tools/askUser.js";
-import { checklistTool } from "../tools/checklist.js";
-import { checkpointTool } from "../tools/checkpoint.js";
+import { TODO_WRITE, todoTool } from "../tools/todo.js";
+import { CHECKPOINT_WRITE, checkpointTool } from "../tools/checkpoint.js";
 import { createSliceState, parseWorkSlice, workSliceGuard } from "../sessions/workSlice.js";
 import { DEFAULT_COMMAND_TIMEOUT_SECONDS, withCommandBudget } from "../core/commandBudget.js";
-import { sessionNameTool } from "../tools/sessionName.js";
+import { SESSION_NAME, deriveSessionName, sessionNameTool } from "../tools/sessionName.js";
 import { CAPABILITY_DISCOVERY, describeCapabilities } from "../tools/getCapabilities.js";
 import { PLAN_INSTRUCTIONS, planRefusal } from "../sessions/planMode.js";
 import { compactionCheckpoint } from "../sessions/compactionCheckpoint.js";
+import { sessionStateText } from "../prompt/compile.js";
 import { pruneToolImages } from "../world/images.js";
 import { parseInitialBashCommand } from "../sessions/initialBash.js";
 import { inspectWorkspaceWrite } from "../sessions/workspaceBoundary.js";
-import { withWorkspaceWriteScope } from "../core/workspaceBashTool.js";
+import { createWorkspaceShellTool } from "../core/workspaceBashTool.js";
 import { createWorkspaceBashOperations, runWithWorkspaceWriteScope } from "../core/workspaceSandbox.js";
 import { withWorkspaceWriteAuthorization, workspaceEditOperations, workspaceWriteOperations } from "../core/workspaceWriteOperations.js";
 import { BUDGET_GUARD, OUTPUT_TRIM, budgetGuard, outputTrim } from "../plugins/firstParty.js";
@@ -48,6 +49,7 @@ export default async function (pi, planRun, getSession) {
     let context = null;
     let nativeSubagents = false;
     let subagentParent = false;
+    let stoppedChildren = null;
     let timer = null;
     let polling = false;
     let failure;
@@ -60,6 +62,10 @@ export default async function (pi, planRun, getSession) {
     const fileTools = new Map();
     const writeAuthorizations = new Map();
     let workspaceRoot = null;
+    let sessionState = null;
+    let stateDelivered = false;
+    let autoNameTried = false;
+    let lastTodo = [];
     // The harness's own tools for this session (connected apps and what the application offers).
     let stage = 'Tool discovery';
     try {
@@ -135,9 +141,24 @@ export default async function (pi, planRun, getSession) {
         },
         workspaceWriteScope: () => planRun?.active ? 'read-only' : undefined
     });
-    pi.registerTool(withWorkspaceWriteScope(createBashTool(process.cwd(), { operations: workspaceBash })));
+    pi.registerTool(createWorkspaceShellTool({ createBashTool, createPowerShellTool }, process.cwd(), workspaceBash));
     pi.registerTool(withWorkspaceWriteAuthorization(createWriteTool(process.cwd(), { operations: workspaceWriteOperations }), writeAuthorizations));
     pi.registerTool(withWorkspaceWriteAuthorization(createEditTool(process.cwd(), { operations: workspaceEditOperations }), writeAuthorizations));
+    // The current name and this run's todo ride with each request; they never change the stable prefix.
+    pi.on('context', (event) => {
+        if (!sessionState || stateDelivered)
+            return;
+        stateDelivered = true;
+        return {
+            messages: [...event.messages, {
+                    role: 'custom',
+                    customType: 'xingular-session-state',
+                    content: sessionState,
+                    display: false,
+                    timestamp: Date.now()
+                }]
+        };
+    });
     compactionCheckpoint({ planInstructions: () => planRun?.active ? PLAN_INSTRUCTIONS : null })(pi);
     // A terminal reply is bounded like any other (PROP-0041): a checkpoint at the boundary, then the
     // person decides whether to continue.
@@ -145,7 +166,7 @@ export default async function (pi, planRun, getSession) {
     const sliceState = createSliceState(slicePolicy);
     // `XINGULAR_WORK_SLICE=off` at launch leaves terminal replies unbounded, as before PROP-0041.
     if (slicePolicy.enabled)
-        workSliceGuard({ policy: slicePolicy, state: sliceState })(pi);
+        workSliceGuard({ policy: slicePolicy, state: sliceState, checkpointAvailable: () => !planRun?.active || planRun.allowedTools.has(CHECKPOINT_WRITE) })(pi);
     // Only the latest screenshots stay in what the model sees (world/images.ts).
     pi.on('context', (event) => {
         const messages = pruneToolImages(event.messages);
@@ -153,9 +174,14 @@ export default async function (pi, planRun, getSession) {
     });
     pi.on('session_start', async (_event, ctx) => {
         context = ctx;
+        sessionState = null;
+        stateDelivered = false;
+        autoNameTried = false;
+        lastTodo = [];
         if (timer)
             clearInterval(timer);
-        await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile() });
+        // The branch's parent runs let the controller show the latest one's rows again on reopen.
+        await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile(), owners: subagentHistory(ctx.sessionManager.getBranch?.() ?? []).owners });
         timer = setInterval(() => {
             if (polling || !context)
                 return;
@@ -188,15 +214,20 @@ export default async function (pi, planRun, getSession) {
         reasoningTokens = undefined;
         costReported = false;
         // A run a plugin starts with a custom message has no user prompt to record; it still begins a turn.
-        const begun = await terminalCall('begin', { text: event.messageType === 'user' ? event.prompt : '' });
+        const begun = await terminalCall('begin', { text: event.messageType === 'user' ? event.prompt : '', model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel?.() ?? null });
         workspaceRoot = typeof begun.workspaceRoot === 'string' ? begun.workspaceRoot : null;
         if (!workspaceRoot)
             throw new Error('The active project workspace could not be resolved; the turn was not started.');
+        // Every turn marks its run on the branch, so a reopened conversation finds its latest one.
+        pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
+        stoppedChildren = null;
         if (nativeSubagents) {
-            pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
             const snapshot = await controlCall('terminal.subagents.register', { tools: pi.getActiveTools(), model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel(), plan: planRun?.active === true, history: subagentHistory(ctx.sessionManager.getBranch()) });
             if (planRun && Array.isArray(snapshot.connectors))
                 planRun.connectors = snapshot.connectors;
+            if (planRun && snapshot.subagentProfiles)
+                planRun.subagentProfiles = snapshot.subagentProfiles;
+            stoppedChildren = snapshot.notice ?? null;
             subagentParent = true;
         }
         if (planRun && event.messageType === 'user') {
@@ -260,6 +291,51 @@ export default async function (pi, planRun, getSession) {
             : 'The user’s initial Bash command has already run. Read its native Bash result and explain what it shows. Do not run the same command again unless the user explicitly asks.';
         return { message: { customType: 'xingular-initial-bash', content: instruction, display: false, details: {} } };
     });
+    // A second handler, so the notice joins any initial-Bash message rather than replacing it.
+    pi.on('before_agent_start', async () => {
+        const notice = stoppedChildren;
+        stoppedChildren = null;
+        if (notice)
+            return { message: { customType: SUBAGENT_RESULTS, content: notice.text, display: false, details: { [SUBAGENT_RECEIPT]: notice.receipt } } };
+    });
+    // A new user turn starts with an empty todo. The previous list is context, not this run's list.
+    // A substantive first turn also gets a provisional name when the terminal policy allows it.
+    pi.on('before_agent_start', async (event, ctx) => {
+        if (event.messageType !== 'user')
+            return;
+        const branch = ctx.sessionManager.getBranch?.() ?? [];
+        const hasUser = branch.some((entry) => entry.type === 'message' && entry.message?.role === 'user');
+        let name = typeof pi.getSessionName === 'function' ? pi.getSessionName() ?? null : null;
+        if (!name && !autoNameTried && pi.setSessionName) {
+            const candidate = deriveSessionName(event.prompt);
+            if (candidate) {
+                autoNameTried = true;
+                try {
+                    const policy = await controlCall('terminal.policy', { tool: SESSION_NAME, args: { name: candidate } });
+                    if (policy.allowed && !policy.requiresApproval) {
+                        pi.setSessionName(candidate);
+                        name = candidate;
+                    }
+                }
+                catch {
+                    // Session naming is metadata; a refused or failed name never fails the turn.
+                }
+            }
+        }
+        const state = {
+            name,
+            todo: [],
+            ...(lastTodo.length ? { previousTodo: lastTodo } : {}),
+            firstTurn: !hasUser
+        };
+        lastTodo = [];
+        const active = typeof pi.getActiveTools === 'function' ? pi.getActiveTools() : null;
+        sessionState = sessionStateText(state, {
+            name: active ? active.includes(SESSION_NAME) : true,
+            todo: active ? active.includes(TODO_WRITE) : true
+        });
+        stateDelivered = false;
+    });
     const deliverChildren = async (event, ctx, settle) => {
         if (!nativeSubagents || (settle && event.outcome !== 'completed') || ctx.signal?.aborted)
             return;
@@ -421,6 +497,10 @@ export default async function (pi, planRun, getSession) {
             clearInterval(timer);
         timer = null;
         context = null;
+        sessionState = null;
+        stateDelivered = false;
+        autoNameTried = false;
+        lastTodo = [];
         // This clears the controller's readiness while the next native session binds. The
         // process-level control claim survives replacement; only the session poller stops.
         await terminalCall('shutdown').catch(() => { });
@@ -437,16 +517,19 @@ export default async function (pi, planRun, getSession) {
             return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined };
         }
     });
-    // The checklist is recorded on the harness run; the shared tool validates and the socket carries the event.
+    // The todo list is recorded on the harness run; the shared tool validates and the socket carries the event.
     let recorded = Promise.resolve();
-    const checklist = checklistTool({ emit: (_type, payload) => { recorded = terminalCall('checklist', payload); } });
+    const todo = todoTool({ emit: (_type, payload) => { recorded = terminalCall('todo', payload); } });
     pi.registerTool({
-        name: checklist.name, label: checklist.label, description: checklist.description,
-        parameters: Type.Unsafe(checklist.parameters(Type)),
+        name: todo.name, label: todo.label, description: todo.description,
+        parameters: Type.Unsafe(todo.parameters(Type)),
         async execute(_id, input) {
             recorded = Promise.resolve();
-            const result = await checklist.execute(input);
+            const result = await todo.execute(input);
             await recorded;
+            const items = input.items;
+            if (Array.isArray(items))
+                lastTodo = items;
             return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined };
         }
     });

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

@@ -5,10 +5,13 @@ export interface TerminalSubagentProfile {
     name: string;
     color: string;
 }
+/** The main agent's row: the parent run itself, shown by name rather than by a profile. */
+export declare const MAIN_PROFILE: TerminalSubagentProfile;
 export interface TerminalSubagentRun {
     id: string;
     parentRunId: string | null;
-    relation: 'subagent';
+    /** `main` is the parent run itself; every other row is a child or nested child. */
+    relation: 'main' | 'subagent';
     /** The short name the parent gave the child (PROP-0030). */
     title: string;
     goal: string | null;
@@ -27,8 +30,8 @@ export interface TerminalSubagentActivity extends TerminalSubagentRun {
     activity: string;
     /** Cumulative run usage only; provider reasoning summaries and request details stay private. */
     usage: TerminalSubagentUsage | null;
-    /** How far the child's own checklist is: counts only, never the items. */
-    checklist: {
+    /** How far the child's own todo is: counts only, never the items. */
+    todo: {
         done: number;
         total: number;
     } | null;
@@ -41,7 +44,17 @@ export declare class SubagentMonitor {
     private parentRunId;
     private readonly activities;
     begin(parentRunId: string): void;
-    observe(parentRunId: string, run: TerminalSubagentRun, event: RunEvent): void;
+    /** Folds one event of the tracked parent (`main`) or one of its descendants; `null` seeds the row. */
+    observe(parentRunId: string, run: TerminalSubagentRun, event: RunEvent | null): void;
+    /**
+     * 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: string, runs: readonly {
+        run: TerminalSubagentRun;
+        events: readonly RunEvent[];
+    }[]): void;
+    /** The main row first, then children in start order. */
     snapshot(parentRunId: string): TerminalSubagentActivity[];
     clear(parentRunId?: string): void;
 }

package/dist/sdk/terminal/subagentMonitor.js

@@ -1,4 +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);
@@ -50,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,
@@ -63,7 +68,7 @@ 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,
@@ -86,8 +91,11 @@ export class SubagentMonitor {
         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)
@@ -125,22 +133,35 @@ export class SubagentMonitor {
                 };
             }
         }
-        else if (event.type === 'checklist.updated') {
+        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

@@ -11,6 +11,7 @@ import type { CallerContext } from "../core/caller.js";
 import { type VariantChoice } from "../variant/materialise.js";
 import type { VariantTrust } from "../variant/trust.js";
 import type { AttachParams, PluginScope } from "../plugins/api.js";
+import type { Proposal } from "../plugins/proposals.js";
 import type { Plugins } from "../plugins/plugins.js";
 import type { Plugin } from "../plugins/types.js";
 import type { Hub } from "../hub/hub.js";
@@ -131,6 +132,12 @@ export interface PluginControl {
     remove?(params: PluginScope & {
         pluginId: string;
     }): Promise<Plugin[]>;
+    proposals?: {
+        list(): Proposal[] | Promise<Proposal[]>;
+        preview(id: string): Proposal | Promise<Proposal>;
+        accept(id: string, hash: string): Proposal | Promise<Proposal>;
+        reject(id: string, hash: string): Proposal | Promise<Proposal>;
+    };
 }
 export declare class Terminals {
     private readonly options;
@@ -138,6 +145,8 @@ export declare class Terminals {
     private readonly diagnosticOwners;
     /** The variant each live session runs, for loading its skills. */
     private readonly variantDirs;
+    /** The subagent profile files each live session's packages bring, chosen when it started. */
+    private readonly packageProfiles;
     /** The world tools each session was given, so a call can only reach one of them. */
     private readonly worldNames;
     private readonly worldReadOnly;
@@ -150,6 +159,13 @@ 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;