@tt-a1i/hive 2.1.10 → 2.1.11

package/dist/src/server/external-goal-bridge.js

@@ -0,0 +1,299 @@
+import { EventEmitter } from 'node:events';
+import { escapeHiveEnvelopeAttribute, escapeHiveEnvelopeText } from './hive-envelope-escape.js';
+import { BadRequestError, ConflictError, ForbiddenError, HttpError, PtyInactiveError, } from './http-errors.js';
+import { serializeTeamListItem } from './team-list-serializer.js';
+import { getOrchestratorId } from './workspace-store-support.js';
+const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
+const MAX_WAIT_TIMEOUT_MS = 120_000;
+export class ExternalGoalDeliveryError extends PtyInactiveError {
+    cursor;
+    goalId;
+    status;
+    constructor(input) {
+        super(input.message);
+        this.name = 'ExternalGoalDeliveryError';
+        this.cursor = input.cursor;
+        this.goalId = input.goalId;
+        this.status = input.status;
+    }
+}
+const reportEventKind = (status) => {
+    if (status === 'progress')
+        return 'progress_reported';
+    if (status === 'done')
+        return 'goal_done';
+    if (status === 'blocked')
+        return 'goal_blocked';
+    return 'goal_failed';
+};
+const reportSessionStatus = (status) => {
+    if (status === 'progress')
+        return 'in_progress';
+    return status;
+};
+const closedForReport = new Set([
+    'blocked',
+    'done',
+    'failed',
+    'cancelled',
+]);
+const boundedTimeout = (value) => {
+    if (value === undefined)
+        return DEFAULT_WAIT_TIMEOUT_MS;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new BadRequestError('timeout_ms must be a non-negative number');
+    }
+    return Math.min(Math.floor(value), MAX_WAIT_TIMEOUT_MS);
+};
+const normalizedCursor = (value) => {
+    if (value === undefined)
+        return 0;
+    if (!Number.isInteger(value) || value < 0) {
+        throw new BadRequestError('cursor must be a non-negative integer');
+    }
+    return value;
+};
+const requireSession = (goalStore, goalId) => {
+    const session = goalStore.getSession(goalId);
+    if (!session)
+        throw new HttpError(404, `External goal not found: ${goalId}`);
+    return session;
+};
+const contextLines = (context) => {
+    if (context === undefined || context === null)
+        return [];
+    const body = typeof context === 'string' ? context : JSON.stringify(context, null, 2);
+    if (!body.trim())
+        return [];
+    return ['', 'Context:', escapeHiveEnvelopeText(body)];
+};
+const buildExternalGoalPayload = (session) => [
+    `<hive-message kind="external-goal" source="${escapeHiveEnvelopeAttribute(session.source)}" goal_id="${escapeHiveEnvelopeAttribute(session.id)}">`,
+    '',
+    'You received an external Supervisor goal.',
+    '',
+    'Rules:',
+    '- You are still the Hive Orchestrator for this workspace.',
+    '- Use current Hive members through `team list` and `team send`.',
+    '- Do not report final completion to the user directly; report to the external Supervisor with:',
+    `  team goal report --goal ${session.id} --status done --stdin`,
+    '- Use status `progress` for meaningful phase updates.',
+    '- Use status `blocked` when you need an external decision.',
+    '',
+    'Goal:',
+    escapeHiveEnvelopeText(session.goal),
+    ...contextLines(session.context),
+    '</hive-message>',
+    '',
+].join('\n');
+const buildExternalGoalContinuePayload = (session, message, context) => [
+    `<hive-message kind="external-goal-continue" goal_id="${escapeHiveEnvelopeAttribute(session.id)}">`,
+    '',
+    'The external Supervisor added context for this goal.',
+    '',
+    'Continue coordinating through Hive members as needed. Report meaningful updates with:',
+    `  team goal report --goal ${session.id} --status progress --stdin`,
+    '',
+    'Message:',
+    escapeHiveEnvelopeText(message),
+    ...contextLines(context),
+    '</hive-message>',
+    '',
+].join('\n');
+const buildExternalGoalCancelPayload = (session, reason) => [
+    `<hive-message kind="external-goal-cancel" goal_id="${escapeHiveEnvelopeAttribute(session.id)}">`,
+    '',
+    'Stop coordinating this external goal. Do not send more goal reports for it.',
+    '',
+    'MVP note: Hive did not automatically cancel member dispatches. Decide whether any open dispatches should be cancelled with `team cancel`.',
+    '',
+    'Reason:',
+    escapeHiveEnvelopeText(reason),
+    '</hive-message>',
+    '',
+].join('\n');
+export const createExternalGoalBridge = ({ deliverToOrchestrator, getActiveRunByAgentId, getAgent, getWorkspaceSnapshot, goalStore, listWorkers, listWorkspaces, }) => {
+    const events = new EventEmitter();
+    events.setMaxListeners(200);
+    const notify = (goalId) => events.emit(goalId);
+    const waitForNewEvent = (goalId, timeoutMs) => {
+        if (timeoutMs <= 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const onEvent = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(() => {
+                events.off(goalId, onEvent);
+                resolve();
+            }, timeoutMs);
+            timer.unref?.();
+            events.once(goalId, onEvent);
+        });
+    };
+    const appendAndNotify = (input) => {
+        const event = goalStore.appendEvent(input);
+        notify(input.goalId);
+        return event;
+    };
+    const deliverOrMarkFailed = async (session, text) => {
+        try {
+            await deliverToOrchestrator(session.workspaceId, text);
+        }
+        catch (error) {
+            const event = appendAndNotify({
+                body: error instanceof Error ? error.message : String(error),
+                goalId: session.id,
+                kind: 'delivery_failed',
+                sessionStatus: 'failed',
+                status: 'failed',
+            });
+            throw new ExternalGoalDeliveryError({
+                cursor: event.sequence,
+                goalId: session.id,
+                message: `orchestrator_not_running: could not deliver external goal ${session.id}`,
+                status: 'failed',
+            });
+        }
+    };
+    return {
+        listWorkspaces,
+        inspectWorkspace(input) {
+            const snapshot = getWorkspaceSnapshot(input.workspaceId);
+            const orchestratorId = getOrchestratorId(input.workspaceId);
+            const orchestrator = getAgent(input.workspaceId, orchestratorId);
+            return {
+                workspace: snapshot.summary,
+                orchestrator: {
+                    id: orchestrator.id,
+                    name: orchestrator.name,
+                    status: orchestrator.status,
+                    active_run: Boolean(getActiveRunByAgentId(input.workspaceId, orchestrator.id)),
+                },
+                members: listWorkers(input.workspaceId).map((worker) => serializeTeamListItem(worker)),
+            };
+        },
+        async startGoal(input) {
+            getWorkspaceSnapshot(input.workspaceId);
+            const { session } = goalStore.createSession({
+                context: input.context,
+                goal: input.goal,
+                source: input.source,
+                workspaceId: input.workspaceId,
+            });
+            notify(session.id);
+            await deliverOrMarkFailed(session, buildExternalGoalPayload(session));
+            const delivered = appendAndNotify({
+                body: 'External goal delivered to Orchestrator.',
+                goalId: session.id,
+                kind: 'goal_delivered',
+                sessionStatus: 'in_progress',
+                status: 'in_progress',
+            });
+            const current = requireSession(goalStore, session.id);
+            return {
+                cursor: delivered.sequence,
+                events: goalStore.listEventsAfter(session.id, 0),
+                goalId: session.id,
+                session: current,
+                status: current.status,
+            };
+        },
+        async continueGoal(input) {
+            const session = requireSession(goalStore, input.goalId);
+            if (session.status === 'cancelled') {
+                throw new ConflictError(`External goal is cancelled: ${input.goalId}`);
+            }
+            const event = appendAndNotify({
+                body: input.message,
+                goalId: session.id,
+                kind: 'goal_continued',
+                sessionStatus: 'in_progress',
+                status: 'in_progress',
+            });
+            await deliverOrMarkFailed({ ...session, status: 'in_progress' }, buildExternalGoalContinuePayload(session, input.message, input.context));
+            const current = requireSession(goalStore, session.id);
+            return { cursor: event.sequence, event, session: current, status: current.status };
+        },
+        reportGoal(input) {
+            const session = requireSession(goalStore, input.goalId);
+            if (session.workspaceId !== input.workspaceId) {
+                throw new HttpError(404, `External goal not found in workspace: ${input.goalId}`);
+            }
+            if (input.fromAgentId !== getOrchestratorId(input.workspaceId)) {
+                throw new ForbiddenError('Only the workspace Orchestrator can report external goals');
+            }
+            if (closedForReport.has(session.status)) {
+                throw new ConflictError(`External goal is not accepting reports: ${input.goalId}`);
+            }
+            const event = appendAndNotify({
+                body: input.body,
+                goalId: session.id,
+                kind: reportEventKind(input.status),
+                sessionStatus: reportSessionStatus(input.status),
+                status: input.status,
+                ...(input.artifacts !== undefined ? { artifacts: input.artifacts } : {}),
+            });
+            const current = requireSession(goalStore, session.id);
+            return { cursor: event.sequence, event, session: current, status: current.status };
+        },
+        async waitGoal(input) {
+            const session = requireSession(goalStore, input.goalId);
+            const cursor = normalizedCursor(input.cursor);
+            const existing = goalStore.listEventsAfter(session.id, cursor);
+            if (existing.length > 0) {
+                const current = requireSession(goalStore, session.id);
+                return {
+                    cursor: existing.at(-1)?.sequence ?? cursor,
+                    events: existing,
+                    goalId: session.id,
+                    status: current.status,
+                };
+            }
+            await waitForNewEvent(session.id, boundedTimeout(input.timeoutMs));
+            const eventsAfterWait = goalStore.listEventsAfter(session.id, cursor);
+            const current = requireSession(goalStore, session.id);
+            return {
+                cursor: eventsAfterWait.at(-1)?.sequence ??
+                    Math.max(cursor, goalStore.getLatestSequence(session.id)),
+                events: eventsAfterWait,
+                goalId: session.id,
+                status: current.status,
+            };
+        },
+        async cancelGoal(input) {
+            const session = requireSession(goalStore, input.goalId);
+            if (closedForReport.has(session.status) && session.status !== 'blocked') {
+                throw new ConflictError(`External goal cannot be cancelled from ${session.status}: ${input.goalId}`);
+            }
+            const event = appendAndNotify({
+                body: input.reason,
+                goalId: session.id,
+                kind: 'goal_cancelled',
+                sessionStatus: 'cancelled',
+                status: 'cancelled',
+            });
+            try {
+                await deliverToOrchestrator(session.workspaceId, buildExternalGoalCancelPayload(session, input.reason));
+            }
+            catch (error) {
+                const deliveryFailure = appendAndNotify({
+                    body: error instanceof Error ? error.message : String(error),
+                    goalId: session.id,
+                    kind: 'delivery_failed',
+                    sessionStatus: 'cancelled',
+                    status: 'cancelled',
+                });
+                throw new ExternalGoalDeliveryError({
+                    cursor: deliveryFailure.sequence,
+                    goalId: session.id,
+                    message: `orchestrator_not_running: cancelled external goal ${session.id}, but could not deliver the cancellation notice`,
+                    status: 'cancelled',
+                });
+            }
+            const current = requireSession(goalStore, session.id);
+            return { cursor: event.sequence, event, session: current, status: current.status };
+        },
+    };
+};

package/dist/src/server/external-goal-store.d.ts

@@ -0,0 +1,59 @@
+import type { Database } from 'better-sqlite3';
+export declare const EXTERNAL_GOAL_STATUSES: readonly ["open", "in_progress", "blocked", "done", "failed", "cancelled"];
+export type ExternalGoalStatus = (typeof EXTERNAL_GOAL_STATUSES)[number];
+export declare const EXTERNAL_GOAL_REPORT_STATUSES: readonly ["progress", "done", "blocked", "failed"];
+export type ExternalGoalReportStatus = (typeof EXTERNAL_GOAL_REPORT_STATUSES)[number];
+export declare const EXTERNAL_GOAL_EVENT_KINDS: readonly ["goal_started", "goal_continued", "goal_delivered", "progress_reported", "goal_done", "goal_blocked", "goal_failed", "goal_cancelled", "delivery_failed"];
+export type ExternalGoalEventKind = (typeof EXTERNAL_GOAL_EVENT_KINDS)[number];
+export interface ExternalGoalSession {
+    closedAt: number | null;
+    context: unknown;
+    createdAt: number;
+    goal: string;
+    id: string;
+    source: string;
+    status: ExternalGoalStatus;
+    summary: string | null;
+    title: string | null;
+    updatedAt: number;
+    workspaceId: string;
+}
+export interface ExternalGoalEvent {
+    artifacts: string[];
+    body: string;
+    createdAt: number;
+    goalId: string;
+    id: string;
+    kind: ExternalGoalEventKind;
+    sequence: number;
+    status: ExternalGoalReportStatus | ExternalGoalStatus | null;
+    workspaceId: string;
+}
+interface CreateExternalGoalInput {
+    context?: unknown;
+    goal: string;
+    source: string;
+    workspaceId: string;
+}
+interface AppendExternalGoalEventInput {
+    artifacts?: string[];
+    body: string;
+    goalId: string;
+    kind: ExternalGoalEventKind;
+    sessionStatus?: ExternalGoalStatus;
+    status?: ExternalGoalEvent['status'];
+}
+export declare const isExternalGoalReportStatus: (value: unknown) => value is ExternalGoalReportStatus;
+export declare const createExternalGoalStore: (db: Database) => {
+    appendEvent: (input: AppendExternalGoalEventInput) => ExternalGoalEvent;
+    createSession: (input: CreateExternalGoalInput) => {
+        event: ExternalGoalEvent;
+        session: ExternalGoalSession;
+    };
+    deleteWorkspaceGoals: (workspaceId: string) => void;
+    getLatestSequence: (goalId: string) => number;
+    getSession: (goalId: string) => ExternalGoalSession | undefined;
+    listEventsAfter: (goalId: string, cursor?: number) => ExternalGoalEvent[];
+};
+export type ExternalGoalStore = ReturnType<typeof createExternalGoalStore>;
+export {};

package/dist/src/server/external-goal-store.js

@@ -0,0 +1,165 @@
+import { randomUUID } from 'node:crypto';
+export const EXTERNAL_GOAL_STATUSES = [
+    'open',
+    'in_progress',
+    'blocked',
+    'done',
+    'failed',
+    'cancelled',
+];
+export const EXTERNAL_GOAL_REPORT_STATUSES = ['progress', 'done', 'blocked', 'failed'];
+export const EXTERNAL_GOAL_EVENT_KINDS = [
+    'goal_started',
+    'goal_continued',
+    'goal_delivered',
+    'progress_reported',
+    'goal_done',
+    'goal_blocked',
+    'goal_failed',
+    'goal_cancelled',
+    'delivery_failed',
+];
+const CLOSED_STATUSES = new Set(['blocked', 'done', 'failed', 'cancelled']);
+export const isExternalGoalReportStatus = (value) => typeof value === 'string' && EXTERNAL_GOAL_REPORT_STATUSES.includes(value);
+const toSessionRecord = (row) => ({
+    closedAt: row.closed_at,
+    context: JSON.parse(row.context_json),
+    createdAt: row.created_at,
+    goal: row.goal,
+    id: row.id,
+    source: row.source,
+    status: row.status,
+    summary: row.summary,
+    title: row.title,
+    updatedAt: row.updated_at,
+    workspaceId: row.workspace_id,
+});
+const toEventRecord = (row) => ({
+    artifacts: JSON.parse(row.artifacts_json),
+    body: row.body,
+    createdAt: row.created_at,
+    goalId: row.goal_id,
+    id: row.id,
+    kind: row.kind,
+    sequence: row.sequence,
+    status: row.status,
+    workspaceId: row.workspace_id,
+});
+const deriveTitle = (goal) => {
+    const firstLine = goal
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find(Boolean);
+    return (firstLine ?? 'External goal').slice(0, 120);
+};
+export const createExternalGoalStore = (db) => {
+    const getSession = (goalId) => {
+        const row = db.prepare('SELECT * FROM external_goal_sessions WHERE id = ?').get(goalId);
+        return row ? toSessionRecord(row) : undefined;
+    };
+    const listEventsAfter = (goalId, cursor = 0) => db
+        .prepare(`SELECT *
+           FROM external_goal_events
+           WHERE goal_id = ? AND sequence > ?
+           ORDER BY sequence ASC`)
+        .all(goalId, cursor).map(toEventRecord);
+    const getLatestSequence = (goalId) => {
+        const row = db
+            .prepare('SELECT COALESCE(MAX(sequence), 0) AS sequence FROM external_goal_events WHERE goal_id = ?')
+            .get(goalId);
+        return row?.sequence ?? 0;
+    };
+    const insertEvent = (session, input) => {
+        const sequence = getLatestSequence(input.goalId) + 1;
+        const now = Date.now();
+        const event = {
+            artifacts: input.artifacts ?? [],
+            body: input.body,
+            createdAt: now,
+            goalId: session.id,
+            id: randomUUID(),
+            kind: input.kind,
+            sequence,
+            status: input.status ?? null,
+            workspaceId: session.workspaceId,
+        };
+        db.prepare(`INSERT INTO external_goal_events (
+          id,
+          goal_id,
+          workspace_id,
+          sequence,
+          kind,
+          status,
+          body,
+          artifacts_json,
+          created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.goalId, event.workspaceId, event.sequence, event.kind, event.status, event.body, JSON.stringify(event.artifacts), event.createdAt);
+        if (input.sessionStatus) {
+            db.prepare(`UPDATE external_goal_sessions
+           SET status = ?, updated_at = ?, closed_at = ?
+           WHERE id = ?`).run(input.sessionStatus, now, CLOSED_STATUSES.has(input.sessionStatus) ? now : null, session.id);
+        }
+        else {
+            db.prepare('UPDATE external_goal_sessions SET updated_at = ? WHERE id = ?').run(now, session.id);
+        }
+        return event;
+    };
+    const appendEvent = (input) => {
+        return db.transaction(() => {
+            const session = getSession(input.goalId);
+            if (!session)
+                throw new Error(`External goal not found: ${input.goalId}`);
+            return insertEvent(session, input);
+        })();
+    };
+    const createSession = (input) => {
+        return db.transaction(() => {
+            const now = Date.now();
+            const session = {
+                closedAt: null,
+                context: input.context ?? null,
+                createdAt: now,
+                goal: input.goal,
+                id: `goal_${randomUUID()}`,
+                source: input.source,
+                status: 'open',
+                summary: null,
+                title: deriveTitle(input.goal),
+                updatedAt: now,
+                workspaceId: input.workspaceId,
+            };
+            db.prepare(`INSERT INTO external_goal_sessions (
+          id,
+          workspace_id,
+          source,
+          status,
+          goal,
+          context_json,
+          title,
+          summary,
+          created_at,
+          updated_at,
+          closed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(session.id, session.workspaceId, session.source, session.status, session.goal, JSON.stringify(session.context), session.title, session.summary, session.createdAt, session.updatedAt, session.closedAt);
+            const event = insertEvent(session, {
+                body: input.goal,
+                goalId: session.id,
+                kind: 'goal_started',
+                status: 'open',
+            });
+            return { event, session };
+        })();
+    };
+    const deleteWorkspaceGoals = (workspaceId) => {
+        db.prepare('DELETE FROM external_goal_events WHERE workspace_id = ?').run(workspaceId);
+        db.prepare('DELETE FROM external_goal_sessions WHERE workspace_id = ?').run(workspaceId);
+    };
+    return {
+        appendEvent,
+        createSession,
+        deleteWorkspaceGoals,
+        getLatestSequence,
+        getSession,
+        listEventsAfter,
+    };
+};

package/dist/src/server/hive-team-guidance.js

@@ -313,6 +313,7 @@ export const buildProtocolGuide = (topic, cliPolicy = DEFAULT_WORKFLOW_CLI_POLIC
             '- `team list` — show current members/status and open dispatches.',
             '- `team send "<member-name>" "<task>"` — dispatch by member name, never id.',
             '- `team cancel --dispatch <id> "<reason>"` — cancel an obsolete open dispatch.',
+            '- `team goal report --goal <goal-id> --status progress|done|blocked|failed --stdin` — report external Supervisor goal events when an external-goal envelope asks for it.',
             `- \`team spawn <role> [--name <name>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]\` — create a member only when authorized.`,
             '- `team dismiss <member-name>` — remove a member you are allowed to remove.',
             '',

package/dist/src/server/post-start-input-writer.js

@@ -48,6 +48,9 @@ const ESCAPE = String.fromCharCode(27);
 const BELL = String.fromCharCode(7);
 const TERMINAL_CONTROL_PATTERN = new RegExp(`${ESCAPE}\\[[0-?]*[ -/]*[@-~]|${ESCAPE}\\][^${BELL}${ESCAPE}]*(?:${BELL}|${ESCAPE}\\\\)`, 'gu');
 const HIVE_ACK_GATED_MESSAGE_PATTERN = /<(?:hive-system-message\b|hive-message\s+kind="(?:cancel|dispatch|heartbeat|startup)"(?:\s|>))/u;
+const OPENCODE_VISIBLE_PROMPT_PATTERN = /\bAsk anything\.\.\./u;
+const OPENCODE_COMPLETED_TURN_FOOTER_PATTERN = /^▣\s+[^·\n]+·\s+\S.*\s+·\s+\d+(?:\.\d+)?(?:ms|s)$/u;
+const OPENCODE_INTERRUPT_STATUS_PATTERN = /\besc\s+interrupt\b/iu;
 export const toBracketedPasteSubmission = (text) => `\u001b[200~${text}\u001b[201~`;
 const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
 const createRunInactiveError = (runId) => new Error(`Run became inactive before input was submitted: ${runId}`);
@@ -71,13 +74,15 @@ export const isInteractiveAgentCommand = (command) => {
 };
 const getPlainTerminalOutput = (output) => output.replace(/\r/g, '\n').replace(TERMINAL_CONTROL_PATTERN, '');
 const getPlainTerminalTail = (output) => getPlainTerminalOutput(output).slice(-PROMPT_READY_TAIL_CHARS);
+const getRecentNonEmptyTerminalLines = (output) => getPlainTerminalTail(output)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
 const hasGeminiPromptReady = (output) => /\bType your message\b/u.test(output);
 const hasHermesPromptReady = (output) => {
     const plain = getPlainTerminalTail(output);
     return /\bWelcome to Hermes Agent![\s\S]*❯/u.test(plain);
 };
-const hasOpencodeVisiblePromptReady = (output) => /\bAsk anything\.\.\./u.test(getPlainTerminalTail(output));
-const hasOpencodeCompletedTurnReady = (output) => /(?:^|\s)▣\s+Build\s+·/u.test(getLastNonEmptyTerminalLine(output));
 const hasGrokPromptReady = (output) => /\b(?:Enter:send|Composer\s+\S+)/u.test(output);
 const hasAgyPromptReady = (output) => /(?:^|\n)\s*>\s*\n\s*(?:[─-]{8,}|\?\s*for shortcuts)/u.test(getPlainTerminalOutput(output));
 const getLastNonEmptyTerminalLine = (output) => {
@@ -112,6 +117,21 @@ export const hasFirstRunSetupPrompt = (output) => {
     const recent = recentLines.join('\n');
     return SETUP_PROMPT_PATTERNS.some((pattern) => pattern.test(recent));
 };
+const getOpencodePromptReadyState = (output) => {
+    const recentLines = getRecentNonEmptyTerminalLines(output);
+    for (let index = recentLines.length - 1; index >= 0; index--) {
+        const line = recentLines[index];
+        if (line === undefined)
+            continue;
+        if (OPENCODE_INTERRUPT_STATUS_PATTERN.test(line))
+            return 'ready';
+        if (OPENCODE_VISIBLE_PROMPT_PATTERN.test(line))
+            return 'ready';
+        if (OPENCODE_COMPLETED_TURN_FOOTER_PATTERN.test(line))
+            return 'ready-after-settle';
+    }
+    return 'not-ready';
+};
 const getInteractivePromptReadyState = (output, command = '') => {
     const commandName = getCommandName(command);
     if (hasBarePromptLine(output) ||
@@ -122,10 +142,7 @@ const getInteractivePromptReadyState = (output, command = '') => {
         return 'ready';
     }
     if (commandName === 'opencode') {
-        if (hasOpencodeVisiblePromptReady(output))
-            return 'ready';
-        if (hasOpencodeCompletedTurnReady(output))
-            return 'ready-after-settle';
+        return getOpencodePromptReadyState(output);
     }
     return 'not-ready';
 };

package/dist/src/server/route-types.d.ts

@@ -67,6 +67,15 @@ export interface ReportTaskBody {
     status?: 'success' | 'failed';
     artifacts?: unknown[];
 }
+export interface GoalReportBody {
+    artifacts?: unknown[];
+    goal_id?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    result?: string;
+    status?: string;
+}
 export interface CancelTaskBody {
     dispatch_id?: string;
     project_id: string;
@@ -74,6 +83,27 @@ export interface CancelTaskBody {
     token?: string;
     reason?: string;
 }
+export interface ExternalGoalStartBody {
+    workspace_id?: string;
+    goal?: string;
+    context?: unknown;
+    timeout_hint_ms?: number;
+    source?: string;
+}
+export interface ExternalGoalWaitBody {
+    goal_id?: string;
+    cursor?: number;
+    timeout_ms?: number;
+}
+export interface ExternalGoalContinueBody {
+    goal_id?: string;
+    message?: string;
+    context?: unknown;
+}
+export interface ExternalGoalCancelBody {
+    goal_id?: string;
+    reason?: string;
+}
 export interface CreateWorkspaceBody {
     path: string;
     name: string;

package/dist/src/server/routes-external-goals.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const externalGoalRoutes: RouteDefinition[];