@xingular/harness 1.0.0 → 1.2.0

package/dist/sdk/terminal/standalone.js

@@ -5,28 +5,51 @@ import { appendFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
 import { setLogSink } from "../core/bus.js";
+import { DEFAULT_PRODUCT_NAME } from "../core/env.js";
+import { interactiveProfileSecretStore, resolveInteractiveProfile } from "../core/interactiveProfile.js";
 import { createHarness } from "../harness.js";
+import { seedVariant } from "../variant/seed.js";
+import * as variantStore from "../variant/store.js";
 export function standaloneArguments(argv) {
     const command = argv[0];
-    if (!command || command.startsWith('--') || command === '-h')
+    if (!command || command.startsWith('-'))
         return argv;
     return command === 'terminal' ? argv.slice(1) : null;
 }
-export function parseStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
-    const root = join(home, '.xingular-harness');
-    const paths = {
-        dataRoot: join(root, 'data'),
-        stateDir: join(root, 'state')
-    };
+function resolveStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
+    const overrides = {};
     const given = new Set();
+    let worktree;
+    let variant;
     for (let index = 0; index < argv.length; index += 1) {
         const argument = argv[index];
+        if (argument === '--worktree' || argument === '-w') {
+            const name = argv[index + 1];
+            if (name && !name.startsWith('-')) {
+                worktree = name;
+                index += 1;
+            }
+            else
+                worktree = true;
+            continue;
+        }
+        if (argument === '--variant') {
+            const scope = argv[index + 1];
+            if (!scope || scope.startsWith('-'))
+                throw new Error('--variant needs a variant scope.');
+            variant = scope;
+            index += 1;
+            continue;
+        }
         if (argument !== '--data' && argument !== '--state')
             throw new Error(`Unknown standalone option: ${argument}`);
         const value = argv[index + 1];
         if (!value || value.startsWith('--'))
             throw new Error(`${argument} needs a directory path.`);
-        paths[argument === '--data' ? 'dataRoot' : 'stateDir'] = resolve(cwd, value);
+        if (argument === '--data')
+            overrides.dataRoot = resolve(cwd, value);
+        else
+            overrides.stateDir = resolve(cwd, value);
         given.add(argument);
         index += 1;
     }
@@ -35,7 +58,49 @@ export function parseStandaloneOptions(argv, home = homedir(), cwd = process.cwd
     if (!isAbsolute(home) && !(given.has('--data') && given.has('--state'))) {
         throw new Error(`The home folder "${home}" is not an absolute path, so the default data and state folders cannot be placed. Set HOME to your home folder, or pass --data and --state with absolute folders.`);
     }
-    return paths;
+    // `npm run dev` passes these roots explicitly. Keep its profile and credentials separate from
+    // the installed interactive profile, even when that production profile selects a host store.
+    const devRoot = isAbsolute(home) ? join(home, '.xingular-harness-dev') : null;
+    const devData = devRoot ? join(devRoot, 'data') : null;
+    const devState = devRoot ? join(devRoot, 'state') : null;
+    const development = !!devRoot && (overrides.dataRoot === devData || overrides.stateDir === devState);
+    const resolvedProfile = isAbsolute(home)
+        ? resolveInteractiveProfile({
+            home,
+            ...(development ? {
+                configPath: join(devRoot, 'profile.json'),
+                legacyDefaults: {
+                    dataRoot: devData,
+                    stateDir: devState,
+                    defaultVariantScope: 'default',
+                    secretBackend: { kind: 'file', path: join(devState, 'secrets.json') }
+                }
+            } : {}),
+            overrides
+        })
+        : {
+            version: 1,
+            dataRoot: overrides.dataRoot,
+            stateDir: overrides.stateDir,
+            defaultVariantScope: 'default',
+            secretBackend: { kind: 'file', path: join(overrides.stateDir, 'secrets.json') }
+        };
+    // The standalone development launch has no host adapter and must not use the App's Keychain.
+    const profile = development
+        ? { ...resolvedProfile, secretBackend: { kind: 'file', path: join(resolvedProfile.stateDir, 'secrets.json') } }
+        : resolvedProfile;
+    return {
+        profile,
+        paths: {
+            dataRoot: profile.dataRoot,
+            stateDir: profile.stateDir,
+            ...(worktree !== undefined ? { worktree } : {}),
+            ...(variant !== undefined ? { variant } : {})
+        }
+    };
+}
+export function parseStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
+    return resolveStandaloneOptions(argv, home, cwd).paths;
 }
 function processEnvironment(overrides) {
     const environment = { ...process.env };
@@ -99,14 +164,33 @@ function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
         child.once('exit', (code, signal) => finish(() => resolveExit(exitCode(code, signal))));
     });
 }
+/**
+ * `--worktree`: the named worktree of the repository in `cwd`, or a new managed one. Older managed
+ * worktrees beyond the kept number are pruned (unsaved work is kept as a snapshot).
+ */
+async function enterWorktree(harness, cwd, wanted) {
+    const name = wanted === true ? undefined : wanted;
+    const existing = name ? (await harness.worktrees.list(cwd)).find((record) => record.name === name) : undefined;
+    if (existing)
+        return existing;
+    const created = await harness.worktrees.create({ repo: cwd, ...(name ? { name } : {}) });
+    process.stdout.write(`Working in worktree ${created.worktree.name} (${created.worktree.path}).\n`);
+    if (created.setup.state === 'untrusted')
+        process.stdout.write('This repository has a setup script you have not trusted; read .xharness/worktree-setup, then run: xagent worktree trust-setup\n');
+    if (created.setup.state === 'failed')
+        process.stdout.write(`The worktree setup script failed; see ${created.setup.log}.\n`);
+    await harness.worktrees.prune({ repo: cwd }).catch(() => undefined);
+    return created.worktree;
+}
 export async function runStandaloneTerminal(argv, dependencies = {}) {
     if (!(dependencies.stdinIsTTY ?? process.stdin.isTTY) || !(dependencies.stdoutIsTTY ?? process.stdout.isTTY)) {
-        throw new Error('The interactive Harness terminal needs a TTY. Run it from a terminal, or use `xharness serve` for a host process.');
+        throw new Error('The interactive Harness terminal needs a TTY. Run it from a terminal, or use `xagent serve` for a host process.');
     }
-    const cwd = resolve(dependencies.cwd ?? process.cwd());
-    const paths = parseStandaloneOptions(argv, dependencies.home, cwd);
+    let cwd = resolve(dependencies.cwd ?? process.cwd());
+    const { paths, profile } = resolveStandaloneOptions(argv, dependencies.home, cwd);
+    const secrets = await interactiveProfileSecretStore(profile, dependencies.hostSecretStore);
     const makeHarness = dependencies.createHarness ?? createHarness;
-    const harness = makeHarness({ dataRoot: paths.dataRoot, stateDir: paths.stateDir, productName: 'Xingular Harness' });
+    const harness = makeHarness({ dataRoot: paths.dataRoot, stateDir: paths.stateDir, productName: DEFAULT_PRODUCT_NAME, secrets });
     const newSessionId = dependencies.createSessionId ?? randomUUID;
     let current = { sessionId: newSessionId(), accountId: null, nativeSessionId: null };
     // The frontend draws on this terminal, so the host's diagnostics go to a file the person can read instead.
@@ -121,19 +205,34 @@ export async function runStandaloneTerminal(argv, dependencies = {}) {
     });
     try {
         await harness.ready;
+        const variantScope = paths.variant ?? profile.defaultVariantScope;
+        if (variantScope === profile.defaultVariantScope && !variantStore.head(paths.dataRoot, variantScope)) {
+            variantStore.seed(paths.dataRoot, variantScope, seedVariant(paths.dataRoot, {}), 'interactive profile default');
+        }
         if (harness.accounts.overview().accounts.length === 0)
             harness.accounts.create('Default', 'subscription');
-        const cwdHash = createHash('sha256').update(cwd).digest('hex');
-        const sessionFolder = join(paths.dataRoot, 'sessions', 'terminal', cwdHash);
+        let worktreeId = null;
+        if (paths.worktree) {
+            const worktree = await enterWorktree(harness, cwd, paths.worktree);
+            cwd = worktree.path;
+            worktreeId = worktree.id;
+        }
         for (;;) {
-            const launch = await harness.terminals.prepare({ ...current, cwd, sessionFolder });
+            const sessionFolder = join(paths.dataRoot, 'sessions', 'terminal', createHash('sha256').update(cwd).digest('hex'));
+            const launch = await harness.terminals.prepare({ ...current, cwd, sessionFolder, variant: { scope: variantScope }, ...(worktreeId ? { run: { worktreeId } } : {}) });
             const code = await spawnFrontend(launch, cwd, dependencies.spawn);
-            // `/accounts` asks for a switch and ends the frontend. The conversation resumes on the chosen account.
+            // `/accounts` and `/worktree` ask for a switch and end the frontend. An account switch resumes
+            // the conversation; a folder switch starts a new one there.
             const next = harness.terminals.takeRelaunch(current.sessionId);
             if (!next)
                 return code;
-            const label = harness.accounts.find(next.accountId).label;
-            process.stdout.write(`Switching this session to account ${label}.\n`);
+            if (next.cwd) {
+                process.stdout.write(`Opening ${next.cwd}.\n`);
+                cwd = next.cwd;
+                worktreeId = next.worktreeId ?? null;
+            }
+            else
+                process.stdout.write(`Switching this session to account ${harness.accounts.find(next.accountId).label}.\n`);
             await harness.terminals.dispose(current.sessionId);
             current = { sessionId: newSessionId(), accountId: next.accountId, nativeSessionId: next.nativeSessionId };
         }

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

@@ -0,0 +1,47 @@
+import { type RunEvent, type RunStatus, type UsagePayload } from "../sessions/contracts.js";
+import type { Effort } from "../sessions/runner.js";
+/** The agent profile a child started from, as the roster shows it (PROP-0029). */
+export interface TerminalSubagentProfile {
+    name: string;
+    color: string;
+}
+export interface TerminalSubagentRun {
+    id: string;
+    parentRunId: string | null;
+    relation: 'subagent';
+    /** The short name the parent gave the child (PROP-0030). */
+    title: string;
+    goal: string | null;
+    status: RunStatus;
+    startedAt: string;
+    endedAt: string | null;
+    profile?: TerminalSubagentProfile | null;
+    /** The pinned account's display label; subagents never switch accounts. */
+    accountLabel?: string | null;
+    /** Effective launch selection, superseded by provider-reported usage when available. */
+    model?: string | null;
+    effort?: Effort | null;
+}
+export type TerminalSubagentUsage = Partial<Pick<UsagePayload, 'provider' | 'model' | 'inputTokens' | 'outputTokens' | 'cacheReadTokens' | 'cacheWriteTokens' | 'reasoningTokens' | 'costUsd' | 'costSource' | 'requests' | 'contextTokens' | 'contextWindow'>>;
+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: {
+        done: number;
+        total: number;
+    } | null;
+}
+export declare const ACTIVE_SUBAGENT_STATUSES: Set<"queued" | "running" | "waiting_for_approval" | "waiting_for_input" | "interrupted" | "completed" | "failed">;
+export declare function terminalSubagentDuration(activity: TerminalSubagentRun, now?: number): string;
+export declare function terminalSubagentTone(status: RunStatus): 'success' | 'warning' | 'error' | 'muted';
+/** Volatile, read-only activity projection for the latest terminal parent run. */
+export declare class SubagentMonitor {
+    private parentRunId;
+    private readonly activities;
+    begin(parentRunId: string): void;
+    observe(parentRunId: string, run: TerminalSubagentRun, event: RunEvent): void;
+    snapshot(parentRunId: string): TerminalSubagentActivity[];
+    clear(parentRunId?: string): void;
+}

package/dist/sdk/terminal/subagentMonitor.js

@@ -0,0 +1,152 @@
+import { usagePayloadSchema } from "../sessions/contracts.js";
+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);
+    const end = activity.endedAt ? Date.parse(activity.endedAt) : now;
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return '—';
+    const seconds = Math.max(0, Math.floor((end - start) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}:${String(seconds % 60).padStart(2, '0')}`;
+    return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}m`;
+}
+export function terminalSubagentTone(status) {
+    if (status === 'completed')
+        return 'success';
+    if (status === 'failed')
+        return 'error';
+    if (ACTIVE_SUBAGENT_STATUSES.has(status))
+        return 'warning';
+    return 'muted';
+}
+function statusActivity(status) {
+    switch (status) {
+        case 'queued': return 'Queued';
+        case 'waiting_for_approval': return 'Waiting for approval';
+        case 'waiting_for_input': return 'Waiting for input';
+        case 'completed': return 'Completed';
+        case 'failed': return 'Failed';
+        case 'interrupted': return 'Interrupted';
+        case 'running': return 'Working';
+    }
+}
+function payloadOf(event) {
+    return event.payload && typeof event.payload === 'object' ? event.payload : {};
+}
+function stringOf(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function latestTool(tools) {
+    return [...tools.values()].sort((left, right) => right.sequence - left.sequence)[0]?.text;
+}
+/** Volatile, read-only activity projection for the latest terminal parent run. */
+export class SubagentMonitor {
+    parentRunId = null;
+    activities = new Map();
+    begin(parentRunId) {
+        this.parentRunId = parentRunId;
+        this.activities.clear();
+    }
+    observe(parentRunId, run, event) {
+        if (this.parentRunId !== parentRunId || run.relation !== 'subagent')
+            return;
+        const row = this.activities.get(run.id) ?? {
+            id: run.id,
+            parentRunId: run.parentRunId,
+            relation: run.relation,
+            title: run.title,
+            goal: run.goal,
+            status: run.status,
+            startedAt: run.startedAt,
+            endedAt: run.endedAt,
+            activity: statusActivity(run.status),
+            checklist: 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 toolCallId = stringOf(payload.toolCallId);
+            const name = stringOf(payload.name) ?? 'Tool';
+            if (toolCallId)
+                row.tools.set(toolCallId, { sequence: event.sequence, text: name });
+        }
+        else if (event.type === 'tool.completed') {
+            const toolCallId = stringOf(payload.toolCallId);
+            const tool = toolCallId ? row.tools.get(toolCallId) : undefined;
+            if (tool && (!row.lastTool || tool.sequence >= row.lastTool.sequence))
+                row.lastTool = tool;
+            if (toolCallId)
+                row.tools.delete(toolCallId);
+        }
+        else if (event.type === 'message.delta') {
+            row.lastTool = null;
+            row.activity = 'Responding';
+        }
+        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 === '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;
+        }
+        if (run.status !== 'running')
+            row.tools.clear();
+        row.activity = run.status === 'running'
+            ? latestTool(row.tools) ?? row.lastTool?.text ?? (event.type === 'message.delta' ? 'Responding' : 'Working')
+            : statusActivity(run.status);
+        this.activities.set(run.id, row);
+    }
+    snapshot(parentRunId) {
+        if (this.parentRunId !== parentRunId)
+            return [];
+        return [...this.activities.values()]
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
+            .map(({ tools: _tools, lastTool: _lastTool, ...activity }) => activity);
+    }
+    clear(parentRunId) {
+        if (parentRunId && this.parentRunId !== parentRunId)
+            return;
+        this.parentRunId = null;
+        this.activities.clear();
+    }
+}

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

@@ -1,5 +1,6 @@
 import type { CapabilitySet } from "../capabilities/types.js";
 import type { Subagents } from "../sessions/subagentService.js";
+import type { SideQuestions } from "../sessions/sideQuestions.js";
 import { type SubagentOptions } from "../sessions/subagents.js";
 import type { Accounts } from "../accounts/accounts.js";
 import type { Approvals } from "../sessions/approvals.js";
@@ -18,11 +19,16 @@ import type { RunRecord } from "../sessions/contracts.js";
 import type { ToolPolicy } from "../sessions/policy.js";
 import type { RunRegistry } from "../sessions/registry.js";
 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. */
     node: string;
-    /** The built `xharness` command (`dist/cli.js`). */
+    /** The built `xagent` command (`dist/cli.js`). */
     cli: string;
     /** The built Pi extension (`dist/terminal-pi.js`). */
     piExtension: string;
@@ -52,6 +58,15 @@ export interface TerminalPrepareInput {
     /** Fields copied onto each run this session records. */
     run?: Partial<Pick<RunRecord, 'mode' | 'worktreeId'>>;
 }
+/** What a session asked to restart as: another account, or another folder (a worktree or the main checkout). */
+export interface TerminalRelaunch {
+    accountId: string;
+    nativeSessionId: string | null;
+    /** Restart in this folder, as a new conversation there. */
+    cwd?: string;
+    /** The managed worktree the new folder belongs to; null for the main checkout. */
+    worktreeId?: string | null;
+}
 export interface TerminalLaunch {
     program: string;
     args: string[];
@@ -65,6 +80,8 @@ export interface TerminalsOptions {
     /** Which plugin code in variants a person trusted. */
     trust?: VariantTrust | null;
     subagents?: Subagents;
+    /** Shared tool-free side-question runs. */
+    sideQuestions?: SideQuestions;
     resolveCapabilities?: (caller: CallerContext, tools: readonly string[], cwd: string) => Promise<CapabilitySet>;
     env: HarnessEnv;
     stateDir: string;
@@ -82,6 +99,16 @@ export interface TerminalsOptions {
     assets?: TerminalAssets;
     /** Web, browser and computer tools, offered when their plugins are on. */
     world?: World;
+    /** Managed worktrees: a session naming one works in it and holds it while it lives. */
+    worktrees?: Worktrees;
+    /** The visible browser a person captures page notes in. */
+    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 {
@@ -98,6 +125,12 @@ export interface PluginControl {
         pluginId: string;
         settings: Record<string, unknown>;
     }): Promise<Plugin[]>;
+    install?(params: PluginScope & {
+        source: string;
+    }): Promise<Plugin[]>;
+    remove?(params: PluginScope & {
+        pluginId: string;
+    }): Promise<Plugin[]>;
 }
 export declare class Terminals {
     private readonly options;
@@ -110,15 +143,27 @@ export declare class Terminals {
     private readonly worldReadOnly;
     private readonly socket;
     private readonly assets;
-    /** A session's `/accounts` switch, taken once its Pi process has ended. */
+    /** A session's `/accounts` or `/worktree` switch, taken once its Pi process has ended. */
     private readonly relaunches;
+    /** The managed worktree each live session holds. */
+    private readonly worktreeLeases;
+    /** Each child's profile name and colour, looked up once per child run. */
+    private readonly childProfiles;
+    private subagentProfile;
     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;
@@ -133,20 +178,28 @@ export declare class Terminals {
      * or removing an account is a person's choice, never the model's shell command.
      */
     private accountsCall;
+    /** `/agents`: the agent profiles this session's folder can use (PROP-0029). */
+    private agentsCall;
+    /** `/worktree`: the managed worktrees of the repository this session works in. */
+    private worktreesCall;
+    /** `/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): {
-        accountId: string;
-        nativeSessionId: string | null;
-    } | null;
+    takeRelaunch(sessionId: string): TerminalRelaunch | null;
     private live;
     private historyDir;
     private runRecord;
     /** 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;
+    private sideQuestionCall;
     /** The only terminal frontend: the Bun-run OpenTUI application. */
     private frontendCommand;
     /**