@tt-a1i/hive 1.7.0 → 2.0.2

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

@@ -48,6 +48,7 @@ export interface TeamOperationsInput {
     dismissEphemeralWorker?: (workspaceId: string, workerId: string) => void;
 }
 export interface DispatchTaskInput {
+    autoStartWorker?: boolean;
     fromAgentId?: string;
     hivePort?: string;
     workflowRunId?: string;
@@ -59,7 +60,7 @@ export interface ReportTaskInput {
     artifacts?: string[];
     dispatchId?: string;
     requireActiveRun?: boolean;
-    status?: string;
+    status?: 'success' | 'failed';
     text?: string;
 }
 export interface StatusTaskInput {
@@ -75,6 +76,7 @@ export interface ReportTaskResult {
     dispatch: DispatchRecord | null;
     forwardError: string | null;
     forwarded: boolean;
+    pendingWarning?: string;
 }
 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): {
@@ -89,11 +91,13 @@ export declare const createTeamOperations: ({ agentRuntime, createDispatch, dele
     }>;
     recordUserInput(workspaceId: string, orchestratorId: string, text: string): void;
     statusTask(workspaceId: string, workerId: string, input?: StatusTaskInput): {
+        pendingWarning?: string;
         dispatch: null;
         forwardError: string | null;
         forwarded: boolean;
     };
     reportTask(workspaceId: string, workerId: string, input?: ReportTaskInput): {
+        pendingWarning?: string;
         dispatch: DispatchRecord;
         forwardError: string | null;
         forwarded: boolean;

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

@@ -25,6 +25,10 @@ export const formatUnknownWorkerError = (workerName, roster) => {
     ].join('\n');
 };
 const reportForwardErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const buildPendingWarning = (workerName, pendingTaskCount, action) => pendingTaskCount > 0
+    ? `Hive recorded the ${action}, but ${workerName} still has ${pendingTaskCount} open dispatch${pendingTaskCount === 1 ? '' : 'es'}. ` +
+        'A worker stays working until every dispatch is closed with `team report --dispatch <id>` or `team cancel --dispatch <id>`.'
+    : undefined;
 export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
     // Best-effort redelivery of reports a prior orchestrator outage stranded.
     // Called when a fresh report confirms the orchestrator is reachable and
@@ -82,6 +86,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         }
     };
     const dispatchTask = async (workspaceId, workerId, text, input = {}) => {
+        const fromAgentId = input.fromAgentId;
+        const sender = fromAgentId ? workspaceStore.getAgent(workspaceId, fromAgentId) : undefined;
+        const worker = workspaceStore.getWorker(workspaceId, workerId);
         const message = createSendMessage(workspaceId, workerId, text, input.fromAgentId);
         const messageHandle = insertMessage(message);
         let dispatch;
@@ -92,8 +99,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 toAgentId: workerId,
                 workspaceId,
             };
-            if (input.fromAgentId)
-                dispatchInput.fromAgentId = input.fromAgentId;
+            if (fromAgentId)
+                dispatchInput.fromAgentId = fromAgentId;
             if (input.workflowRunId !== undefined)
                 dispatchInput.workflowRunId = input.workflowRunId;
             if (input.stepIndex !== undefined)
@@ -104,10 +111,17 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 dispatchInput.label = input.label;
             dispatch = createDispatch(dispatchInput);
             const dispatchId = dispatch.id;
-            if (input.fromAgentId) {
-                const sender = workspaceStore.getAgent(workspaceId, input.fromAgentId);
-                await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
-                const worker = workspaceStore.getWorker(workspaceId, workerId);
+            if (fromAgentId && sender) {
+                const shouldAutoStartWorker = input.autoStartWorker !== false;
+                const hadActiveRun = Boolean(agentRuntime.getActiveRunByAgentId(workspaceId, workerId));
+                if (!hadActiveRun && shouldAutoStartWorker) {
+                    await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
+                }
+                if (!shouldAutoStartWorker && !agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
+                    workspaceStore.markTaskDispatched(workspaceId, workerId);
+                    pendingMarked = true;
+                    return dispatch;
+                }
                 const isWorkflowDispatch = input.workflowRunId !== undefined || input.fromAgentId === getWorkflowAgentId(workspaceId);
                 markDispatchSubmitted(dispatchId);
                 workspaceStore.markTaskDispatched(workspaceId, workerId);
@@ -204,14 +218,12 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             if (!worker) {
                 throw new ConflictError(formatUnknownWorkerError(workerName, roster));
             }
-            /* Capture the active-run state *before* dispatchTask runs, because
-               dispatchTask calls ensureWorkerRun on authenticated team-send calls
-               and may silently auto-start a stopped worker. Surfacing
-               `restartedWorker=true` to the orchestrator turns that silent state
-               change into a transparent one. Internal calls without `fromAgentId`
-               only queue work and do not wake a PTY, so they must not report a
-               restart. */
+            /* Capture the active-run state *before* dispatchTask runs. Internal
+               workflow calls may auto-start a stopped worker; explicit CLI
+               `team send` passes autoStartWorker:false so the worker remains
+               stopped with a queued dispatch until the user restarts it. */
             const restartedWorker = input.fromAgentId !== undefined &&
+                input.autoStartWorker !== false &&
                 !agentRuntime.getActiveRunByAgentId(workspaceId, worker.id);
             const dispatch = await dispatchTask(workspaceId, worker.id, text, input);
             return Object.assign(dispatch, { restartedWorker });
@@ -241,7 +253,13 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         console.error('[hive] swallowed:teamStatus.forward', error);
                     }
                 }
-                return { dispatch: null, forwardError, forwarded };
+                const pendingWarning = buildPendingWarning(worker.name, worker.pendingTaskCount, 'status update');
+                return {
+                    dispatch: null,
+                    forwardError,
+                    forwarded,
+                    ...(pendingWarning ? { pendingWarning } : {}),
+                };
             }
             catch (error) {
                 deleteMessage(messageHandle);
@@ -270,8 +288,10 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
                 }
                 workspaceStore.markTaskReported(workspaceId, workerId);
+                const remainingPendingTaskCount = workspaceStore.getWorker(workspaceId, workerId).pendingTaskCount;
                 let forwardError = null;
                 let forwarded = false;
+                const pendingWarning = buildPendingWarning(worker.name, remainingPendingTaskCount, 'report');
                 // Workflow-sourced dispatches: the source is the in-process runner, not a
                 // PTY. Resolve its awaiting Promise instead of injecting into orchestrator
                 // stdin (which would do nothing — `__workflow__` has no PTY).
@@ -288,7 +308,12 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         forwardError = reportForwardErrorMessage(error);
                         console.error('[hive] swallowed:teamReport.workflowForward', error);
                     }
-                    return { dispatch, forwardError, forwarded };
+                    return {
+                        dispatch,
+                        forwardError,
+                        forwarded,
+                        ...(pendingWarning ? { pendingWarning } : {}),
+                    };
                 }
                 // Real worker reported (not a workflow-internal step) — fire the
                 // outbound completion webhook. Best-effort; never blocks the report.
@@ -369,7 +394,12 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         }
                     });
                 }
-                return { dispatch, forwardError, forwarded };
+                return {
+                    dispatch,
+                    forwardError,
+                    forwarded,
+                    ...(pendingWarning ? { pendingWarning } : {}),
+                };
             }
             catch (error) {
                 deleteMessage(messageHandle);