@minionry/minion 0.7.36

package/dist/server/services/websocket/sdk-agent-host.js

@@ -0,0 +1,569 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { join } from 'node:path';
+import { engineNoticeErrorCode } from '../../cli/headless/claude-invoker-stream.js';
+import { CANCELLED_MOVEMENT_ERROR } from '../../cli/improvisation-movements.js';
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { HERMES_ALL_TOOLSETS } from '../../engines/hermes/hermes-gateway-home.js';
+import { ENGINE_EFFORT_LEVELS, engineForModel } from '../../engines/types.js';
+import { getClientId } from '../client-id.js';
+import { setSdkSessionHost, } from '../sdk/agent-sessions.js';
+import { cancelAppRunForClosedTab, setSdkAgentHost } from '../sdk/agents.js';
+import { recordAppRunTokens } from '../sdk/rate-limits.js';
+import { SdkMethodError } from '../sdk/registry.js';
+import { deriveRunProfile, WORKSPACE_WRITE_TOOLS } from '../sdk/run-profile.js';
+import { provisionAppSandbox } from '../sdk/sandbox.js';
+import { getEffortLevel, getFastMode, getModel, makeSpaceKey } from '../settings.js';
+import { parseErrorMarker } from '../timeline/index.js';
+import { getPendingQuestionTab, resolvePendingQuestion } from './ask-user-question-bridge.js';
+import { clearScope } from './handler-context.js';
+import { slugify } from './quality-persistence.js';
+import { setQualityReviewHost, } from './quality-review-agent.js';
+import { resolveEngineForSession, runAcceptedExecute, setupSessionListeners } from './session-handlers.js';
+import { broadcastTabEvent } from './tab-broadcast.js';
+import { planSeqReplay } from './tab-event-replay.js';
+const APP_HOST_WS = { send: () => { }, close: () => { }, readyState: 3 };
+function claudeCodeSessionDefaults() {
+    const model = getModel();
+    const effortLevel = getEffortLevel();
+    return {
+        ...(engineForModel(model) === 'claude-code' ? { model } : {}),
+        ...(ENGINE_EFFORT_LEVELS['claude-code'].includes(effortLevel) ? { effortLevel } : {}),
+        fastMode: getFastMode(),
+    };
+}
+function selectionSessionOptions(selection) {
+    return {
+        ...(selection.model ? { model: selection.model } : {}),
+        effortLevel: selection.effortLevel,
+        fastMode: selection.fastMode,
+    };
+}
+const workspaceNotedSessions = new WeakSet();
+function withWorkspaceNote(session, prompt) {
+    const note = session.appOrigin?.profile?.workspaceNote;
+    if (!note || workspaceNotedSessions.has(session))
+        return prompt;
+    workspaceNotedSessions.add(session);
+    return `${note}\n\n${prompt}`;
+}
+export function installSdkAgentHost(ctx) {
+    setSdkAgentHost((start) => Promise.resolve(createAppAgentRun(ctx, start)));
+}
+const APP_RUN_ENGINE_HOME_DIRNAME = 'hermes';
+function createAppAgentRun(ctx, start) {
+    if (start.continuation)
+        return continueAppAgentRun(ctx, start, start.continuation.tabId);
+    const registry = ctx.getRegistry(start.workingDir);
+    const tabId = `tab-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const sandbox = provisionAppSandbox(start.workingDir, start.appId);
+    const profile = { ...start.profile, cwd: sandbox.dataDir };
+    const { model, selection } = start;
+    const session = new ImprovisationSessionManager({
+        workingDir: start.workingDir,
+        ...(selection ? selectionSessionOptions(selection) : claudeCodeSessionDefaults()),
+        agentLabel: start.appId,
+        appOrigin: { appId: start.appId, origin: start.origin, grantScopes: [...start.grantScopes], profile },
+        ...(model
+            ? {
+                appRun: {
+                    appId: start.appId,
+                    homeDir: join(sandbox.root, APP_RUN_ENGINE_HOME_DIRNAME),
+                    cwd: sandbox.dataDir,
+                    disabledToolsets: HERMES_ALL_TOOLSETS,
+                    maxTurns: model.maxTurns,
+                    runBudgetSeconds: model.maxSeconds,
+                },
+                ...(model.systemPrompt ? { appSystemPrompt: model.systemPrompt } : {}),
+            }
+            : {}),
+    });
+    if (model)
+        session.applyOverrides({ engine: model.engine, model: model.value });
+    setupSessionListeners(ctx, session, APP_HOST_WS, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    registry.registerTab(tabId, sessionId, start.tabName, undefined, {
+        appId: start.appId,
+        origin: start.origin,
+    });
+    if (model) {
+        registry.updateTabEngineOverride(tabId, {
+            engine: model.engine,
+            model: model.value,
+            effortLevel: getEffortLevel() || 'auto',
+            fastMode: getFastMode(),
+        });
+    }
+    else if (selection) {
+        registry.updateTabEngineOverride(tabId, {
+            engine: selection.engine,
+            model: selection.model ?? 'default',
+            effortLevel: selection.effortLevel,
+            fastMode: selection.fastMode,
+            ultracode: false,
+        });
+    }
+    const registeredTab = registry.getTab(tabId);
+    const engine = resolveEngineForSession(session);
+    ctx.broadcastToAll({
+        type: 'tabCreated',
+        engine,
+        data: {
+            tabId,
+            tabName: registeredTab?.tabName || start.tabName,
+            createdAt: registeredTab?.createdAt,
+            order: registeredTab?.order,
+            engine,
+            sessionInfo: session.getSessionInfo(),
+            appLink: { appId: start.appId, origin: start.origin },
+        },
+    });
+    return {
+        tabId,
+        sessionId,
+        start: () => runPrompt(session, start),
+        cancel: () => session.cancel(),
+        broadcast: (response) => ctx.broadcastToAll(response),
+        isExecuting: () => session.isExecuting,
+        ...(model ? { modelValue: model.value } : {}),
+    };
+}
+function continueAppAgentRun(ctx, start, tabId) {
+    const regTab = ctx.getRegistry(start.workingDir).getTab(tabId);
+    const session = regTab ? ctx.sessions.get(regTab.sessionId) : undefined;
+    if (!regTab || !session) {
+        throw new SdkMethodError('BAD_REQUEST', `session '${tabId}' has no open tab — start a new run`);
+    }
+    if (regTab.appLink?.appId !== start.appId || session.appOrigin?.appId !== start.appId) {
+        throw new SdkMethodError('BAD_REQUEST', `unknown sessionId '${tabId}' — agents.run continues only a session this app started`);
+    }
+    if (session.isExecuting) {
+        throw new SdkMethodError('BAD_REQUEST', `session_busy: session '${tabId}' is still running a turn — wait for its result() before continuing it`);
+    }
+    const pin = start.continuation?.model;
+    const engine = resolveEngineForSession(session);
+    if (!pin && engine !== 'claude-code') {
+        throw new SdkMethodError('ENGINE_UNAVAILABLE', `agents.run: session '${tabId}' now runs on ${engine}, which can't run an app's turn with tools — start a new run`);
+    }
+    return {
+        tabId,
+        sessionId: regTab.sessionId,
+        start: () => {
+            if (pin)
+                session.applyOverrides({ engine: pin.engine, model: pin.value });
+            return runPrompt(session, start);
+        },
+        cancel: () => session.cancel(),
+        broadcast: (response) => ctx.broadcastToAll(response),
+        isExecuting: () => session.isExecuting,
+        ...(pin ? { modelValue: pin.value } : {}),
+    };
+}
+async function runPrompt(session, start) {
+    try {
+        const movement = await session.executePrompt(withWorkspaceNote(session, start.prompt));
+        if (typeof movement.tokensUsed === 'number' && movement.tokensUsed > 0) {
+            recordAppRunTokens(start.appId, start.spaceKey, movement.tokensUsed);
+        }
+        const text = movement.assistantResponse ?? '';
+        if (movement.errorOutput === CANCELLED_MOVEMENT_ERROR) {
+            return { status: 'cancelled', text };
+        }
+        if (!movement.assistantResponse && movement.errorOutput) {
+            return { status: 'error', text: withoutErrorMarker(movement.errorOutput) };
+        }
+        return { status: 'done', text };
+    }
+    catch (error) {
+        return { status: 'error', text: withoutErrorMarker(error instanceof Error ? error.message : String(error)) };
+    }
+}
+function withoutErrorMarker(message) {
+    return parseErrorMarker(message)?.text ?? message;
+}
+export function installSdkSessionHost(ctx) {
+    const host = {
+        list: (workingDir) => listSdkSessions(ctx, workingDir),
+        create: (args) => createSdkSession(ctx, args),
+        attach: (args) => attachSdkSession(ctx, args),
+        close: (args) => closeSdkSession(ctx, args),
+        rename: (args) => renameSdkSession(ctx, args),
+        history: (args) => sdkSessionHistory(ctx, args),
+        replay: (args) => sdkSessionReplay(ctx, args),
+        approve: (args) => approveSdkSession(ctx, args),
+        answerQuestion: (args) => answerSdkSessionQuestion(ctx, args),
+        prompt: (args) => promptSdkSession(ctx, args),
+        stop: (args) => stopSdkSession(ctx, args),
+    };
+    setSdkSessionHost(host);
+}
+function toSdkSessionSummary(args) {
+    return {
+        id: args.tabId,
+        name: args.tabName,
+        createdAt: args.createdAt,
+        lastActivityAt: args.lastActivityAt,
+        isExecuting: args.isExecuting,
+    };
+}
+function listSdkSessions(ctx, workingDir) {
+    const registry = ctx.getRegistry(workingDir);
+    const summaries = [];
+    for (const [tabId, regTab] of Object.entries(registry.getAllTabs())) {
+        if (regTab.webManaged)
+            continue;
+        summaries.push(toSdkSessionSummary({
+            tabId,
+            tabName: regTab.tabName,
+            createdAt: regTab.createdAt,
+            lastActivityAt: regTab.lastActivityAt,
+            isExecuting: ctx.sessions.get(regTab.sessionId)?.isExecuting === true,
+        }));
+    }
+    return summaries;
+}
+function createSdkSession(ctx, args) {
+    const registry = ctx.getRegistry(args.workingDir);
+    const tabId = `tab-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const sandbox = provisionAppSandbox(args.workingDir, args.appId);
+    const profile = {
+        ...deriveRunProfile({ appId: args.appId, origin: args.origin, grantScopes: args.grantScopes, workingDir: args.workingDir }),
+        cwd: sandbox.dataDir,
+    };
+    const session = new ImprovisationSessionManager({
+        workingDir: args.workingDir,
+        ...claudeCodeSessionDefaults(),
+        agentLabel: args.appId,
+        appOrigin: { appId: args.appId, origin: args.origin, grantScopes: [...args.grantScopes], profile },
+    });
+    setupSessionListeners(ctx, session, APP_HOST_WS, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    registry.registerTab(tabId, sessionId, args.name, undefined, { appId: args.appId, origin: args.origin });
+    const registeredTab = registry.getTab(tabId);
+    const engine = resolveEngineForSession(session);
+    ctx.broadcastToAll({
+        type: 'tabCreated',
+        engine,
+        data: {
+            tabId,
+            tabName: registeredTab?.tabName || 'Agent',
+            createdAt: registeredTab?.createdAt,
+            order: registeredTab?.order,
+            engine,
+            sessionInfo: session.getSessionInfo(),
+            appLink: { appId: args.appId, origin: args.origin },
+        },
+    });
+    return toSdkSessionSummary({
+        tabId,
+        tabName: registeredTab?.tabName ?? args.name ?? 'Agent',
+        createdAt: registeredTab?.createdAt ?? new Date().toISOString(),
+        lastActivityAt: registeredTab?.lastActivityAt ?? new Date().toISOString(),
+        isExecuting: session.isExecuting,
+    });
+}
+function resolveOrRehydrateSdkSession(ctx, workingDir, tabId) {
+    const registry = ctx.getRegistry(workingDir);
+    const regTab = registry.getTab(tabId);
+    if (!regTab)
+        return null;
+    const existing = ctx.sessions.get(regTab.sessionId);
+    if (existing)
+        return { registry, regTab, session: existing };
+    let session;
+    try {
+        session = ImprovisationSessionManager.resumeFromHistory(workingDir, regTab.sessionId);
+        registry.markTabPersisted(tabId);
+    }
+    catch {
+        session = new ImprovisationSessionManager({
+            workingDir,
+            sessionId: regTab.sessionId,
+            ...claudeCodeSessionDefaults(),
+        });
+    }
+    setupSessionListeners(ctx, session, APP_HOST_WS, tabId);
+    ctx.sessions.set(session.getSessionInfo().sessionId, session);
+    registry.touchTab(tabId);
+    return { registry, regTab, session };
+}
+function attachSdkSession(ctx, args) {
+    const resolved = resolveOrRehydrateSdkSession(ctx, args.workingDir, args.sessionId);
+    if (!resolved)
+        return null;
+    const { registry, session } = resolved;
+    const regTab = registry.getTab(args.sessionId) ?? resolved.regTab;
+    return toSdkSessionSummary({
+        tabId: args.sessionId,
+        tabName: regTab.tabName,
+        createdAt: regTab.createdAt,
+        lastActivityAt: regTab.lastActivityAt,
+        isExecuting: session.isExecuting,
+    });
+}
+function closeSdkSession(ctx, args) {
+    const registry = ctx.getRegistry(args.workingDir);
+    const tabId = args.sessionId;
+    if (!registry.getTab(tabId))
+        return false;
+    cancelAppRunForClosedTab(tabId);
+    registry.unregisterTab(tabId);
+    clearScope(ctx, tabId);
+    ctx.gitBranches.delete(tabId);
+    ctx.tabEventBuffers.delete(tabId);
+    ctx.chatTimelines.delete(tabId);
+    ctx.msgIdTracker.forget(tabId);
+    ctx.broadcastToAll({ type: 'tabRemoved', data: { tabId } });
+    return true;
+}
+function renameSdkSession(ctx, args) {
+    const registry = ctx.getRegistry(args.workingDir);
+    const tabId = args.sessionId;
+    const regTab = registry.getTab(tabId);
+    if (!regTab)
+        return null;
+    registry.updateTabName(tabId, args.name);
+    ctx.broadcastToAll({ type: 'tabRenamed', data: { tabId, tabName: args.name } });
+    const updated = registry.getTab(tabId) ?? regTab;
+    return toSdkSessionSummary({
+        tabId,
+        tabName: updated.tabName,
+        createdAt: updated.createdAt,
+        lastActivityAt: updated.lastActivityAt,
+        isExecuting: ctx.sessions.get(updated.sessionId)?.isExecuting === true,
+    });
+}
+const SDK_HISTORY_MAX_ENTRIES = 4000;
+const SDK_HISTORY_MAX_BYTES = 8 * 1024 * 1024;
+function sdkSessionHistory(ctx, args) {
+    const resolved = resolveOrRehydrateSdkSession(ctx, args.workingDir, args.sessionId);
+    if (!resolved)
+        return null;
+    const { session } = resolved;
+    try {
+        ctx.chatTimelines
+            .getOrCreate(args.sessionId)
+            .ensureSeeded(session.getHistory().movements, { executing: session.isExecuting });
+    }
+    catch (err) {
+        console.error(`[timeline] seed failed tabId=${args.sessionId}:`, err);
+    }
+    const seq = ctx.tabEventBuffers.getOrCreate(args.sessionId).currentSeq();
+    const snapshot = ctx.chatTimelines
+        .getOrCreate(args.sessionId)
+        .snapshot(seq, { maxEntries: SDK_HISTORY_MAX_ENTRIES, maxBytes: SDK_HISTORY_MAX_BYTES });
+    return { sessionId: args.sessionId, entries: snapshot.entries, seq: snapshot.seq };
+}
+function sdkSessionReplay(ctx, args) {
+    const registry = ctx.getRegistry(args.workingDir);
+    if (!registry.getTab(args.sessionId))
+        return { kind: 'not_found' };
+    const buffer = ctx.tabEventBuffers.getOrCreate(args.sessionId);
+    const plan = planSeqReplay(buffer, args.afterSeq);
+    if (plan.kind === 'gap') {
+        return { kind: 'gap', evictedThroughSeq: plan.evictedThroughSeq, currentSeq: plan.currentSeq };
+    }
+    const events = [];
+    for (const event of plan.events) {
+        if (event.type === 'timelineEvent')
+            events.push(event.data);
+    }
+    return {
+        kind: 'ok',
+        result: { sessionId: args.sessionId, fromSeq: args.afterSeq, events, currentSeq: buffer.currentSeq() },
+    };
+}
+function approveSdkSession(ctx, args) {
+    const resolved = resolveOrRehydrateSdkSession(ctx, args.workingDir, args.sessionId);
+    if (!resolved)
+        return false;
+    resolved.session.respondToApproval(args.approved);
+    broadcastTabEvent(ctx, args.sessionId, 'output', { text: args.approved ? '\n✅ Approved - proceeding with operation\n' : '\n🚫 Rejected - operation cancelled\n' });
+    return true;
+}
+function answerSdkSessionQuestion(ctx, args) {
+    if (!ctx.getRegistry(args.workingDir).getTab(args.sessionId))
+        return false;
+    if (getPendingQuestionTab(args.toolUseId) === args.sessionId) {
+        resolvePendingQuestion(args.toolUseId, args.answers);
+    }
+    return true;
+}
+function promptSdkSession(ctx, args) {
+    const resolved = resolveOrRehydrateSdkSession(ctx, args.workingDir, args.sessionId);
+    if (!resolved)
+        return null;
+    const { registry, session } = resolved;
+    const tabId = args.sessionId;
+    const prompt = withWorkspaceNote(session, args.prompt);
+    if (session.isExecuting) {
+        registry.enqueuePrompt(tabId, { prompt, attachments: args.attachments });
+        ctx.broadcastToAll({
+            type: 'promptQueueSync',
+            tabId,
+            data: { tabId, queue: registry.getPromptQueue(tabId) },
+        });
+        return { queued: true };
+    }
+    const input = { prompt, attachments: args.attachments };
+    runAcceptedExecute(ctx, session, input, tabId);
+    return { queued: false };
+}
+function stopSdkSession(ctx, args) {
+    const resolved = resolveOrRehydrateSdkSession(ctx, args.workingDir, args.sessionId);
+    if (!resolved)
+        return false;
+    resolved.session.cancel();
+    return true;
+}
+export function installSdkQualityReviewHost(ctx) {
+    setQualityReviewHost({ open: (args) => openQualityReviewSession(ctx, args) });
+}
+function openQualityReviewSession(ctx, args) {
+    const tabId = `quality-review-${slugify(args.reportPath)}-${Date.now()}`;
+    const { session } = openAttributedAgentTab(ctx, {
+        workingDir: args.workingDir,
+        tabId,
+        tabName: args.tabName,
+        agentLabel: args.initiator?.appId ?? 'quality-review',
+        engine: args.engine,
+        model: args.model,
+        effortLevel: args.effortLevel,
+        fastMode: args.fastMode,
+        ...(args.initiator ? { appLink: { ...args.initiator } } : {}),
+        disallowedTools: [...WORKSPACE_WRITE_TOOLS],
+    });
+    if (args.onToolUse) {
+        session.on('onToolUse', (event) => {
+            try {
+                args.onToolUse?.(event);
+            }
+            catch (error) {
+                console.error('[QualityReview] tool progress callback failed:', error);
+            }
+        });
+    }
+    return {
+        sessionId: tabId,
+        prompt: (text) => runQualityReviewPrompt(session, text, args),
+        cancel: () => session.cancel(),
+    };
+}
+async function runQualityReviewPrompt(session, text, args) {
+    const movement = await session.executePrompt(text, undefined, { workingDir: args.dirPath });
+    if (args.initiator && typeof movement.tokensUsed === 'number' && movement.tokensUsed > 0) {
+        recordAppRunTokens(args.initiator.appId, makeSpaceKey(getClientId(), args.workingDir), movement.tokensUsed);
+    }
+    const assistantText = movement.assistantResponse ?? '';
+    if (movement.errorOutput === CANCELLED_MOVEMENT_ERROR)
+        return { text: assistantText, cancelled: true };
+    const engineNotice = movement.outcome?.engineNotice;
+    const notice = engineNotice ? { code: engineNoticeErrorCode(engineNotice.kind), text: engineNotice.text } : undefined;
+    if (!movement.assistantResponse && movement.errorOutput) {
+        throw new Error(notice ? `[[MINIONRY_ERROR:${notice.code}]] ${notice.text}` : movement.errorOutput);
+    }
+    return { text: assistantText, cancelled: false, ...(notice ? { notice } : {}) };
+}
+export function openAttributedAgentTab(ctx, args) {
+    const registry = ctx.getRegistry(args.workingDir);
+    const session = new ImprovisationSessionManager({
+        workingDir: args.workingDir,
+        model: args.model,
+        effortLevel: args.effortLevel,
+        fastMode: args.fastMode,
+        agentLabel: args.agentLabel,
+        ...(args.appOrigin ? { appOrigin: args.appOrigin } : {}),
+        ...(args.disallowedTools?.length ? { disallowedTools: [...args.disallowedTools] } : {}),
+    });
+    session.applyOverrides({ engine: args.engine });
+    setupSessionListeners(ctx, session, APP_HOST_WS, args.tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    registry.registerTab(args.tabId, sessionId, args.tabName, undefined, args.appLink);
+    registry.updateTabEngineOverride(args.tabId, {
+        engine: args.engine,
+        model: args.model ?? 'default',
+        effortLevel: args.effortLevel ?? 'auto',
+        ...(args.fastMode !== undefined ? { fastMode: args.fastMode } : {}),
+    });
+    const registeredTab = registry.getTab(args.tabId);
+    const engine = resolveEngineForSession(session);
+    const tabName = registeredTab?.tabName || args.tabName || 'Agent';
+    ctx.broadcastToAll({
+        type: 'tabCreated',
+        engine,
+        data: {
+            tabId: args.tabId,
+            tabName,
+            createdAt: registeredTab?.createdAt,
+            order: registeredTab?.order,
+            engine,
+            sessionInfo: session.getSessionInfo(),
+            ...(args.appLink ? { appLink: { ...args.appLink } } : {}),
+        },
+    });
+    return { tabId: args.tabId, tabName, sessionId, session, engine };
+}
+const COMPANION_TAB_NAME_MAX = 48;
+const COMPANION_STEP_MARKER = '[[MINIONRY_BROWSER_STEP]]';
+const COMPANION_DONE_MARKER = '[[MINIONRY_BROWSER_DONE]]';
+const COMPANION_FAILED_MARKER = '[[MINIONRY_ERROR:BROWSER_TASK_FAILED]]';
+export function openBrowserCompanionTab(ctx, args) {
+    const { appId, origin } = args.initiator;
+    const tabId = `browser-agent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const grantScopes = [...(args.initiator.grantScopes ?? [])];
+    const sandbox = provisionAppSandbox(args.workingDir, appId);
+    const profile = {
+        ...deriveRunProfile({ appId, origin, grantScopes, workingDir: args.workingDir }),
+        cwd: sandbox.dataDir,
+    };
+    const name = companionTabName(args.task);
+    const tab = openAttributedAgentTab(ctx, {
+        workingDir: args.workingDir,
+        tabId,
+        ...(name ? { tabName: name } : {}),
+        agentLabel: appId,
+        engine: args.engine,
+        ...(args.model ? { model: args.model } : {}),
+        effortLevel: getEffortLevel(),
+        fastMode: getFastMode(),
+        appLink: { appId, origin },
+        appOrigin: { appId, origin, grantScopes, profile },
+    });
+    const startedAt = Date.now();
+    broadcastTabEvent(ctx, tabId, 'movementStart', { sequenceNumber: 1, prompt: args.task, timestamp: startedAt, executionStartTimestamp: startedAt }, tab.engine);
+    let settled = false;
+    return {
+        sessionId: tabId,
+        name: tab.tabName,
+        step: (detail) => {
+            if (settled)
+                return;
+            mirrorCompanionLine(ctx, tabId, tab.engine, COMPANION_STEP_MARKER, detail);
+        },
+        settle: (text, failed = false) => {
+            if (settled)
+                return;
+            settled = true;
+            mirrorCompanionLine(ctx, tabId, tab.engine, failed ? COMPANION_FAILED_MARKER : COMPANION_DONE_MARKER, text);
+            broadcastTabEvent(ctx, tabId, 'movementComplete', { sequenceNumber: 1, durationMs: Date.now() - startedAt, tokensUsed: 0 }, tab.engine);
+        },
+    };
+}
+export function companionTabName(task) {
+    const line = task
+        .split('\n')
+        .map((candidate) => candidate.trim())
+        .find((candidate) => candidate.length > 0);
+    if (!line)
+        return '';
+    return line.length > COMPANION_TAB_NAME_MAX ? `${line.slice(0, COMPANION_TAB_NAME_MAX - 1)}…` : line;
+}
+function mirrorCompanionLine(ctx, tabId, engine, marker, text) {
+    const line = text.replace(/\s+/g, ' ').trim();
+    if (!line)
+        return;
+    broadcastTabEvent(ctx, tabId, 'output', { text: `${marker} ${line}`, timestamp: Date.now() }, engine);
+}