@tt-a1i/hive 2.1.10 → 2.1.11

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,

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;

package/dist/src/server/runtime-store-external-goals.d.ts

@@ -0,0 +1,47 @@
+import type { RuntimeStoreServices } from './runtime-store-helpers.js';
+export declare const createRuntimeStoreExternalGoalMethods: (services: RuntimeStoreServices) => {
+    cancelExternalGoal: (input: import("./external-goal-bridge.js").ExternalGoalCancelInput) => Promise<{
+        cursor: number;
+        event: import("./external-goal-store.js").ExternalGoalEvent;
+        session: import("./external-goal-store.js").ExternalGoalSession;
+        status: "open" | "cancelled" | "in_progress" | "blocked" | "done" | "failed";
+    }>;
+    continueExternalGoal: (input: import("./external-goal-bridge.js").ExternalGoalContinueInput) => Promise<{
+        cursor: number;
+        event: import("./external-goal-store.js").ExternalGoalEvent;
+        session: import("./external-goal-store.js").ExternalGoalSession;
+        status: "open" | "cancelled" | "in_progress" | "blocked" | "done" | "failed";
+    }>;
+    inspectExternalGoalWorkspace: (input: {
+        workspaceId: string;
+    }) => {
+        workspace: import("../shared/types.js").WorkspaceSummary;
+        orchestrator: {
+            id: string;
+            name: string;
+            status: "idle" | "working" | "stopped";
+            active_run: boolean;
+        };
+        members: import("../shared/types.js").TeamListItemPayload[];
+    };
+    listExternalGoalWorkspaces: () => import("../shared/types.js").WorkspaceSummary[];
+    reportExternalGoal: (input: import("./external-goal-bridge.js").ExternalGoalReportInput) => {
+        cursor: number;
+        event: import("./external-goal-store.js").ExternalGoalEvent;
+        session: import("./external-goal-store.js").ExternalGoalSession;
+        status: "open" | "cancelled" | "in_progress" | "blocked" | "done" | "failed";
+    };
+    startExternalGoal: (input: import("./external-goal-bridge.js").ExternalGoalStartInput) => Promise<{
+        cursor: number;
+        events: import("./external-goal-store.js").ExternalGoalEvent[];
+        goalId: string;
+        session: import("./external-goal-store.js").ExternalGoalSession;
+        status: "open" | "cancelled" | "in_progress" | "blocked" | "done" | "failed";
+    }>;
+    waitExternalGoal: (input: import("./external-goal-bridge.js").ExternalGoalWaitInput) => Promise<{
+        cursor: number;
+        events: import("./external-goal-store.js").ExternalGoalEvent[];
+        goalId: string;
+        status: "open" | "cancelled" | "in_progress" | "blocked" | "done" | "failed";
+    }>;
+};

package/dist/src/server/runtime-store-external-goals.js

@@ -0,0 +1,24 @@
+import { createExternalGoalBridge } from './external-goal-bridge.js';
+import { getOrchestratorId } from './workspace-store-support.js';
+export const createRuntimeStoreExternalGoalMethods = (services) => {
+    const bridge = createExternalGoalBridge({
+        deliverToOrchestrator: (workspaceId, text) => services.agentRuntime.deliverSystemMessageToAgent(workspaceId, getOrchestratorId(workspaceId), text, {
+            requireActiveRun: true,
+        }),
+        getActiveRunByAgentId: (workspaceId, agentId) => services.agentRuntime.getActiveRunByAgentId(workspaceId, agentId),
+        getAgent: (workspaceId, agentId) => services.workspaceStore.getAgent(workspaceId, agentId),
+        getWorkspaceSnapshot: (workspaceId) => services.workspaceStore.getWorkspaceSnapshot(workspaceId),
+        goalStore: services.externalGoalStore,
+        listWorkers: (workspaceId) => services.workspaceStore.listWorkers(workspaceId),
+        listWorkspaces: () => services.workspaceStore.listWorkspaces(),
+    });
+    return {
+        cancelExternalGoal: bridge.cancelGoal,
+        continueExternalGoal: bridge.continueGoal,
+        inspectExternalGoalWorkspace: bridge.inspectWorkspace,
+        listExternalGoalWorkspaces: bridge.listWorkspaces,
+        reportExternalGoal: bridge.reportGoal,
+        startExternalGoal: bridge.startGoal,
+        waitExternalGoal: bridge.waitGoal,
+    };
+};

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

@@ -3,6 +3,7 @@ import { type AgentLaunchConfigInput, createAgentRunStore } from './agent-run-st
 import { createAgentRuntime } from './agent-runtime.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
 import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
+import { createExternalGoalStore } from './external-goal-store.js';
 import { createMessageLogStore } from './message-log-store.js';
 import { createProtocolEventStats } from './protocol-event-stats.js';
 import type { PtyOutputBus } from './pty-output-bus.js';
@@ -40,6 +41,7 @@ export interface RuntimeStoreServices {
     agentRuntime: ReturnType<typeof createAgentRuntime>;
     db: ReturnType<typeof openRuntimeDatabase>;
     dispatchLedgerStore: ReturnType<typeof createDispatchLedgerStore>;
+    externalGoalStore: ReturnType<typeof createExternalGoalStore>;
     isRuntimeClosing: () => boolean;
     markRuntimeClosing: () => void;
     messageLogStore: ReturnType<typeof createMessageLogStore>;
@@ -91,6 +93,7 @@ export declare const createRuntimeStoreLifecycle: ({ agentManager, services, }:
     peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
     deleteWorkspaceShell: (workspaceId: string) => void;
     closeWorkspaceShell: (workspaceId: string, runId: string) => boolean;
+    findLiveRun: (runId: string) => LiveAgentRun | undefined;
     getLiveRun: (runId: string) => LiveAgentRun;
     waitForRunExit: (runId: string, timeoutMs: number) => Promise<boolean>;
     getPtyOutputBus: () => PtyOutputBus;

package/dist/src/server/runtime-store-helpers.js

@@ -5,6 +5,7 @@ import { createAgentRunStore } from './agent-run-store.js';
 import { createAgentRuntime } from './agent-runtime.js';
 import { createAgentSessionStore } from './agent-session-store.js';
 import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
+import { createExternalGoalStore } from './external-goal-store.js';
 import { readFeatureFlags } from './feature-flags.js';
 import { createMessageLogStore } from './message-log-store.js';
 import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
@@ -80,6 +81,7 @@ export const createRuntimeStoreServices = (options = {}) => {
     const uploadStorage = createWorkspaceUploadStorage(options.dataDir);
     const messageLogStore = createMessageLogStore(db);
     const dispatchLedgerStore = createDispatchLedgerStore(db);
+    const externalGoalStore = createExternalGoalStore(db);
     const teamMemoryStore = createTeamMemoryStore(db);
     const teamMemoryDreamStore = createTeamMemoryDreamStore(db);
     const teamRecallStore = createTeamRecallStore(db);
@@ -305,6 +307,7 @@ export const createRuntimeStoreServices = (options = {}) => {
         agentRuntime,
         db,
         dispatchLedgerStore,
+        externalGoalStore,
         isRuntimeClosing: () => closing,
         markRuntimeClosing: () => {
             closing = true;
@@ -426,6 +429,7 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
         });
         return Promise.all(starts);
     };
+    const findLiveRun = (runId) => services.shellRuntime.getLiveRun(runId) ?? services.agentRuntime.findLiveRun(runId);
     return {
         close: async () => {
             services.markRuntimeClosing();
@@ -457,7 +461,13 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
             services.shellRuntime.deleteWorkspace(workspaceId);
         },
         closeWorkspaceShell: (workspaceId, runId) => services.shellRuntime.closeRun(workspaceId, runId),
-        getLiveRun: (runId) => services.shellRuntime.getLiveRun(runId) ?? services.agentRuntime.getLiveRun(runId),
+        findLiveRun,
+        getLiveRun: (runId) => {
+            const run = findLiveRun(runId);
+            if (!run)
+                throw new Error(`Live run not found: ${runId}`);
+            return run;
+        },
         waitForRunExit: (runId, timeoutMs) => services.agentRuntime.waitForRunExit(runId, timeoutMs),
         getPtyOutputBus: () => {
             if (!agentManager)

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

@@ -1,4 +1,5 @@
 import { createRuntimeStoreDreamMethods } from './runtime-store-dream.js';
+import { createRuntimeStoreExternalGoalMethods } from './runtime-store-external-goals.js';
 import { createRuntimeStoreLifecycle, createRuntimeStoreServices, logTasksFileWatchStartError, } from './runtime-store-helpers.js';
 import { createRuntimeStoreMemoryMethods } from './runtime-store-memory.js';
 import { createRuntimeStoreRemoteMethods } from './runtime-store-remote.js';
@@ -61,6 +62,7 @@ export const createRuntimeStore = (options = {}) => {
             try {
                 runDataMutation(() => {
                     services.dispatchLedgerStore.deleteWorkspaceDispatches(workspaceId);
+                    services.externalGoalStore.deleteWorkspaceGoals(workspaceId);
                     services.teamMemoryStore.deleteWorkspaceMemories(workspaceId);
                     services.teamMemoryDreamStore.deleteWorkspaceDreamRuns(workspaceId);
                     services.workspaceStore.deleteWorkspaceData(workspaceId);
@@ -92,6 +94,7 @@ export const createRuntimeStore = (options = {}) => {
         listDispatches: services.dispatchLedgerStore.listWorkspaceDispatches,
         listOpenDispatches: services.dispatchLedgerStore.listOpenWorkspaceDispatches,
         listRecentDispatches: services.dispatchLedgerStore.listRecentWorkspaceDispatches,
+        ...createRuntimeStoreExternalGoalMethods(services),
         listWorkers: (workspaceId) => services.workspaceStore.listWorkers(workspaceId),
         getLastPtyLineForAgent: (workspaceId, agentId) => services.workerOutputTracker?.getLastPtyLine(workspaceId, agentId) ?? null,
         getWorkspaceSnapshot: (workspaceId) => services.workspaceStore.getWorkspaceSnapshot(workspaceId),
@@ -106,6 +109,7 @@ export const createRuntimeStore = (options = {}) => {
         autostartConfiguredAgents: lifecycle.autostartConfiguredAgents,
         startWorkspaceWatch: lifecycle.startWorkspaceWatch,
         startWorkspaceShell: lifecycle.startWorkspaceShell,
+        findLiveRun: lifecycle.findLiveRun,
         getLiveRun: lifecycle.getLiveRun,
         waitForRunExit: lifecycle.waitForRunExit,
         getActiveRunByAgentId: (workspaceId, agentId) => services.agentRuntime.getActiveRunByAgentId(workspaceId, agentId),
@@ -122,9 +126,11 @@ export const createRuntimeStore = (options = {}) => {
         settings: services.settings,
         writeRunInput: lifecycle.writeRunInput,
         getUiToken: () => services.uiAuth.getToken(),
+        getSupervisorToken: () => services.uiAuth.getSupervisorToken(),
         stopAgentRun: lifecycle.stopTerminalRun,
         validateAgentToken: (agentId, token) => services.agentRuntime.validateAgentToken(agentId, token),
         validateUiToken: (token) => services.uiAuth.validate(token),
+        validateSupervisorToken: (token) => services.uiAuth.validateSupervisorToken(token),
         getRetentionSignals: () => services.protocolEventStats.getRetentionSignals(),
         ...createRuntimeStoreRemoteMethods(services),
         getWorkflowDispatchAwaiter: () => services.workflowDispatchAwaiter,

package/dist/src/server/sqlite-schema-v37.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion37: (db: Database) => void;

package/dist/src/server/sqlite-schema-v37.js

@@ -0,0 +1,38 @@
+export const applySchemaVersion37 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS external_goal_sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      status TEXT NOT NULL,
+      goal TEXT NOT NULL,
+      context_json TEXT NOT NULL,
+      title TEXT,
+      summary TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      closed_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_external_goal_sessions_workspace
+      ON external_goal_sessions (workspace_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS external_goal_events (
+      id TEXT PRIMARY KEY,
+      goal_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      kind TEXT NOT NULL,
+      status TEXT,
+      body TEXT NOT NULL,
+      artifacts_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(goal_id, sequence)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_external_goal_events_goal
+      ON external_goal_events (goal_id, sequence);
+    CREATE INDEX IF NOT EXISTS idx_external_goal_events_workspace
+      ON external_goal_events (workspace_id, created_at);
+  `);
+};

package/dist/src/server/sqlite-schema.d.ts

@@ -1,3 +1,3 @@
 import type { Database } from 'better-sqlite3';
-export declare const CURRENT_SCHEMA_VERSION = 36;
+export declare const CURRENT_SCHEMA_VERSION = 37;
 export declare const initializeRuntimeDatabase: (db: Database) => void;

package/dist/src/server/sqlite-schema.js

@@ -29,7 +29,8 @@ import { applySchemaVersion33 } from './sqlite-schema-v33.js';
 import { applySchemaVersion34 } from './sqlite-schema-v34.js';
 import { applySchemaVersion35 } from './sqlite-schema-v35.js';
 import { applySchemaVersion36 } from './sqlite-schema-v36.js';
-export const CURRENT_SCHEMA_VERSION = 36;
+import { applySchemaVersion37 } from './sqlite-schema-v37.js';
+export const CURRENT_SCHEMA_VERSION = 37;
 // Idempotent column-add helper. SQLite doesn't have `ALTER TABLE … ADD COLUMN
 // IF NOT EXISTS`, so PRAGMA-check first. Safe to call on every init; required
 // for foreign-built DBs where the version-gated migration is skipped.
@@ -195,6 +196,41 @@ export const initializeRuntimeDatabase = (db) => {
 
     CREATE INDEX IF NOT EXISTS idx_workspace_uploads_workspace_created
       ON workspace_uploads (workspace_id, created_at DESC, id DESC);
+
+    CREATE TABLE IF NOT EXISTS external_goal_sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      status TEXT NOT NULL,
+      goal TEXT NOT NULL,
+      context_json TEXT NOT NULL,
+      title TEXT,
+      summary TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      closed_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_external_goal_sessions_workspace
+      ON external_goal_sessions (workspace_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS external_goal_events (
+      id TEXT PRIMARY KEY,
+      goal_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      kind TEXT NOT NULL,
+      status TEXT,
+      body TEXT NOT NULL,
+      artifacts_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(goal_id, sequence)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_external_goal_events_goal
+      ON external_goal_events (goal_id, sequence);
+    CREATE INDEX IF NOT EXISTS idx_external_goal_events_workspace
+      ON external_goal_events (workspace_id, created_at);
   `);
     // Idempotent column additions — run on every init regardless of
     // schema_version. The v19 migration adds these columns but is gated on
@@ -404,4 +440,8 @@ export const initializeRuntimeDatabase = (db) => {
     if (!appliedVersions.has(36)) {
         db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(36, Date.now());
     }
+    applySchemaVersion37(db);
+    if (!appliedVersions.has(37)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(37, Date.now());
+    }
 };

package/dist/src/server/team-authz.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
-export type TeamCommand = 'send' | 'list' | 'next' | 'report' | 'recall' | 'memory_add' | 'memory_apply' | 'memory_dream_show' | 'memory_forget' | 'memory_search' | 'memory_show' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
+export type TeamCommand = 'send' | 'list' | 'next' | 'report' | 'recall' | 'memory_add' | 'memory_apply' | 'memory_dream_show' | 'memory_forget' | 'memory_search' | 'memory_show' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow' | 'goal_report';
 export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
 /**
  * Dispatch-target gate: the sentinel is an observer, so handing it a dispatch

package/dist/src/server/team-authz.js

@@ -15,6 +15,7 @@ const ORCHESTRATOR_COMMANDS = new Set([
     'spawn',
     'dismiss',
     'workflow',
+    'goal_report',
 ]);
 const WORKER_COMMANDS = new Set([
     'report',

package/dist/src/server/ui-auth.d.ts

@@ -1,7 +1,9 @@
 import type { IncomingMessage } from 'node:http';
 export interface UiAuth {
     getToken: () => string;
+    getSupervisorToken: () => string;
     validate: (token: string | undefined) => boolean;
+    validateSupervisorToken: (token: string | undefined) => boolean;
     isTunnelRequest: (request: IncomingMessage) => boolean;
     getTunnelSecret: () => string;
 }