hivehq 2.0.0

package/dist/src/server/team-memory-store.js

@@ -0,0 +1,513 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_DEFAULT_LIMIT, MEMORY_SEARCH_MAX_LIMIT, } from '../shared/team-memory.js';
+export class MemoryEntryNotFoundError extends Error {
+    memoryId;
+    workspaceId;
+    constructor(memoryId, workspaceId) {
+        super(`Memory entry not found in workspace: ${memoryId}`);
+        this.name = 'MemoryEntryNotFoundError';
+        this.memoryId = memoryId;
+        this.workspaceId = workspaceId;
+    }
+}
+export class MemoryEntryStatusError extends Error {
+    actualStatus;
+    memoryId;
+    expectedStatus;
+    constructor(memoryId, expectedStatus, actualStatus) {
+        const expected = Array.isArray(expectedStatus) ? expectedStatus.join(' or ') : expectedStatus;
+        super(`Memory entry ${memoryId} expected status ${expected}, got ${actualStatus}`);
+        this.name = 'MemoryEntryStatusError';
+        this.memoryId = memoryId;
+        this.expectedStatus = expectedStatus;
+        this.actualStatus = actualStatus;
+    }
+}
+const hashText = (text) => createHash('sha256').update(text).digest('hex');
+const excerptFor = (text) => [...text].slice(0, 500).join('');
+const clampLimit = (value) => {
+    if (value === undefined || !Number.isInteger(value) || value < 0) {
+        return MEMORY_SEARCH_DEFAULT_LIMIT;
+    }
+    return Math.min(value, MEMORY_SEARCH_MAX_LIMIT);
+};
+const clampDigestLimit = (value) => {
+    if (value === undefined || !Number.isInteger(value) || value <= 0)
+        return 20;
+    return Math.min(value, 50);
+};
+const clampListLimit = (value) => {
+    if (value === undefined || !Number.isInteger(value) || value <= 0)
+        return MEMORY_SEARCH_MAX_LIMIT;
+    return Math.min(value, MEMORY_SEARCH_MAX_LIMIT);
+};
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const toSearchTerms = (query) => query.trim().split(/\s+/).filter(Boolean);
+const toFtsQuery = (query) => toSearchTerms(query).map(quoteFtsToken).join(' AND ');
+const hasShortTerm = (terms) => terms.some((term) => [...term].length < 3);
+const escapeLike = (value) => `%${value.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_')}%`;
+const parseTags = (value) => {
+    if (!value)
+        return [];
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((tag) => typeof tag === 'string') : [];
+};
+const toEntryRecord = (row) => ({
+    archivedAt: row.archived_at,
+    body: row.body,
+    confidence: row.confidence,
+    createdAt: row.created_at,
+    disabled: row.disabled === 1,
+    id: row.id,
+    kind: row.kind,
+    lastInjectedAt: row.last_injected_at,
+    pinned: row.pinned === 1,
+    scope: row.scope,
+    source: row.source,
+    status: row.status,
+    tags: parseTags(row.tags),
+    updatedAt: row.updated_at,
+    workspaceId: row.workspace_id,
+});
+const toSourceRecord = (row) => ({
+    actorAgentIdSnapshot: row.actor_agent_id_snapshot,
+    actorNameSnapshot: row.actor_name_snapshot,
+    actorRoleSnapshot: row.actor_role_snapshot,
+    createdAt: row.created_at,
+    excerpt: row.excerpt,
+    id: row.id,
+    memoryId: row.memory_id,
+    sourceId: row.source_id,
+    sourceSequence: row.source_sequence,
+    sourceType: row.source_type,
+    textHash: row.text_hash,
+});
+export const createTeamMemoryStore = (db) => {
+    const nextFtsRowid = () => db.prepare('SELECT COALESCE(MAX(fts_rowid), 0) + 1 AS next FROM memory_entries').get().next;
+    const listSources = (memoryId) => db
+        .prepare(`SELECT *
+           FROM memory_sources
+           WHERE memory_id = ?
+           ORDER BY created_at ASC, id ASC`)
+        .all(memoryId).map(toSourceRecord);
+    const toEntryWithSources = (row) => ({
+        ...toEntryRecord(row),
+        sources: listSources(row.id),
+    });
+    const getEntryWithSources = (workspaceId, memoryId) => {
+        const row = db
+            .prepare(`SELECT *
+         FROM memory_entries
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+         LIMIT 1`)
+            .get(memoryId, workspaceId);
+        if (!row)
+            return undefined;
+        return toEntryWithSources(row);
+    };
+    const requireEntryWithSources = (workspaceId, memoryId) => {
+        const entry = getEntryWithSources(workspaceId, memoryId);
+        if (!entry)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return entry;
+    };
+    const searchFts = (table, workspaceId, ftsQuery, statuses, includeDisabled) => {
+        if (statuses.length === 0)
+            return [];
+        const indexName = table === 'memory_fts' ? 'unicode' : 'trigram';
+        const statusPlaceholders = statuses.map(() => '?').join(', ');
+        return db
+            .prepare(`SELECT
+           e.*,
+           ? AS index_name,
+           bm25(${table}) AS score
+         FROM ${table}
+         JOIN memory_entries e ON e.fts_rowid = ${table}.rowid
+         WHERE ${table} MATCH ?
+           AND e.scope = 'workspace'
+           AND e.workspace_id = ?
+           ${includeDisabled ? '' : 'AND e.disabled = 0'}
+           AND e.status IN (${statusPlaceholders})`)
+            .all(indexName, ftsQuery, workspaceId, ...statuses);
+    };
+    const searchLike = (workspaceId, terms, statuses, includeDisabled) => {
+        if (terms.length === 0 || statuses.length === 0)
+            return [];
+        const predicates = terms
+            .map(() => "(e.body LIKE ? ESCAPE '\\' OR COALESCE(e.tags, '') LIKE ? ESCAPE '\\')")
+            .join(' AND ');
+        const statusPlaceholders = statuses.map(() => '?').join(', ');
+        return db
+            .prepare(`SELECT
+           e.*,
+           'like' AS index_name,
+           0 AS score
+         FROM memory_entries e
+         WHERE e.scope = 'workspace'
+           AND e.workspace_id = ?
+           ${includeDisabled ? '' : 'AND e.disabled = 0'}
+           AND e.status IN (${statusPlaceholders})
+           AND ${predicates}`)
+            .all(workspaceId, ...statuses, ...terms.flatMap((term) => [escapeLike(term), escapeLike(term)]));
+    };
+    const searchEntries = (workspaceId, query, options = {}) => {
+        if ([...query].length > MEMORY_QUERY_MAX_CHARS)
+            return [];
+        const ftsQuery = toFtsQuery(query);
+        if (!ftsQuery)
+            return [];
+        const terms = toSearchTerms(query);
+        const statuses = options.statuses ?? ['active'];
+        const includeDisabled = options.includeDisabled ?? false;
+        const rows = [
+            ...searchFts('memory_fts', workspaceId, ftsQuery, statuses, includeDisabled),
+            ...searchFts('memory_fts_trigram', workspaceId, ftsQuery, statuses, includeDisabled),
+            ...(hasShortTerm(terms) ? searchLike(workspaceId, terms, statuses, includeDisabled) : []),
+        ];
+        const byId = new Map();
+        for (const row of rows) {
+            const previous = byId.get(row.id);
+            if (!previous || row.score < previous.score)
+                byId.set(row.id, row);
+        }
+        return [...byId.values()]
+            .sort((a, b) => a.score - b.score || b.updated_at - a.updated_at)
+            .slice(0, clampLimit(options.limit))
+            .map((row) => ({
+            ...toEntryWithSources(row),
+            indexName: row.index_name,
+            score: row.score,
+        }));
+    };
+    const listEntries = (workspaceId, options = {}) => {
+        const statuses = options.statuses ?? ['active'];
+        if (statuses.length === 0)
+            return [];
+        const statusPlaceholders = statuses.map(() => '?').join(', ');
+        return db
+            .prepare(`SELECT *
+           FROM memory_entries
+           WHERE scope = 'workspace'
+             AND workspace_id = ?
+             AND status IN (${statusPlaceholders})
+           ORDER BY
+             CASE status
+               WHEN 'candidate' THEN 0
+               WHEN 'active' THEN 1
+               WHEN 'archived' THEN 2
+               ELSE 3
+             END ASC,
+             pinned DESC,
+             updated_at DESC,
+             created_at DESC,
+             id ASC
+           LIMIT ?`)
+            .all(workspaceId, ...statuses, clampListLimit(options.limit)).map(toEntryWithSources);
+    };
+    const listAllEntries = (workspaceId) => db
+        .prepare(`SELECT *
+           FROM memory_entries
+           WHERE scope = 'workspace'
+             AND workspace_id = ?
+           ORDER BY
+             CASE status
+               WHEN 'candidate' THEN 0
+               WHEN 'active' THEN 1
+               WHEN 'archived' THEN 2
+               ELSE 3
+             END ASC,
+             pinned DESC,
+             updated_at DESC,
+             created_at DESC,
+             id ASC`)
+        .all(workspaceId).map(toEntryWithSources);
+    const listDigestEntries = (workspaceId, options = {}) => db
+        .prepare(`SELECT *
+           FROM memory_entries
+           WHERE scope = 'workspace'
+             AND workspace_id = ?
+             AND status = 'active'
+             AND disabled = 0
+           ORDER BY
+             pinned DESC,
+             CASE source WHEN 'manual' THEN 0 ELSE 1 END ASC,
+             COALESCE(confidence, 0) DESC,
+             updated_at DESC,
+             created_at DESC,
+             id ASC
+           LIMIT ?`)
+        .all(workspaceId, clampDigestLimit(options.limit)).map(toEntryWithSources);
+    const listExportEntries = (workspaceId) => db
+        .prepare(`SELECT *
+           FROM memory_entries
+           WHERE scope = 'workspace'
+             AND workspace_id = ?
+             AND status = 'active'
+           ORDER BY
+             kind ASC,
+             pinned DESC,
+             CASE source WHEN 'manual' THEN 0 ELSE 1 END ASC,
+             COALESCE(confidence, 0) DESC,
+             updated_at DESC,
+             created_at DESC,
+             id ASC`)
+        .all(workspaceId).map(toEntryWithSources);
+    const addEntry = (input) => {
+        const id = randomUUID();
+        const sourceId = randomUUID();
+        const now = Date.now();
+        const status = input.actor.role === 'orchestrator' ? 'active' : 'candidate';
+        const source = input.source ?? 'manual';
+        const confidence = input.confidence ?? (source === 'manual' ? 1 : null);
+        const tags = JSON.stringify(input.tags ?? []);
+        db.transaction(() => {
+            const ftsRowid = nextFtsRowid();
+            db.prepare(`INSERT INTO memory_entries (
+          id,
+          workspace_id,
+          scope,
+          fts_rowid,
+          kind,
+          body,
+          tags,
+          status,
+          source,
+          confidence,
+          pinned,
+          disabled,
+          created_at,
+          updated_at,
+          archived_at,
+          last_injected_at
+        ) VALUES (?, ?, 'workspace', ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, NULL, NULL)`).run(id, input.workspaceId, ftsRowid, input.kind, input.body, tags, status, source, confidence, now, now);
+            db.prepare(`INSERT INTO memory_sources (
+          id,
+          memory_id,
+          source_type,
+          source_id,
+          source_sequence,
+          excerpt,
+          text_hash,
+          actor_agent_id_snapshot,
+          actor_name_snapshot,
+          actor_role_snapshot,
+          created_at
+        ) VALUES (?, ?, 'manual', NULL, NULL, ?, ?, ?, ?, ?, ?)`).run(sourceId, id, excerptFor(input.body), hashText(input.body), input.actor.id, input.actor.name, input.actor.role, now);
+        })();
+        const created = getEntryWithSources(input.workspaceId, id);
+        if (!created)
+            throw new Error(`Memory entry disappeared after insert: ${id}`);
+        return created;
+    };
+    const logInjections = (input) => {
+        if (input.memoryIds.length === 0)
+            return [];
+        const injectedAt = Date.now();
+        const ids = input.memoryIds.map(() => randomUUID());
+        db.transaction(() => {
+            for (const [index, memoryId] of input.memoryIds.entries()) {
+                const memory = db
+                    .prepare(`SELECT id
+             FROM memory_entries
+             WHERE id = ?
+               AND scope = 'workspace'
+               AND workspace_id = ?
+             LIMIT 1`)
+                    .get(memoryId, input.workspaceId);
+                if (!memory) {
+                    throw new MemoryEntryNotFoundError(memoryId, input.workspaceId);
+                }
+                db.prepare(`INSERT INTO memory_injections (
+            id,
+            memory_id,
+            workspace_id,
+            target_agent_id_snapshot,
+            context_type,
+            dispatch_id,
+            injected_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(ids[index], memoryId, input.workspaceId, input.targetAgentIdSnapshot ?? null, input.contextType, input.dispatchId ?? null, injectedAt);
+                db.prepare(`UPDATE memory_entries
+           SET last_injected_at = ?
+           WHERE id = ? AND workspace_id = ?`).run(injectedAt, memoryId, input.workspaceId);
+            }
+        })();
+        return ids;
+    };
+    const deleteInjections = (injectionIds) => {
+        if (injectionIds.length === 0)
+            return;
+        const placeholders = injectionIds.map(() => '?').join(', ');
+        db.transaction(() => {
+            const rows = db
+                .prepare(`SELECT DISTINCT memory_id, workspace_id
+           FROM memory_injections
+           WHERE id IN (${placeholders})`)
+                .all(...injectionIds);
+            db.prepare(`DELETE FROM memory_injections WHERE id IN (${placeholders})`).run(...injectionIds);
+            for (const row of rows) {
+                db.prepare(`UPDATE memory_entries
+           SET last_injected_at = (
+             SELECT MAX(injected_at)
+             FROM memory_injections
+             WHERE memory_id = ?
+               AND workspace_id = ?
+           )
+           WHERE id = ?
+             AND workspace_id = ?`).run(row.memory_id, row.workspace_id, row.memory_id, row.workspace_id);
+            }
+        })();
+    };
+    const archiveEntry = (workspaceId, memoryId) => {
+        const current = requireEntryWithSources(workspaceId, memoryId);
+        if (current.status === 'archived')
+            return current;
+        if (current.status !== 'active') {
+            throw new MemoryEntryStatusError(memoryId, 'active', current.status);
+        }
+        const now = Date.now();
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET status = 'archived',
+             archived_at = ?,
+             updated_at = ?
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+           AND status = 'active'`)
+            .run(now, now, memoryId, workspaceId);
+        if (result.changes === 0)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return requireEntryWithSources(workspaceId, memoryId);
+    };
+    const approveCandidate = (workspaceId, memoryId) => {
+        const current = requireEntryWithSources(workspaceId, memoryId);
+        if (current.status !== 'candidate') {
+            throw new MemoryEntryStatusError(memoryId, 'candidate', current.status);
+        }
+        const now = Date.now();
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET status = 'active',
+             archived_at = NULL,
+             updated_at = ?
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+           AND status = 'candidate'`)
+            .run(now, memoryId, workspaceId);
+        if (result.changes === 0)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return requireEntryWithSources(workspaceId, memoryId);
+    };
+    const rejectCandidate = (workspaceId, memoryId) => {
+        const current = requireEntryWithSources(workspaceId, memoryId);
+        if (current.status !== 'candidate') {
+            throw new MemoryEntryStatusError(memoryId, 'candidate', current.status);
+        }
+        const now = Date.now();
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET status = 'rejected',
+             updated_at = ?
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+           AND status = 'candidate'`)
+            .run(now, memoryId, workspaceId);
+        if (result.changes === 0)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return requireEntryWithSources(workspaceId, memoryId);
+    };
+    const setPinned = (workspaceId, memoryId, pinned) => {
+        const current = requireEntryWithSources(workspaceId, memoryId);
+        if (current.status !== 'active') {
+            throw new MemoryEntryStatusError(memoryId, 'active', current.status);
+        }
+        const now = Date.now();
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET pinned = ?,
+             updated_at = ?
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+           AND status = 'active'`)
+            .run(pinned ? 1 : 0, now, memoryId, workspaceId);
+        if (result.changes === 0)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return requireEntryWithSources(workspaceId, memoryId);
+    };
+    const setDisabled = (workspaceId, memoryId, disabled) => {
+        const current = requireEntryWithSources(workspaceId, memoryId);
+        if (current.status !== 'active') {
+            throw new MemoryEntryStatusError(memoryId, 'active', current.status);
+        }
+        const now = Date.now();
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET disabled = ?,
+             updated_at = ?
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+           AND status = 'active'`)
+            .run(disabled ? 1 : 0, now, memoryId, workspaceId);
+        if (result.changes === 0)
+            throw new MemoryEntryNotFoundError(memoryId, workspaceId);
+        return requireEntryWithSources(workspaceId, memoryId);
+    };
+    const deleteWorkspaceMemories = (workspaceId) => {
+        db.transaction(() => {
+            db.prepare('DELETE FROM memory_injections WHERE workspace_id = ?').run(workspaceId);
+            const rows = db
+                .prepare(`SELECT id
+           FROM memory_entries
+           WHERE scope = 'workspace'
+             AND workspace_id = ?`)
+                .all(workspaceId);
+            for (const row of rows) {
+                db.prepare('DELETE FROM memory_sources WHERE memory_id = ?').run(row.id);
+                db.prepare('DELETE FROM memory_injections WHERE memory_id = ?').run(row.id);
+            }
+            db.prepare(`DELETE FROM memory_entries
+         WHERE scope = 'workspace'
+           AND workspace_id = ?`).run(workspaceId);
+        })();
+    };
+    const listInjectionsForDispatch = (workspaceId, dispatchId) => db
+        .prepare(`SELECT *
+           FROM memory_injections
+           WHERE workspace_id = ?
+             AND dispatch_id = ?
+           ORDER BY injected_at ASC, id ASC`)
+        .all(workspaceId, dispatchId).map((row) => ({
+        contextType: row.context_type,
+        dispatchId: row.dispatch_id,
+        id: row.id,
+        injectedAt: row.injected_at,
+        memory: requireEntryWithSources(workspaceId, row.memory_id),
+        memoryId: row.memory_id,
+        targetAgentIdSnapshot: row.target_agent_id_snapshot,
+        workspaceId: row.workspace_id,
+    }));
+    return {
+        addEntry,
+        approveCandidate,
+        archiveEntry,
+        deleteWorkspaceMemories,
+        deleteInjections,
+        getEntryWithSources,
+        listDigestEntries,
+        listExportEntries,
+        listAllEntries,
+        listEntries,
+        listInjectionsForDispatch,
+        logInjections,
+        rejectCandidate,
+        searchEntries,
+        setDisabled,
+        setPinned,
+    };
+};

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

@@ -0,0 +1,102 @@
+import type { TeamListItem } from '../shared/types.js';
+import type { AgentRuntime } from './agent-runtime.js';
+import type { DispatchRecord } from './dispatch-ledger-store.js';
+import type { MessageLogHandle, MessageLogRecord } from './message-log-store.js';
+import type { ReportOutboxStore } from './report-outbox-store.js';
+import type { WebhookEvent } from './webhook-notifier.js';
+import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
+import type { WorkspaceStore } from './workspace-store.js';
+export declare const formatUnknownWorkerError: (workerName: string, roster: readonly TeamListItem[]) => string;
+export interface TeamOperationsInput {
+    agentRuntime: AgentRuntime;
+    createDispatch: (input: {
+        fromAgentId?: string;
+        label?: string;
+        phase?: string;
+        stepIndex?: number;
+        text: string;
+        toAgentId: string;
+        workflowRunId?: string;
+        workspaceId: string;
+    }) => DispatchRecord;
+    deleteDispatch: (dispatchId: string) => void;
+    deleteMessage: (handle: MessageLogHandle) => void;
+    findOpenDispatch: (workspaceId: string, toAgentId: string, dispatchId?: string) => DispatchRecord | undefined;
+    findOpenDispatchById: (workspaceId: string, dispatchId: string) => DispatchRecord | undefined;
+    insertMessage: (record: MessageLogRecord) => MessageLogHandle;
+    markDispatchCancelled: (input: {
+        dispatchId: string;
+        reason: string;
+        workspaceId: string;
+    }) => DispatchRecord | undefined;
+    markDispatchReportedByWorker: (input: {
+        artifacts: string[];
+        dispatchId?: string;
+        reportText: string;
+        toAgentId: string;
+        workspaceId: string;
+    }) => DispatchRecord | undefined;
+    markDispatchSubmitted: (dispatchId: string) => void;
+    reportOutbox: ReportOutboxStore;
+    /** Fire an outbound completion webhook (best-effort) when a worker reports. */
+    notifyWebhook?: (event: WebhookEvent) => void;
+    workflowDispatchAwaiter: WorkflowDispatchAwaiter;
+    workspaceStore: WorkspaceStore;
+    /** Auto-dismiss an ephemeral orchestrator-spawned worker after its
+     *  dispatch report. Wired in runtime-store-helpers to remove the worker
+     *  completely (stop run, drop launch config, drop the row). M11. */
+    dismissEphemeralWorker?: (workspaceId: string, workerId: string) => void;
+}
+export interface DispatchTaskInput {
+    autoStartWorker?: boolean;
+    fromAgentId?: string;
+    hivePort?: string;
+    workflowRunId?: string;
+    stepIndex?: number;
+    phase?: string;
+    label?: string;
+}
+export interface ReportTaskInput {
+    artifacts?: string[];
+    dispatchId?: string;
+    requireActiveRun?: boolean;
+    status?: 'success' | 'failed';
+    text?: string;
+}
+export interface StatusTaskInput {
+    artifacts?: string[];
+    requireActiveRun?: boolean;
+    text?: string;
+}
+export interface CancelTaskInput {
+    fromAgentId: string;
+    reason: string;
+}
+export interface ReportTaskResult {
+    dispatch: DispatchRecord | null;
+    forwardError: string | null;
+    forwarded: boolean;
+}
+export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }: TeamOperationsInput) => {
+    cancelTask(workspaceId: string, dispatchId: string, input: CancelTaskInput): {
+        dispatch: DispatchRecord;
+        forwardError: string | null;
+        forwarded: boolean;
+    };
+    dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
+    drainReportOutbox: (workspaceId: string) => void;
+    dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord & {
+        restartedWorker: boolean;
+    }>;
+    recordUserInput(workspaceId: string, orchestratorId: string, text: string): void;
+    statusTask(workspaceId: string, workerId: string, input?: StatusTaskInput): {
+        dispatch: null;
+        forwardError: string | null;
+        forwarded: boolean;
+    };
+    reportTask(workspaceId: string, workerId: string, input?: ReportTaskInput): {
+        dispatch: DispatchRecord;
+        forwardError: string | null;
+        forwarded: boolean;
+    };
+};