@xingular/harness 1.6.0-unstable → 2.0.1-unstable

package/dist/sdk/terminal/liveTerminal.js

@@ -0,0 +1,436 @@
+// The terminal as a client of the harness (ADR-0083, phase 2). The terminal frontend no longer runs
+// Pi: each turn it sends is a `sessions.run { live: true }` of this terminal's conversation, and the
+// frontend draws from the live session's native events and its own read of the history file.
+// These are protected session-socket routes (INV-TUI-4): the account, folder, variant and caller come
+// from preparation, never from the request.
+import { randomUUID } from 'node:crypto';
+import { HarnessError, invalid } from "../core/errors.js";
+import { loadRun, pendingDecisions, readEvents, recordedSubagents } from "../sessions/runStore.js";
+import { rename as renameHistory } from "../sessions/control.js";
+/** Pi's own tools a terminal session has active, as the in-process terminal has them. */
+export const TERMINAL_NATIVE_TOOLS = ['read', 'bash', 'edit', 'write'];
+/** Native events kept for a client that reads late; older ones are dropped and the client resyncs. */
+const JOURNAL = 4000;
+const WAIT_MS = 20_000;
+/** Pi's names for the commands of loaded extensions: a name two extensions share gets `:2`, `:3`. */
+export function registeredCommands(extensions) {
+    const all = extensions.flatMap((extension) => [...extension.commands.values()].map((command) => ({ command, source: command.sourceInfo ?? extension.sourceInfo })));
+    const counts = new Map();
+    for (const { command } of all)
+        counts.set(command.name, (counts.get(command.name) ?? 0) + 1);
+    const seen = new Map();
+    const taken = new Set();
+    return all.map(({ command, source }) => {
+        const occurrence = (seen.get(command.name) ?? 0) + 1;
+        seen.set(command.name, occurrence);
+        let invocationName = (counts.get(command.name) ?? 0) > 1 ? `${command.name}:${occurrence}` : command.name;
+        let suffix = occurrence;
+        while (taken.has(invocationName))
+            invocationName = `${command.name}:${++suffix}`;
+        taken.add(invocationName);
+        return { name: command.name, invocationName, description: command.description ?? '', sourceInfo: source ?? null };
+    });
+}
+export class LiveTerminal {
+    context;
+    sessions;
+    runs;
+    journal = [];
+    seq = 0;
+    waiters = new Set();
+    pendingRevision = 0;
+    pendingWaiters = new Set();
+    activeRunId = null;
+    lastRunId = null;
+    stops = [];
+    disposed = false;
+    settledListeners = new Set();
+    constructor(context, sessions, runs) {
+        this.context = context;
+        this.sessions = sessions;
+        this.runs = runs;
+        this.stops.push(sessions.live.watch(context.sessionId, (event) => this.append(event)));
+        this.stops.push(runs.listen((event) => {
+            // A follow-up the harness started after the last reply is this terminal's reply now.
+            const liveActive = sessions.live.status(context.sessionId)?.activeRunId ?? null;
+            if (liveActive && liveActive === event.runId && this.activeRunId !== liveActive)
+                this.started(liveActive);
+            if (event.runId !== this.activeRunId && !this.isOwnChild(event.runId))
+                return;
+            if (['approval.requested', 'approval.resolved', 'question.requested', 'question.answered'].includes(event.type))
+                this.bumpPending();
+            // A plugin's dialog is shown by the window itself; its question stays answerable from anywhere.
+            if (event.type === 'question.requested' && event.payload.dialog) {
+                this.append({ type: 'harness_dialog', runId: event.runId, request: { ...event.payload, requestId: event.payload.questionId } });
+            }
+            if (event.type === 'question.answered')
+                this.append({ type: 'harness_dialog_done', requestId: event.payload.questionId });
+            // What a plugin shows (a notice, a status line, a widget) reaches the window with the reply's own events.
+            if (event.type === 'extension.notice')
+                this.append({ type: 'harness_notice', notice: event.payload });
+            // A reply that fails says why in the window, as an in-process prompt's error does.
+            if (event.type === 'failed' && event.runId === this.activeRunId) {
+                const message = event.payload.message;
+                if (typeof message === 'string' && message)
+                    this.append({ type: 'harness_notice', notice: { kind: 'error', text: message } });
+            }
+            const ended = event.type === 'completed' || event.type === 'failed' || (event.type === 'status.changed' && event.payload.status === 'interrupted');
+            if (ended && event.runId === this.activeRunId) {
+                // The window learns that the reply is over even when Pi's loop never started (a command that failed).
+                // A goal run says where its goal stands, so the window's /goal shows the harness's own state.
+                let goalMode = null;
+                try {
+                    goalMode = loadRun(this.context.root, event.runId).goalMode ?? null;
+                }
+                catch {
+                    // No record to read.
+                }
+                const live = this.sessions.live.status(this.context.sessionId);
+                this.append({ type: 'harness_settled', runId: event.runId, status: event.type === 'completed' ? 'completed' : event.type === 'failed' ? 'failed' : 'interrupted', goalMode, sessionFile: live?.sessionFile ?? null, nativeSessionId: live?.nativeSessionId ?? null });
+                this.activeRunId = null;
+                this.bumpPending();
+                // A follow-up the harness queued starts in the same turn of the event loop; settle after it.
+                setImmediate(() => {
+                    if (this.activeRunId || this.disposed)
+                        return;
+                    for (const settled of this.settledListeners)
+                        settled();
+                });
+            }
+        }));
+    }
+    /** The subagents of the active reply: their approvals and questions are this terminal's too. */
+    children() {
+        if (!this.activeRunId)
+            return [];
+        try {
+            return recordedSubagents(this.context.root, this.activeRunId);
+        }
+        catch {
+            return [];
+        }
+    }
+    isOwnChild(runId) {
+        return this.children().includes(runId);
+    }
+    append(event) {
+        const type = event?.type;
+        const last = this.journal.at(-1);
+        // A streaming update carries the whole message so far, so a newer one replaces one not yet read.
+        if (type === 'message_update' && last?.event?.type === 'message_update')
+            this.journal.pop();
+        this.journal.push({ seq: ++this.seq, event });
+        if (this.journal.length > JOURNAL)
+            this.journal.splice(0, this.journal.length - JOURNAL);
+        for (const wake of this.waiters)
+            wake();
+    }
+    bumpPending() {
+        this.pendingRevision += 1;
+        for (const wake of this.pendingWaiters)
+            wake();
+    }
+    async wait(set, ms) {
+        await new Promise((resolve) => {
+            const wake = () => { clearTimeout(timer); set.delete(wake); resolve(); };
+            const timer = setTimeout(wake, ms);
+            timer.unref?.();
+            set.add(wake);
+        });
+    }
+    known = { nativeSessionId: null, sessionFile: null };
+    /** Pi's id of this terminal's conversation, as its harness runs record it. */
+    get nativeSessionId() {
+        const live = this.sessions.live.status(this.context.sessionId);
+        if (live)
+            this.known = { nativeSessionId: live.nativeSessionId, sessionFile: live.sessionFile ?? this.known.sessionFile };
+        return this.known.nativeSessionId;
+    }
+    /** The history file of this terminal's conversation, once it has one. */
+    get sessionFile() {
+        void this.nativeSessionId;
+        return this.known.sessionFile;
+    }
+    /** The reply running now, if one is. */
+    get activeRun() {
+        return this.activeRunId;
+    }
+    /** Called each time the terminal's replies have all settled and nothing else is queued. */
+    onSettled(listener) {
+        this.settledListeners.add(listener);
+        return () => { this.settledListeners.delete(listener); };
+    }
+    /** The run this terminal is showing, or the last one it finished. */
+    get lastRun() {
+        return this.activeRunId ?? this.lastRunId;
+    }
+    async call(call, params) {
+        if (this.disposed)
+            throw new HarnessError('run_not_active', 'This terminal session has closed.');
+        switch (call) {
+            case 'terminal.live.state': return this.state();
+            case 'terminal.live.events': return this.events(params);
+            case 'terminal.live.run': return this.run(params);
+            case 'terminal.live.steer': {
+                const text = this.text(params);
+                if (!this.activeRunId)
+                    throw new HarnessError('run_not_active', 'No reply is running to steer.');
+                await this.runs.steer(this.activeRunId, text);
+                return { runId: this.activeRunId };
+            }
+            case 'terminal.live.followUp': {
+                const result = await this.sessions.followUp(this.context.sessionId, this.text(params));
+                if ('runId' in result)
+                    this.started(result.runId);
+                return result;
+            }
+            case 'terminal.live.followUp.clear': return { removed: this.sessions.live.clearQueue(this.context.sessionId) };
+            case 'terminal.live.interrupt': {
+                const runId = this.activeRunId;
+                // The run is stopped and recorded at once; Pi's own abort finishes after the reply returns, so
+                // the window never waits on a provider stream that is slow to close.
+                if (runId)
+                    void this.runs.interrupt(runId).catch(() => undefined);
+                return { runId };
+            }
+            case 'terminal.live.close': {
+                void this.nativeSessionId;
+                // A new or switched conversation: what this terminal knows comes from its next run.
+                if (params.forget === true)
+                    this.known = { nativeSessionId: null, sessionFile: null };
+                if (params.reload === true)
+                    this.listed = null;
+                return this.sessions.closeLive(this.context.sessionId);
+            }
+            case 'terminal.live.rename': {
+                const name = this.text(params).trim().slice(0, 200);
+                // The live session writes its own history; a saved one is renamed in place.
+                const session = this.sessions.live.session(this.context.sessionId);
+                if (session?.setSessionName && !this.activeRunId) {
+                    session.setSessionName(name);
+                    return { name };
+                }
+                if (this.activeRunId)
+                    throw new HarnessError('session_busy', 'Rename the conversation after the reply settles.');
+                const file = typeof params.sessionFile === 'string' ? params.sessionFile : undefined;
+                return renameHistory({ sessionDir: this.context.sessionDir, ...(file ? { sessionFile: file } : {}), cwd: this.context.cwd, name });
+            }
+            case 'terminal.live.pending': return { revision: this.pendingRevision, requests: this.pending(params.ownDialogs === true) };
+            case 'terminal.live.pending.wait': {
+                if (params.revision === this.pendingRevision)
+                    await this.wait(this.pendingWaiters, WAIT_MS);
+                return { revision: this.pendingRevision, requests: this.pending(params.ownDialogs === true) };
+            }
+            case 'terminal.live.approve': return this.approve(params);
+            case 'terminal.live.answer': return this.answer(params);
+            case 'terminal.live.answers': return this.answers(params);
+            default: throw invalid(`Unknown live terminal operation ${call}.`);
+        }
+    }
+    text(params) {
+        if (typeof params.text !== 'string' || !params.text.trim())
+            throw invalid('Text is required.');
+        return params.text;
+    }
+    listed = null;
+    async state() {
+        const live = this.sessions.live.status(this.context.sessionId);
+        const session = this.sessions.live.session(this.context.sessionId);
+        const view = session ? sessionView(session) : null;
+        // Before the first turn there is no live session to ask; the trusted extensions are listed instead.
+        const commands = view ? view.commands : await (this.listed ??= (this.context.commands?.() ?? Promise.resolve([])).catch((error) => {
+            this.listed = null;
+            throw error;
+        }));
+        return {
+            seq: this.seq,
+            activeRunId: this.activeRunId,
+            lastRunId: this.lastRunId,
+            live,
+            session: view,
+            commands
+        };
+    }
+    async events(params) {
+        const after = typeof params.after === 'number' && Number.isFinite(params.after) ? params.after : 0;
+        const read = () => {
+            const first = this.journal[0]?.seq ?? this.seq + 1;
+            // Events the client missed were dropped: it must read the session again.
+            const reset = after > 0 && after < first - 1;
+            return { seq: this.seq, events: this.journal.filter((entry) => entry.seq > after), reset };
+        };
+        let result = read();
+        if (!result.events.length && params.wait !== false) {
+            await this.wait(this.waiters, typeof params.waitMs === 'number' ? Math.min(Math.max(params.waitMs, 0), WAIT_MS) : WAIT_MS);
+            result = read();
+        }
+        return result;
+    }
+    started(runId) {
+        this.activeRunId = runId;
+        this.lastRunId = runId;
+        this.bumpPending();
+    }
+    async run(params) {
+        const { context } = this;
+        if (this.activeRunId)
+            throw new HarnessError('session_busy', 'A reply is running. Steer it, or queue the message as a follow-up.');
+        const text = typeof params.text === 'string' ? params.text : '';
+        const command = params.command;
+        if (!text.trim() && !command)
+            throw invalid('Text is required.');
+        const images = Array.isArray(params.images) ? params.images.filter((image) => !!image && typeof image.mediaType === 'string' && typeof image.data === 'string') : undefined;
+        const resume = params.resume && typeof params.resume === 'object'
+            ? { sessionFile: typeof params.resume.sessionFile === 'string' ? params.resume.sessionFile : null,
+                nativeSessionId: typeof params.resume.nativeSessionId === 'string' ? params.resume.nativeSessionId : null }
+            : null;
+        const runId = randomUUID();
+        const native = context.readOnly ? TERMINAL_NATIVE_TOOLS.filter((name) => !['bash', 'edit', 'write'].includes(name)) : TERMINAL_NATIVE_TOOLS;
+        const allow = [...new Set([...native, ...(await context.tools?.() ?? [])])];
+        const input = {
+            run: { id: runId, sessionId: context.sessionId, sessionType: 'terminal', mode: 'code' },
+            accountId: context.accountId,
+            model: typeof params.model === 'string' ? params.model : null,
+            effort: typeof params.effort === 'string' ? params.effort : null,
+            cwd: context.cwd,
+            sessionDir: context.sessionDir,
+            ...(resume?.sessionFile ? { resume } : {}),
+            ...(params.newHistory === true && !resume?.sessionFile ? { newHistory: true } : {}),
+            text: command ? `/${command.name}` : text,
+            ...(images?.length ? { images } : {}),
+            ...(typeof params.initialBashCommand === 'string' ? { initialBashCommand: params.initialBashCommand } : {}),
+            caller: context.caller,
+            variant: context.variant,
+            launch: context.launch,
+            tools: { allow, gated: [] },
+            connections: context.connections,
+            ...(context.subagents !== undefined ? { subagents: context.subagents } : {}),
+            // The terminal sends a plan only the tools it may use, as the in-process terminal does.
+            ...(params.plan === true ? { plan: true, planTools: 'active' } : {}),
+            ...(params.goal && typeof params.goal === 'object' ? { goal: params.goal } : {}),
+            ...(Array.isArray(params.hiddenNotes) && params.hiddenNotes.length ? { hiddenNotes: params.hiddenNotes } : {}),
+            ...(command ? { command } : { live: true })
+        };
+        this.started(runId);
+        try {
+            const result = await this.sessions.run(input);
+            if (!result.nativeSessionId)
+                this.activeRunId = null;
+            return result;
+        }
+        catch (error) {
+            this.activeRunId = null;
+            this.bumpPending();
+            throw error;
+        }
+    }
+    /** The decisions waiting; `ownDialogs` leaves out plugin dialogs the window shows itself. */
+    pending(ownDialogs = false) {
+        const runId = this.activeRunId;
+        if (!runId)
+            return [];
+        return [runId, ...this.children()].flatMap((id) => {
+            try {
+                return pendingDecisions(readEvents(this.context.root, id)).filter((decision) => !ownDialogs || !decision.payload.dialog).map((decision) => ({
+                    ...decision.payload,
+                    type: decision.kind,
+                    requestId: decision.id,
+                    runId: id
+                }));
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    decision(params, kind) {
+        const requestId = typeof params.requestId === 'string' ? params.requestId : '';
+        const request = this.pending().find((entry) => entry.requestId === requestId && entry.type === kind);
+        if (!request)
+            throw new HarnessError('invalid_request', 'This terminal decision is no longer pending.');
+        return request;
+    }
+    approve(params) {
+        const request = this.decision(params, 'approval');
+        const decision = params.decision === 'approved' ? 'approved' : params.decision === 'denied' ? 'denied' : null;
+        if (!decision)
+            throw invalid('A decision must be approved or denied.');
+        if (decision === 'approved' && params.alwaysAllow === true) {
+            if (request.rememberable !== true || typeof request.target !== 'string')
+                throw invalid('This action cannot be always allowed.');
+            this.context.allowTool(request.target);
+        }
+        this.runs.resolveApproval(String(request.runId), String(request.requestId), decision);
+        return {};
+    }
+    answer(params) {
+        const request = this.decision(params, 'question');
+        this.runs.answerQuestion(String(request.runId), String(request.requestId), params.answer);
+        return {};
+    }
+    answers(params) {
+        const batch = this.pending().find((entry) => entry.batchId === params.batchId);
+        if (!batch || typeof params.batchId !== 'string' || !Array.isArray(params.answers))
+            throw invalid('This question batch is no longer pending.');
+        this.runs.answerQuestions(String(batch.runId), params.batchId, params.answers);
+        return {};
+    }
+    /** A message from another surface of this terminal (remote control): a new reply, or a follow-up. */
+    async send(text) {
+        if (this.activeRunId)
+            return this.sessions.followUp(this.context.sessionId, text);
+        const state = this.sessions.live.status(this.context.sessionId);
+        const result = await this.run({ text, ...(state?.sessionFile ? { resume: { sessionFile: state.sessionFile, nativeSessionId: state.nativeSessionId } } : {}) });
+        return { runId: result.runId };
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (this.activeRunId)
+            await this.runs.interrupt(this.activeRunId).catch(() => undefined);
+        for (const stop of this.stops.splice(0))
+            stop();
+        this.sessions.closeLive(this.context.sessionId);
+        for (const wake of [...this.waiters, ...this.pendingWaiters])
+            wake();
+    }
+}
+function sessionView(session) {
+    const commands = (() => {
+        try {
+            return (session.extensionRunner?.getRegisteredCommands() ?? []).map((command) => ({
+                name: command.name,
+                invocationName: command.invocationName ?? command.name,
+                description: command.description ?? '',
+                sourceInfo: command.sourceInfo ?? null
+            }));
+        }
+        catch {
+            return [];
+        }
+    })();
+    const usage = (() => {
+        try {
+            return session.getContextUsage?.() ?? null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    return {
+        sessionId: session.sessionId,
+        sessionFile: session.sessionFile ?? null,
+        sessionName: session.sessionName ?? null,
+        systemPrompt: session.systemPrompt ?? '',
+        model: session.model ? { id: session.model.id, provider: session.model.provider, name: session.model.name ?? session.model.id, reasoning: !!session.model.reasoning, contextWindow: session.model.contextWindow ?? 0, input: session.model.input ?? ['text'] } : null,
+        thinkingLevel: session.thinkingLevel ?? null,
+        isStreaming: !!session.isStreaming,
+        activeTools: session.getActiveToolNames?.() ?? [],
+        tools: (session.getAllTools?.() ?? []).map((tool) => ({ name: tool.name, description: tool.description ?? '' })),
+        steering: [...(session.getSteeringMessages?.() ?? [])],
+        followUp: [...(session.getFollowUpMessages?.() ?? [])],
+        context: usage ? { percent: usage.percent ?? null, window: usage.contextWindow ?? 0 } : null,
+        commands
+    };
+}

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

@@ -1,7 +1,8 @@
 import { spawn as nodeSpawn } from 'node:child_process';
 import { type SecretStore } from "../accounts/secrets.js";
-import { type SecretBackendDescriptor } from "../core/interactiveProfile.js";
+import { type InteractiveProfile, type SecretBackendDescriptor } from "../core/interactiveProfile.js";
 import { type Harness, type HarnessOptions } from "../harness.js";
+import type { TerminalLaunch } from "./terminals.js";
 export interface StandalonePaths {
     dataRoot: string;
     stateDir: string;
@@ -16,6 +17,11 @@ export interface StandalonePaths {
     variant?: string | null;
     /** `--remote-control`, `--rc`: turn on `/remote-control` as the terminal opens. */
     remoteControl?: boolean;
+    /**
+     * `--daemon`: run in the long-lived harness for these folders, starting it when it is not running,
+     * so a reply outlives this window (ADR-0083). The frontend is then a client of the harness.
+     */
+    daemon?: boolean;
 }
 export interface StandaloneDependencies {
     home?: string;
@@ -30,5 +36,17 @@ export interface StandaloneDependencies {
     spawn?: typeof nodeSpawn;
 }
 export declare function standaloneArguments(argv: string[]): string[] | null;
+export interface ResolvedStandaloneOptions {
+    paths: StandalonePaths;
+    profile: InteractiveProfile;
+}
+export declare function resolveStandaloneOptions(argv: string[], home?: string, cwd?: string): ResolvedStandaloneOptions;
+/** The harness a standalone launch, or the long-lived harness for the same folders, runs. */
+export declare function createStandaloneHarness(paths: StandalonePaths, profile: InteractiveProfile, dependencies?: Pick<StandaloneDependencies, 'createHarness' | 'hostSecretStore'>): Promise<Harness>;
+/** What every launch needs before its first terminal: the profile's default variant and an account. */
+export declare function ensureStandaloneDefaults(harness: Harness, paths: StandalonePaths, profile: InteractiveProfile): string;
+/** Where a terminal in `cwd` keeps its compiled instructions and native history. */
+export declare function terminalSessionFolder(dataRoot: string, cwd: string): string;
 export declare function parseStandaloneOptions(argv: string[], home?: string, cwd?: string): StandalonePaths;
+export declare function spawnFrontend(launch: TerminalLaunch, cwd: string, spawn?: typeof nodeSpawn): Promise<number>;
 export declare function runStandaloneTerminal(argv: string[], dependencies?: StandaloneDependencies): Promise<number>;

package/dist/sdk/terminal/standalone.js

@@ -18,19 +18,24 @@ export function standaloneArguments(argv) {
         return argv;
     return command === 'terminal' ? argv.slice(1) : null;
 }
-function resolveStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
+export function resolveStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
     const overrides = {};
     const given = new Set();
     let worktree;
     let variant;
     let accountState;
     let remoteControl = false;
+    let daemon = false;
     for (let index = 0; index < argv.length; index += 1) {
         const argument = argv[index];
         if (argument === '--remote-control' || argument === '--rc') {
             remoteControl = true;
             continue;
         }
+        if (argument === '--daemon') {
+            daemon = true;
+            continue;
+        }
         if (argument === '--worktree' || argument === '-w') {
             const name = argv[index + 1];
             if (name && !name.startsWith('-')) {
@@ -113,10 +118,41 @@ function resolveStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
             ...(accountState !== undefined ? { accountState } : {}),
             ...(worktree !== undefined ? { worktree } : {}),
             ...(variant !== undefined ? { variant } : {}),
-            ...(remoteControl ? { remoteControl } : {})
+            ...(remoteControl ? { remoteControl } : {}),
+            ...(daemon ? { daemon } : {})
         }
     };
 }
+/** The harness a standalone launch, or the long-lived harness for the same folders, runs. */
+export async function createStandaloneHarness(paths, profile, dependencies = {}) {
+    // `--account-state` takes both halves of another state's account identity, so its credentials
+    // come from that state's own file store rather than from this launch's profile backend.
+    const secrets = paths.accountState
+        ? fileSecretStore(join(paths.accountState, 'secrets.json'))
+        : await interactiveProfileSecretStore(profile, dependencies.hostSecretStore);
+    const makeHarness = dependencies.createHarness ?? createHarness;
+    return makeHarness({
+        dataRoot: paths.dataRoot,
+        stateDir: paths.stateDir,
+        ...(paths.accountState ? { accountsDir: join(paths.accountState, 'accounts') } : {}),
+        productName: DEFAULT_PRODUCT_NAME,
+        secrets
+    });
+}
+/** What every launch needs before its first terminal: the profile's default variant and an account. */
+export function ensureStandaloneDefaults(harness, paths, profile) {
+    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');
+    return variantScope;
+}
+/** Where a terminal in `cwd` keeps its compiled instructions and native history. */
+export function terminalSessionFolder(dataRoot, cwd) {
+    return join(dataRoot, 'sessions', 'terminal', createHash('sha256').update(cwd).digest('hex'));
+}
 export function parseStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
     return resolveStandaloneOptions(argv, home, cwd).paths;
 }
@@ -148,7 +184,7 @@ function spawnError(error, launch) {
     const problem = code === 'ENOENT' ? 'was not found' : `could not start (${code})`;
     return new Error(`Could not start the Harness terminal. The Bun executable "${launch.program}" ${problem}; install Bun or set XINGULAR_HARNESS_BUN, then run npm run build:tui.`, { cause: error });
 }
-function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
+export function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
     return new Promise((resolveExit, reject) => {
         const child = spawn(launch.program, launch.args, {
             cwd,
@@ -156,10 +192,13 @@ function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
             stdio: 'inherit'
         });
         let settled = false;
+        let fatal = false;
         const cleanup = () => {
             process.off('SIGINT', onInterrupt);
             process.off('SIGTERM', onTerminate);
             process.off('SIGHUP', onHangup);
+            process.off('uncaughtException', onFatal);
+            process.off('unhandledRejection', onFatal);
         };
         const finish = (action) => {
             if (settled)
@@ -174,12 +213,36 @@ function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
         const onTerminate = () => {
             child.kill('SIGTERM');
         };
-        const onHangup = () => undefined;
+        // The window closed: its frontend gets the same hangup and should end. One that is still there
+        // after a moment has no terminal left to restore, so it is ended, and this host carries on
+        // (a detached reply keeps running in the long-lived harness).
+        const onHangup = () => {
+            setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+            }, 3000).unref();
+        };
+        // A client frontend's plugins run in this process (ADR-0083). An error nothing caught ends it, as
+        // it ends an in-process frontend, but the window closes first so the terminal is left as it was.
+        const onFatal = (error) => {
+            if (fatal)
+                return;
+            fatal = true;
+            process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+            child.kill('SIGTERM');
+            setTimeout(() => process.exit(1), 5000).unref();
+        };
         process.on('SIGINT', onInterrupt);
+        process.on('uncaughtException', onFatal);
+        process.on('unhandledRejection', onFatal);
         process.on('SIGTERM', onTerminate);
         process.on('SIGHUP', onHangup);
         child.once('error', (error) => finish(() => reject(spawnError(error, launch))));
-        child.once('exit', (code, signal) => finish(() => resolveExit(exitCode(code, signal))));
+        child.once('exit', (code, signal) => {
+            if (fatal)
+                process.exit(1);
+            finish(() => resolveExit(exitCode(code, signal)));
+        });
     });
 }
 /**
@@ -206,19 +269,11 @@ export async function runStandaloneTerminal(argv, dependencies = {}) {
     }
     let cwd = resolve(dependencies.cwd ?? process.cwd());
     const { paths, profile } = resolveStandaloneOptions(argv, dependencies.home, cwd);
-    // `--account-state` takes both halves of another state's account identity, so its credentials
-    // come from that state's own file store rather than from this launch's profile backend.
-    const secrets = paths.accountState
-        ? fileSecretStore(join(paths.accountState, 'secrets.json'))
-        : await interactiveProfileSecretStore(profile, dependencies.hostSecretStore);
-    const makeHarness = dependencies.createHarness ?? createHarness;
-    const harness = makeHarness({
-        dataRoot: paths.dataRoot,
-        stateDir: paths.stateDir,
-        ...(paths.accountState ? { accountsDir: join(paths.accountState, 'accounts') } : {}),
-        productName: DEFAULT_PRODUCT_NAME,
-        secrets
-    });
+    if (paths.daemon) {
+        const { runDaemonTerminal } = await import("./daemon.js");
+        return runDaemonTerminal({ paths, profile, cwd, ...(dependencies.spawn ? { spawn: dependencies.spawn } : {}), ...(dependencies.createSessionId ? { createSessionId: dependencies.createSessionId } : {}) });
+    }
+    const harness = await createStandaloneHarness(paths, profile, dependencies);
     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.
@@ -233,12 +288,7 @@ 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 variantScope = ensureStandaloneDefaults(harness, paths, profile);
         let worktreeId = null;
         if (paths.worktree) {
             const worktree = await enterWorktree(harness, cwd, paths.worktree);
@@ -248,7 +298,7 @@ export async function runStandaloneTerminal(argv, dependencies = {}) {
         // The version this conversation runs: the head at start, or one the person switched to (PROP-0052).
         let variantVersion = null;
         for (;;) {
-            const sessionFolder = join(paths.dataRoot, 'sessions', 'terminal', createHash('sha256').update(cwd).digest('hex'));
+            const sessionFolder = terminalSessionFolder(paths.dataRoot, cwd);
             const launch = await harness.terminals.prepare({ ...current, cwd, sessionFolder, variant: { scope: variantScope, ...(variantVersion ? { version: variantVersion } : {}) }, ...(worktreeId ? { run: { worktreeId } } : {}) });
             const code = await spawnFrontend(paths.remoteControl ? { ...launch, env: { ...launch.env, [REMOTE_CONTROL_ENV]: '1' } } : launch, cwd, dependencies.spawn);
             // `/accounts` and `/worktree` ask for a switch and end the frontend. An account switch resumes