@tt-a1i/hive 2.1.9 → 2.1.11

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

@@ -4,6 +4,7 @@ const READY_CHECK_INTERVAL_MS = 50;
 const READY_TIMEOUT_MS = 3000;
 const PROMPT_READY_HARD_TIMEOUT_MS = 30000;
 const PROMPT_READY_TAIL_CHARS = 8000;
+const OPENCODE_COMPLETION_READY_SETTLE_MS = 1000;
 const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
 const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
 const PASTE_CHARS_PER_DELAY_MS = 4;
@@ -47,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}`);
@@ -70,12 +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 hasOpencodePromptReady = (output) => /\bAsk anything\.\.\./u.test(getPlainTerminalTail(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) => {
@@ -110,15 +117,36 @@ export const hasFirstRunSetupPrompt = (output) => {
     const recent = recentLines.join('\n');
     return SETUP_PROMPT_PATTERNS.some((pattern) => pattern.test(recent));
 };
-export const hasInteractivePromptReady = (output, command = '') => {
+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);
-    return (hasBarePromptLine(output) ||
+    if (hasBarePromptLine(output) ||
         (commandName === 'agy' && hasAgyPromptReady(output)) ||
         (commandName === 'grok' && hasGrokPromptReady(output)) ||
         (commandName === 'hermes' && hasHermesPromptReady(output)) ||
-        ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output)) ||
-        (commandName === 'opencode' && hasOpencodePromptReady(output)));
+        ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output))) {
+        return 'ready';
+    }
+    if (commandName === 'opencode') {
+        return getOpencodePromptReadyState(output);
+    }
+    return 'not-ready';
 };
+export const hasInteractivePromptReady = (output, command = '') => getInteractivePromptReadyState(output, command) !== 'not-ready';
 export const hasBracketedPasteAcknowledgement = (output, baselineLength) => {
     const outputAfterPaste = output.slice(baselineLength);
     const pasteEndIndex = outputAfterPaste.lastIndexOf(BRACKETED_PASTE_END);
@@ -282,6 +310,24 @@ export const createPostStartInputWriter = (agentManager, command) => {
         });
         const startedAt = Date.now();
         let isInitialAttempt = true;
+        let settleCandidate = null;
+        const isReadyToWrite = (output) => {
+            const promptReadyState = getInteractivePromptReadyState(output, command);
+            if (promptReadyState === 'ready') {
+                settleCandidate = null;
+                return true;
+            }
+            if (promptReadyState !== 'ready-after-settle') {
+                settleCandidate = null;
+                return false;
+            }
+            const tail = getPlainTerminalTail(output);
+            if (!settleCandidate || settleCandidate.tail !== tail) {
+                settleCandidate = { since: Date.now(), tail };
+                return false;
+            }
+            return Date.now() - settleCandidate.since >= OPENCODE_COMPLETION_READY_SETTLE_MS;
+        };
         const tryWrite = () => {
             let output;
             try {
@@ -297,7 +343,7 @@ export const createPostStartInputWriter = (agentManager, command) => {
                 return;
             }
             const firstRunSetupPromptVisible = hasFirstRunSetupPrompt(output);
-            if ((!firstRunSetupPromptVisible && hasInteractivePromptReady(output, command)) ||
+            if ((!firstRunSetupPromptVisible && isReadyToWrite(output)) ||
                 (!firstRunSetupPromptVisible &&
                     canTimeoutBeforePromptReady(command) &&
                     Date.now() - startedAt >= READY_TIMEOUT_MS)) {

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[];

package/dist/src/server/routes-external-goals.js

@@ -0,0 +1,184 @@
+import { HIVE_SUPERVISOR_TOKEN_HEADER } from './external-goal-auth.js';
+import { ExternalGoalDeliveryError } from './external-goal-bridge.js';
+import { BadRequestError, ForbiddenError } from './http-errors.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+const BODY_MAX_CHARS = 40_000;
+const SOURCE_MAX_CHARS = 80;
+const requireNonEmptyString = (value, field, maxChars = BODY_MAX_CHARS) => {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new BadRequestError(`Missing ${field}`);
+    }
+    if ([...value].length > maxChars) {
+        throw new BadRequestError(`${field} must be ${maxChars} characters or fewer`);
+    }
+    return value;
+};
+const optionalNonEmptyString = (value, field, maxChars = SOURCE_MAX_CHARS) => {
+    if (value === undefined || value === null)
+        return undefined;
+    return requireNonEmptyString(value, field, maxChars);
+};
+const serializeEvent = (event) => ({
+    artifacts: event.artifacts,
+    body: event.body,
+    created_at: event.createdAt,
+    goal_id: event.goalId,
+    id: event.id,
+    kind: event.kind,
+    sequence: event.sequence,
+    status: event.status,
+    workspace_id: event.workspaceId,
+});
+const serializeSession = (session) => ({
+    closed_at: session.closedAt,
+    created_at: session.createdAt,
+    goal: session.goal,
+    id: session.id,
+    source: session.source,
+    status: session.status,
+    summary: session.summary,
+    title: session.title,
+    updated_at: session.updatedAt,
+    workspace_id: session.workspaceId,
+});
+const serializeWaitResult = (result) => ({
+    cursor: result.cursor,
+    events: result.events.map(serializeEvent),
+    goal_id: result.goalId,
+    status: result.status,
+});
+const sendDeliveryError = (response, error) => {
+    sendJson(response, error.statusCode, {
+        cursor: error.cursor,
+        error: error.message,
+        goal_id: error.goalId,
+        status: error.status,
+    });
+};
+const requireExternalController = (store, request) => {
+    if (store.authorizeRemoteTunnelRequest(request)) {
+        throw new ForbiddenError('Supervisor token is not available over the remote tunnel');
+    }
+    const rawToken = request.headers[HIVE_SUPERVISOR_TOKEN_HEADER];
+    const token = Array.isArray(rawToken) ? rawToken[0] : rawToken;
+    if (!store.validateSupervisorToken(token)) {
+        throw new ForbiddenError('External goal endpoint requires valid Supervisor token');
+    }
+};
+export const externalGoalRoutes = [
+    route('GET', '/api/external-goals/session', ({ request, response, store }) => {
+        if (store.authorizeRemoteTunnelRequest(request)) {
+            throw new ForbiddenError('Supervisor token is not available over the remote tunnel');
+        }
+        sendJson(response, 200, {
+            token: store.getSupervisorToken(),
+            token_type: 'hive-supervisor',
+        });
+    }),
+    route('GET', '/api/external-goals/workspaces', ({ request, response, store }) => {
+        requireExternalController(store, request);
+        sendJson(response, 200, { workspaces: store.listExternalGoalWorkspaces() });
+    }),
+    route('GET', '/api/external-goals/workspaces/:workspaceId', ({ params, request, response, store }) => {
+        requireExternalController(store, request);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId)
+            return;
+        sendJson(response, 200, store.inspectExternalGoalWorkspace({ workspaceId }));
+    }),
+    route('POST', '/api/external-goals/start', async ({ request, response, store }) => {
+        requireExternalController(store, request);
+        const body = await readJsonBody(request);
+        const workspaceId = requireNonEmptyString(body.workspace_id, 'workspace_id', 200);
+        const goal = requireNonEmptyString(body.goal, 'goal');
+        const source = optionalNonEmptyString(body.source, 'source') ?? 'hive-mcp';
+        let result;
+        try {
+            result = await store.startExternalGoal({
+                workspaceId,
+                goal,
+                source,
+                ...(body.context !== undefined ? { context: body.context } : {}),
+                ...(body.timeout_hint_ms !== undefined ? { timeoutHintMs: body.timeout_hint_ms } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof ExternalGoalDeliveryError) {
+                sendDeliveryError(response, error);
+                return;
+            }
+            throw error;
+        }
+        sendJson(response, 202, {
+            cursor: result.cursor,
+            events: result.events.map(serializeEvent),
+            goal_id: result.goalId,
+            ok: true,
+            session: serializeSession(result.session),
+            status: result.status,
+        });
+    }),
+    route('POST', '/api/external-goals/wait', async ({ request, response, store }) => {
+        requireExternalController(store, request);
+        const body = await readJsonBody(request);
+        const goalId = requireNonEmptyString(body.goal_id, 'goal_id', 200);
+        const result = await store.waitExternalGoal({
+            goalId,
+            ...(body.cursor !== undefined ? { cursor: body.cursor } : {}),
+            ...(body.timeout_ms !== undefined ? { timeoutMs: body.timeout_ms } : {}),
+        });
+        sendJson(response, 200, serializeWaitResult(result));
+    }),
+    route('POST', '/api/external-goals/continue', async ({ request, response, store }) => {
+        requireExternalController(store, request);
+        const body = await readJsonBody(request);
+        const goalId = requireNonEmptyString(body.goal_id, 'goal_id', 200);
+        const message = requireNonEmptyString(body.message, 'message');
+        let result;
+        try {
+            result = await store.continueExternalGoal({
+                goalId,
+                message,
+                ...(body.context !== undefined ? { context: body.context } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof ExternalGoalDeliveryError) {
+                sendDeliveryError(response, error);
+                return;
+            }
+            throw error;
+        }
+        sendJson(response, 202, {
+            cursor: result.cursor,
+            event: serializeEvent(result.event),
+            ok: true,
+            session: serializeSession(result.session),
+            status: result.status,
+        });
+    }),
+    route('POST', '/api/external-goals/cancel', async ({ request, response, store }) => {
+        requireExternalController(store, request);
+        const body = await readJsonBody(request);
+        const goalId = requireNonEmptyString(body.goal_id, 'goal_id', 200);
+        const reason = requireNonEmptyString(body.reason, 'reason');
+        let result;
+        try {
+            result = await store.cancelExternalGoal({ goalId, reason });
+        }
+        catch (error) {
+            if (error instanceof ExternalGoalDeliveryError) {
+                sendDeliveryError(response, error);
+                return;
+            }
+            throw error;
+        }
+        sendJson(response, 202, {
+            cursor: result.cursor,
+            event: serializeEvent(result.event),
+            ok: true,
+            session: serializeSession(result.session),
+            status: result.status,
+        });
+    }),
+];

package/dist/src/server/routes-runtime.js

@@ -74,6 +74,11 @@ export const runtimeRoutes = [
             return;
         }
         requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        sendJson(response, 200, serializeLiveAgentRun(store.getLiveRun(runId)));
+        const run = store.findLiveRun(runId);
+        if (!run) {
+            sendJson(response, 404, { error: 'Run not found' });
+            return;
+        }
+        sendJson(response, 200, serializeLiveAgentRun(run));
     }),
 ];

package/dist/src/server/routes-scenarios.d.ts

@@ -4,23 +4,18 @@ import type { RuntimeStore } from './runtime-store-contract.js';
 import { type ScenarioPreset } from './scenario-presets.js';
 import { type CliAvailabilityProbe } from './spawn-cli-resolver.js';
 import { type UiLanguage } from './workspace-ui-language.js';
-export declare const scenarioRoutes: RouteDefinition[];
-/**
- * Materialize the scenario team and hand the goal to the orchestrator.
- * Exported for direct testing (the route harness has no PTY, so the
- * active-run gate above would mask this logic).
- *
- * Workers derive a FRESH launch config from the orchestrator's CLI brand via
- * the same resolver `team spawn` uses — never a clone of the orchestrator's
- * own config, which may carry session-resume arguments that would make every
- * worker resume the orchestrator's session.
- *
- * Worker creation is sequential and NOT transactional across workers: each
- * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
- * leaves earlier workers in place and surfaces the error to the caller.
- */
-export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => Array<{
+type CreatedScenarioWorker = {
     id: string;
     name: string;
     role: WorkerRole;
-}>;
+};
+type StartedScenarioWorker = CreatedScenarioWorker & {
+    start: {
+        ok: true;
+        run_id: string;
+    };
+};
+export declare const scenarioRoutes: RouteDefinition[];
+export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => CreatedScenarioWorker[];
+export declare const applyAndStartScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, hivePort: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => Promise<StartedScenarioWorker[]>;
+export {};

package/dist/src/server/routes-scenarios.js

@@ -5,12 +5,13 @@ import { resolveDefaultSpawnCliLaunchConfig, } from './spawn-cli-resolver.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 import { getOrchestratorId } from './workspace-store-support.js';
 import { resolveWorkspaceUiLanguage, writeWorkspaceUiLanguage, } from './workspace-ui-language.js';
+const getRuntimePort = (request) => String(request.socket.localPort ?? '');
 export const scenarioRoutes = [
     /**
-     * One-click team assembly: materialize a scenario preset's workers (each
-     * inheriting the orchestrator's launch config) and hand the user's goal to
-     * the orchestrator as a normal user message. Deliberately NOT dispatching —
-     * splitting the goal and calling `team send` stays the orchestrator's job.
+     * One-click team assembly: materialize a scenario preset's members, start
+     * their PTYs, then hand the user's goal to the orchestrator as a normal user
+     * message. Deliberately NOT dispatching — splitting the goal and calling
+     * `team send` stays the orchestrator's job.
      */
     route('POST', '/api/workspaces/:workspaceId/scenarios/:scenarioId/apply', async ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and scenario id are required');
@@ -35,13 +36,12 @@ export const scenarioRoutes = [
         }
         const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.locale);
         writeWorkspaceUiLanguage(store.settings, workspaceId, language);
-        // The kickoff is delivered to the orchestrator's live terminal and is NOT
-        // persisted for replay, so an offline orchestrator would silently lose the
-        // goal. Gate up front: no live run, no team assembly.
+        // The kickoff must land in the orchestrator's live terminal. Gate up
+        // front so a stopped orchestrator never gets a half-created scenario.
         if (!store.getActiveRunByAgentId(workspaceId, getOrchestratorId(workspaceId))) {
             throw new ConflictError('Start the Orchestrator first — the scenario goal is handed to its terminal');
         }
-        const created = applyScenario(store, workspaceId, scenario, goal, undefined, language);
+        const created = await applyAndStartScenario(store, workspaceId, scenario, goal, getRuntimePort(request), undefined, language);
         sendJson(response, 201, {
             created_workers: created,
             injected: true,
@@ -51,7 +51,7 @@ export const scenarioRoutes = [
 /**
  * Materialize the scenario team and hand the goal to the orchestrator.
  * Exported for direct testing (the route harness has no PTY, so the
- * active-run gate above would mask this logic).
+ * active-run/start behavior would mask this logic).
  *
  * Workers derive a FRESH launch config from the orchestrator's CLI brand via
  * the same resolver `team spawn` uses — never a clone of the orchestrator's
@@ -62,7 +62,7 @@ export const scenarioRoutes = [
  * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
  * leaves earlier workers in place and surfaces the error to the caller.
  */
-export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable, language = 'en') => {
+const createScenarioWorkers = (store, workspaceId, scenario, isCommandAvailable, language = 'en') => {
     const ports = {
         getCommandPreset: (id) => store.settings.getCommandPreset(id),
         getOrchestratorLaunchConfig: () => store.peekAgentLaunchConfig(workspaceId, getOrchestratorId(workspaceId)),
@@ -72,7 +72,7 @@ export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvail
     const takenNames = new Set(store.listWorkers(workspaceId).map((worker) => worker.name));
     const created = [];
     for (const spec of scenario.workers) {
-        const name = buildScenarioWorkerName(spec, (candidate) => takenNames.has(candidate));
+        const name = buildScenarioWorkerName(spec, takenNames, { language });
         takenNames.add(name);
         const description = spec.descriptionOverride !== undefined
             ? getScenarioWorkerDescription(spec, language)
@@ -84,11 +84,35 @@ export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvail
         }, launchConfig);
         created.push({ id: worker.id, name: worker.name, role: spec.role });
     }
-    store.recordUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffMessage({
-        scenarioId: scenario.id,
-        goal,
-        language,
-        workers: created.map((worker) => ({ name: worker.name, role: worker.role })),
-    }));
     return created;
 };
+const deliverScenarioKickoff = async (store, workspaceId, scenario, goal, language, created) => {
+    await store.deliverUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffText(scenario, goal, language, created));
+};
+const buildScenarioKickoffText = (scenario, goal, language, created) => buildScenarioKickoffMessage({
+    scenarioId: scenario.id,
+    goal,
+    language,
+    workers: created.map((worker) => ({ name: worker.name, role: worker.role })),
+});
+const recordScenarioKickoff = (store, workspaceId, scenario, goal, language, created) => {
+    store.recordUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffText(scenario, goal, language, created));
+};
+export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable, language = 'en') => {
+    const created = createScenarioWorkers(store, workspaceId, scenario, isCommandAvailable, language);
+    recordScenarioKickoff(store, workspaceId, scenario, goal, language, created);
+    return created;
+};
+const startScenarioWorkers = async (store, workspaceId, hivePort, created) => Promise.all(created.map(async (worker) => {
+    const run = await store.startAgent(workspaceId, worker.id, { hivePort });
+    if (run.status === 'error') {
+        throw new ConflictError(`Failed to start scenario member: ${worker.name}`);
+    }
+    return { ...worker, start: { ok: true, run_id: run.runId } };
+}));
+export const applyAndStartScenario = async (store, workspaceId, scenario, goal, hivePort, isCommandAvailable, language = 'en') => {
+    const created = createScenarioWorkers(store, workspaceId, scenario, isCommandAvailable, language);
+    const started = await startScenarioWorkers(store, workspaceId, hivePort, created);
+    await deliverScenarioKickoff(store, workspaceId, scenario, goal, language, created);
+    return started;
+};

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

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

package/dist/src/server/routes-team-goals.js

@@ -0,0 +1,60 @@
+import { isExternalGoalReportStatus } from './external-goal-store.js';
+import { BadRequestError } from './http-errors.js';
+import { readJsonBody, route, sendJson } from './route-helpers.js';
+import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
+const BODY_MAX_CHARS = 40_000;
+const requireNonEmptyString = (value, field, maxChars = BODY_MAX_CHARS) => {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new BadRequestError(`Missing ${field}`);
+    }
+    if ([...value].length > maxChars) {
+        throw new BadRequestError(`${field} must be ${maxChars} characters or fewer`);
+    }
+    return value;
+};
+const getArtifacts = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+export const teamGoalRoutes = [
+    route('POST', '/api/team/goal/report', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id', 200);
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id', 200);
+        const goalId = requireNonEmptyString(body.goal_id, 'goal_id', 200);
+        const resultText = requireNonEmptyString(body.result, 'result');
+        if (!isExternalGoalReportStatus(body.status)) {
+            throw new BadRequestError('Invalid status; expected progress, done, blocked, or failed');
+        }
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'goal_report');
+        const result = store.reportExternalGoal({
+            artifacts: getArtifacts(body.artifacts),
+            body: resultText,
+            fromAgentId,
+            goalId,
+            status: body.status,
+            workspaceId: projectId,
+        });
+        sendJson(response, 202, {
+            cursor: result.cursor,
+            event: {
+                artifacts: result.event.artifacts,
+                body: result.event.body,
+                created_at: result.event.createdAt,
+                goal_id: result.event.goalId,
+                id: result.event.id,
+                kind: result.event.kind,
+                sequence: result.event.sequence,
+                status: result.event.status,
+                workspace_id: result.event.workspaceId,
+            },
+            goal_id: goalId,
+            ok: true,
+            status: result.status,
+        });
+    }),
+];

package/dist/src/server/routes.js

@@ -2,6 +2,7 @@ import { matchPath } from './route-helpers.js';
 import { actionCenterRoutes } from './routes-action-center.js';
 import { diagnosticsRoutes } from './routes-diagnostics.js';
 import { dispatchRoutes } from './routes-dispatches.js';
+import { externalGoalRoutes } from './routes-external-goals.js';
 import { fsRoutes } from './routes-fs.js';
 import { marketplaceRoutes } from './routes-marketplace.js';
 import { openWorkspaceRoutes } from './routes-open-workspace.js';
@@ -11,6 +12,7 @@ import { scenarioRoutes } from './routes-scenarios.js';
 import { settingsRoutes } from './routes-settings.js';
 import { taskRoutes } from './routes-tasks.js';
 import { teamRoutes } from './routes-team.js';
+import { teamGoalRoutes } from './routes-team-goals.js';
 import { teamMemoryRoutes } from './routes-team-memory.js';
 import { teamRecallRoutes } from './routes-team-recall.js';
 import { uiRoutes } from './routes-ui.js';
@@ -36,8 +38,10 @@ const routes = [
     ...workspaceMemoryDreamRoutes,
     ...workspaceMemoryRoutes,
     ...runtimeRoutes,
+    ...externalGoalRoutes,
     ...teamRecallRoutes,
     ...teamMemoryRoutes,
+    ...teamGoalRoutes,
     ...teamRoutes,
     ...fsRoutes,
     ...marketplaceRoutes,

package/dist/src/server/runtime-store-contract.d.ts

@@ -4,6 +4,7 @@ import type { AgentManager } from './agent-manager.js';
 import type { AgentLaunchConfigInput, PersistedAgentRun } from './agent-run-store.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
 import type { DispatchRecord, ListDispatchesOptions } from './dispatch-ledger-store.js';
+import type { ExternalGoalBridge, ExternalGoalCancelInput, ExternalGoalContinueInput, ExternalGoalReportInput, ExternalGoalStartInput, ExternalGoalWaitInput } from './external-goal-bridge.js';
 import type { RecoveryMessage } from './message-log-store.js';
 import type { PtyOutputBus } from './pty-output-bus.js';
 import type { RemoteAuditStore } from './remote-audit-store.js';
@@ -50,6 +51,13 @@ export interface RuntimeStore {
     listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     listOpenDispatches: (workspaceId: string) => DispatchRecord[];
     listRecentDispatches: (workspaceId: string, limit?: number) => DispatchRecord[];
+    listExternalGoalWorkspaces: ExternalGoalBridge['listWorkspaces'];
+    inspectExternalGoalWorkspace: ExternalGoalBridge['inspectWorkspace'];
+    startExternalGoal: (input: ExternalGoalStartInput) => ReturnType<ExternalGoalBridge['startGoal']>;
+    continueExternalGoal: (input: ExternalGoalContinueInput) => ReturnType<ExternalGoalBridge['continueGoal']>;
+    reportExternalGoal: (input: ExternalGoalReportInput) => ReturnType<ExternalGoalBridge['reportGoal']>;
+    waitExternalGoal: (input: ExternalGoalWaitInput) => ReturnType<ExternalGoalBridge['waitGoal']>;
+    cancelExternalGoal: (input: ExternalGoalCancelInput) => ReturnType<ExternalGoalBridge['cancelGoal']>;
     listWorkers: (workspaceId: string) => TeamListItem[];
     getLastPtyLineForAgent: (workspaceId: string, agentId: string) => string | null;
     getWorkspaceSnapshot: (workspaceId: string) => WorkspaceRecord;
@@ -70,6 +78,7 @@ export interface RuntimeStore {
         workspace_id: string;
     }>>;
     startWorkspaceWatch: (workspaceId: string) => Promise<void>;
+    findLiveRun: (runId: string) => LiveAgentRun | undefined;
     getLiveRun: (runId: string) => LiveAgentRun;
     waitForRunExit: (runId: string, timeoutMs: number) => Promise<boolean>;
     getActiveRunByAgentId: (workspaceId: string, agentId: string) => LiveAgentRun | undefined;
@@ -102,9 +111,11 @@ export interface RuntimeStore {
     settings: SettingsStore;
     writeRunInput: (runId: string, input: Buffer | string) => void;
     getUiToken: () => string;
+    getSupervisorToken: () => string;
     stopAgentRun: (runId: string) => void;
     validateAgentToken: (agentId: string, token: string | undefined) => boolean;
     validateUiToken: (token: string | undefined) => boolean;
+    validateSupervisorToken: (token: string | undefined) => boolean;
     authorizeRemoteTunnelRequest: (request: IncomingMessage) => boolean;
     getRemoteTunnelSecret: () => string;
     getRemoteAuditStore: () => RemoteAuditStore;