@tt-a1i/hive 2.1.10 → 2.1.12

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

@@ -39,6 +39,7 @@ const COMMANDS_WITH_BRACKETED_PASTE = new Set([
     'grok',
     'hermes',
     'opencode',
+    'pi',
 ]);
 const COMMANDS_WAITING_FOR_PASTE_ACK = new Set(['claude', 'codex']);
 const BRACKETED_PASTE_END = '\u001b[201~';
@@ -48,6 +49,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,14 +75,17 @@ 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 hasPiPromptReady = (output) => /\bpi\s+v\d+(?:\.\d+){1,3}[\s\S]*\b(?:escape\s+interrupt|ctrl\+c\/ctrl\+d\s+clear\/exit)\b/iu.test(getPlainTerminalTail(output));
 const hasAgyPromptReady = (output) => /(?:^|\n)\s*>\s*\n\s*(?:[─-]{8,}|\?\s*for shortcuts)/u.test(getPlainTerminalOutput(output));
 const getLastNonEmptyTerminalLine = (output) => {
     const normalized = getPlainTerminalOutput(output);
@@ -112,20 +119,33 @@ 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) ||
         (commandName === 'agy' && hasAgyPromptReady(output)) ||
         (commandName === 'grok' && hasGrokPromptReady(output)) ||
         (commandName === 'hermes' && hasHermesPromptReady(output)) ||
+        (commandName === 'pi' && hasPiPromptReady(output)) ||
         ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output))) {
         return 'ready';
     }
     if (commandName === 'opencode') {
-        if (hasOpencodeVisiblePromptReady(output))
-            return 'ready';
-        if (hasOpencodeCompletedTurnReady(output))
-            return 'ready-after-settle';
+        return getOpencodePromptReadyState(output);
     }
     return 'not-ready';
 };
@@ -167,11 +187,12 @@ const canTimeoutBeforePromptReady = (command) => {
         commandName !== 'gemini' &&
         commandName !== 'hermes' &&
         commandName !== 'opencode' &&
+        commandName !== 'pi' &&
         commandName !== 'qwen');
 };
 const hasPromptReadyHardTimeout = (command) => {
     const commandName = getCommandName(command);
-    return commandName === 'hermes' || commandName === 'opencode';
+    return commandName === 'hermes' || commandName === 'opencode' || commandName === 'pi';
 };
 const isWritableRunStatus = (status) => status === undefined || status === 'starting' || status === 'running';
 const writeIfRunWritable = (agentManager, runId, text) => {

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-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,