@tt-a1i/hive 2.1.9 → 2.1.11

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/scenario-presets.d.ts

@@ -3,11 +3,14 @@ import type { WorkerRole } from '../shared/types.js';
 import type { UiLanguage } from '../shared/ui-language.js';
 export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, type ScenarioId, type ScenarioPreset, type ScenarioWorkerSpec, } from '../shared/scenario-presets.js';
 /**
- * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
- * and unlikely to collide. The caller passes an `isTaken` probe against the
- * live roster; on the (rare) collision we just roll again.
+ * Scenario member names come from the same role-flavored historical-figure
+ * pool the Add Member dialog uses. When a pool is exhausted in a busy
+ * workspace, append a short suffix instead of failing the whole scenario.
  */
-export declare const buildScenarioWorkerName: (spec: Pick<ScenarioWorkerSpec, "nameStem">, isTaken: (name: string) => boolean, maxAttempts?: number) => string;
+export declare const buildScenarioWorkerName: (spec: Pick<ScenarioWorkerSpec, "nameStem" | "role">, usedNames: ReadonlySet<string>, input?: {
+    language?: UiLanguage;
+    nextUint32?: () => number;
+}, maxAttempts?: number) => string;
 export interface ScenarioKickoffInput {
     scenarioId: string;
     goal: string;

package/dist/src/server/scenario-presets.js

@@ -1,15 +1,25 @@
 import { randomBytes } from 'node:crypto';
+import { generateWorkerName } from '../shared/random-worker-name.js';
 export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, } from '../shared/scenario-presets.js';
 /**
- * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
- * and unlikely to collide. The caller passes an `isTaken` probe against the
- * live roster; on the (rare) collision we just roll again.
+ * Scenario member names come from the same role-flavored historical-figure
+ * pool the Add Member dialog uses. When a pool is exhausted in a busy
+ * workspace, append a short suffix instead of failing the whole scenario.
  */
-export const buildScenarioWorkerName = (spec, isTaken, maxAttempts = 16) => {
+export const buildScenarioWorkerName = (spec, usedNames, input = {}, maxAttempts = 16) => {
+    const candidate = generateWorkerName({
+        role: spec.role,
+        usedNames,
+        ...(input.language !== undefined ? { language: input.language } : {}),
+        ...(input.nextUint32 !== undefined ? { nextUint32: input.nextUint32 } : {}),
+    });
+    if (!usedNames.has(candidate))
+        return candidate;
+    const base = candidate || spec.nameStem;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const suffix = randomBytes(3).readUIntBE(0, 3).toString(36).padStart(4, '0').slice(-4);
-        const name = `${spec.nameStem}-${suffix}`;
-        if (!isTaken(name))
+        const name = `${base}-${suffix}`;
+        if (!usedNames.has(name))
             return name;
     }
     throw new Error(`Could not generate a unique member name for: ${spec.nameStem}`);

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;
 }

package/dist/src/server/ui-auth.js

@@ -2,6 +2,7 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { HIVE_REMOTE_SECRET_HEADER } from './remote-loopback-auth.js';
 export const createUiAuth = () => {
     const token = randomUUID();
+    const supervisorToken = randomUUID();
     // 32 bytes of CSPRNG entropy, fresh every boot. base64url so it travels as a
     // clean header value. Held only in this closure.
     const tunnelSecret = randomBytes(32).toString('base64url');
@@ -10,9 +11,15 @@ export const createUiAuth = () => {
         getToken() {
             return token;
         },
+        getSupervisorToken() {
+            return supervisorToken;
+        },
         validate(input) {
             return input === token;
         },
+        validateSupervisorToken(input) {
+            return input === supervisorToken;
+        },
         isTunnelRequest(request) {
             const raw = request.headers[HIVE_REMOTE_SECRET_HEADER];
             const got = Array.isArray(raw) ? raw[0] : raw;

package/dist/src/shared/random-worker-name.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerRole } from './types.js';
+import type { UiLanguage } from './ui-language.js';
+export interface GenerateWorkerNameOptions {
+    language?: UiLanguage;
+    role?: WorkerRole;
+    usedNames?: ReadonlySet<string>;
+    nextUint32?: () => number;
+}
+export declare const generateWorkerName: ({ language, role, usedNames, nextUint32, }?: GenerateWorkerNameOptions) => string;