@tt-a1i/hive 2.0.2 → 2.1.1

package/dist/src/server/diagnostics-support-bundle.d.ts

@@ -0,0 +1,288 @@
+import type { RuntimeStore } from './runtime-store.js';
+import type { VersionInfoPayload } from './version-service.js';
+export declare const buildDiagnosticsSupportBundle: (input: {
+    now?: number;
+    store: RuntimeStore;
+    version: VersionInfoPayload;
+}) => {
+    app: {
+        current_version: string;
+        install_hint: string;
+        latest_version: string;
+        package_name: string;
+        update_available: boolean;
+    };
+    generated_at: number;
+    retention: import("./protocol-event-stats.js").RetentionSignals;
+    privacy: {
+        omitted: string[];
+        included_as_metadata_only: string[];
+    };
+    remote: {
+        status: {
+            connected: boolean;
+            connection: import("./remote-tunnel.js").TunnelStatus;
+            enabled: boolean;
+            gateway_url: string | null;
+            gateway_url_custom: boolean;
+            logged_in: boolean;
+        };
+        devices: {
+            active_count: number;
+            last_active_at: number | null;
+            revoked_count: number;
+            total_count: number;
+        };
+        recent_audit: {
+            action: string;
+            byte_count: number | null;
+            device_id: string | null;
+            endpoint: string | null;
+            has_preview: boolean;
+            id: number;
+            reject_reason: string | null;
+            result: string;
+            ts: number;
+            workspace_id: string | null;
+        }[];
+    };
+    runtime: {
+        arch: NodeJS.Architecture;
+        node_version: string;
+        os_release: string;
+        platform: NodeJS.Platform;
+    };
+    schema_version: number;
+    workspaces: {
+        active_workspace_id: string | null;
+        included_count: number;
+        items: {
+            action_center: {
+                attention: Record<string, unknown>[];
+                generated_at: number;
+                recent_activity: ({
+                    kind: string;
+                    status: import("./dispatch-ledger-store.js").DispatchStatus;
+                    submitted_at: number | null;
+                    timestamp: number;
+                    to_agent_id: string;
+                    to_worker_name: string | null;
+                    workflow_run_id: string | null;
+                    label: string | null;
+                    phase: string | null;
+                    report_preview: string | null;
+                    task_preview: string | null;
+                    has_label?: never;
+                    has_phase?: never;
+                    created_at: number;
+                    id: string;
+                } | {
+                    kind: string;
+                    status: import("./dispatch-ledger-store.js").DispatchStatus;
+                    submitted_at: number | null;
+                    timestamp: number;
+                    to_agent_id: string;
+                    to_worker_name: string | null;
+                    workflow_run_id: string | null;
+                    has_label: boolean;
+                    has_phase: boolean;
+                    label?: never;
+                    phase?: never;
+                    report_preview?: never;
+                    task_preview?: never;
+                    created_at: number;
+                    id: string;
+                })[];
+                summary: {
+                    idle_workers: number;
+                    open_dispatches: number;
+                    recent_reports: number;
+                    stopped_with_queue: number;
+                    stopped_workers: number;
+                    total_workers: number;
+                    waiting_reports: number;
+                    working_workers: number;
+                };
+                workers: ({
+                    terminal_hint: string | null;
+                    current_dispatch: {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        label: string | null;
+                        phase: string | null;
+                        report_preview: string | null;
+                        task_preview: string | null;
+                        has_label?: never;
+                        has_phase?: never;
+                        created_at: number;
+                        id: string;
+                    } | {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        has_label: boolean;
+                        has_phase: boolean;
+                        label?: never;
+                        phase?: never;
+                        report_preview?: never;
+                        task_preview?: never;
+                        created_at: number;
+                        id: string;
+                    } | null;
+                    id: string;
+                    latest_report: {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        label: string | null;
+                        phase: string | null;
+                        report_preview: string | null;
+                        task_preview: string | null;
+                        has_label?: never;
+                        has_phase?: never;
+                        created_at: number;
+                        id: string;
+                    } | {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        has_label: boolean;
+                        has_phase: boolean;
+                        label?: never;
+                        phase?: never;
+                        report_preview?: never;
+                        task_preview?: never;
+                        created_at: number;
+                        id: string;
+                    } | null;
+                    name: string;
+                    pending_task_count: number;
+                    role: import("../shared/types.js").WorkerRole;
+                    status: "idle" | "working" | "stopped";
+                } | {
+                    terminal_hint?: never;
+                    current_dispatch: {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        label: string | null;
+                        phase: string | null;
+                        report_preview: string | null;
+                        task_preview: string | null;
+                        has_label?: never;
+                        has_phase?: never;
+                        created_at: number;
+                        id: string;
+                    } | {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        has_label: boolean;
+                        has_phase: boolean;
+                        label?: never;
+                        phase?: never;
+                        report_preview?: never;
+                        task_preview?: never;
+                        created_at: number;
+                        id: string;
+                    } | null;
+                    id: string;
+                    latest_report: {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        label: string | null;
+                        phase: string | null;
+                        report_preview: string | null;
+                        task_preview: string | null;
+                        has_label?: never;
+                        has_phase?: never;
+                        created_at: number;
+                        id: string;
+                    } | {
+                        status: import("./dispatch-ledger-store.js").DispatchStatus;
+                        submitted_at: number | null;
+                        timestamp: number;
+                        to_agent_id: string;
+                        to_worker_name: string | null;
+                        workflow_run_id: string | null;
+                        has_label: boolean;
+                        has_phase: boolean;
+                        label?: never;
+                        phase?: never;
+                        report_preview?: never;
+                        task_preview?: never;
+                        created_at: number;
+                        id: string;
+                    } | null;
+                    name: string;
+                    pending_task_count: number;
+                    role: import("../shared/types.js").WorkerRole;
+                    status: "idle" | "working" | "stopped";
+                })[];
+                workspace_id: string;
+            };
+            id: string;
+            name: string;
+            path: {
+                basename: string | null;
+                has_parent: boolean;
+                path_kind: "windows" | "unknown" | "posix";
+            };
+            recent_dispatches: {
+                artifact_count: number;
+                created_at: number;
+                from_agent_id: string | null;
+                has_label: boolean;
+                has_phase: boolean;
+                has_report: boolean;
+                id: string;
+                report_text_length: number;
+                reported_at: number | null;
+                status: import("./dispatch-ledger-store.js").DispatchStatus;
+                submitted_at: number | null;
+                task_text_length: number;
+                to_agent_id: string;
+                to_worker_name: string | null;
+                workflow_run_id: string | null;
+            }[];
+            runs: import("./terminal-input-profile.js").TerminalRunSummary[];
+            workers: {
+                command_preset_id: string | null;
+                ephemeral: boolean;
+                has_last_pty_line: boolean;
+                id: string;
+                name: string;
+                pending_task_count: number;
+                role: import("../shared/types.js").WorkerRole;
+                spawned_by: "workflow" | "orchestrator" | null;
+                status: "idle" | "working" | "stopped";
+            }[];
+            workers_truncated: boolean;
+        }[];
+        total_count: number;
+        truncated: boolean;
+    };
+};

package/dist/src/server/diagnostics-support-bundle.js

@@ -0,0 +1,179 @@
+import { arch, platform, release } from 'node:os';
+import { basename, win32 } from 'node:path';
+import { buildActionCenterSummary } from './action-center-summary.js';
+import { DEFAULT_GATEWAY_URL, REMOTE_DAEMON_TOKEN_KEY, REMOTE_ENABLED_KEY, REMOTE_GATEWAY_URL_KEY, } from './remote-config-keys.js';
+const ACTIVE_WORKSPACE_KEY = 'active_workspace_id';
+const MAX_INCLUDED_WORKSPACES = 5;
+const MAX_WORKERS_PER_WORKSPACE = 20;
+const MAX_RUNS_PER_WORKSPACE = 20;
+const MAX_RECENT_DISPATCHES = 20;
+const MAX_REMOTE_AUDIT = 50;
+const detectPathKind = (workspacePath) => {
+    if (/^[a-z]:[\\/]/iu.test(workspacePath) || workspacePath.includes('\\'))
+        return 'windows';
+    if (workspacePath.startsWith('/'))
+        return 'posix';
+    return 'unknown';
+};
+const redactWorkspacePath = (workspacePath) => {
+    const pathKind = detectPathKind(workspacePath);
+    const base = pathKind === 'windows'
+        ? win32.basename(workspacePath)
+        : basename(workspacePath) || workspacePath;
+    const trimmed = workspacePath.replace(/[\\/]+$/u, '');
+    const hasParent = pathKind === 'windows' ? trimmed.includes('\\') : trimmed.includes('/');
+    return {
+        basename: base || null,
+        has_parent: hasParent,
+        path_kind: pathKind,
+    };
+};
+const isLoggedIn = (store) => (store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null) !== null &&
+    (store.settings.getAppState(REMOTE_DAEMON_TOKEN_KEY)?.value ?? null) !== null;
+const buildRemoteSummary = (store) => {
+    const devices = store.getRemoteDeviceStore().list(true);
+    const activeDevices = devices.filter((device) => device.revokedAt === null);
+    const lastActiveValues = devices
+        .map((device) => device.lastActive)
+        .filter((value) => typeof value === 'number');
+    // A self-hosted gateway URL is private infrastructure; the shareable bundle
+    // only names the default gateway and otherwise records that a custom one is
+    // in use.
+    const gatewayUrl = store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null;
+    const gatewayUrlIsCustom = gatewayUrl !== null && gatewayUrl !== DEFAULT_GATEWAY_URL;
+    return {
+        status: {
+            connected: store.getRemoteTunnelStatus() === 'online',
+            connection: store.getRemoteTunnelStatus(),
+            enabled: store.settings.getAppState(REMOTE_ENABLED_KEY)?.value === 'true',
+            gateway_url: gatewayUrlIsCustom ? null : gatewayUrl,
+            gateway_url_custom: gatewayUrlIsCustom,
+            logged_in: isLoggedIn(store),
+        },
+        devices: {
+            active_count: activeDevices.length,
+            last_active_at: lastActiveValues.length > 0 ? Math.max(...lastActiveValues) : null,
+            revoked_count: devices.length - activeDevices.length,
+            total_count: devices.length,
+        },
+        recent_audit: store
+            .getRemoteAuditStore()
+            .list(MAX_REMOTE_AUDIT)
+            .map((entry) => ({
+            action: entry.action,
+            byte_count: entry.byteCount,
+            device_id: entry.deviceId,
+            endpoint: entry.endpoint,
+            has_preview: Boolean(entry.preview),
+            id: entry.id,
+            reject_reason: entry.rejectReason,
+            result: entry.result,
+            ts: entry.ts,
+            workspace_id: entry.workspaceId,
+        })),
+    };
+};
+const buildWorkspaceDiagnostics = (store, workspace) => {
+    const allWorkers = store.listWorkers(workspace.id);
+    const workers = allWorkers.slice(0, MAX_WORKERS_PER_WORKSPACE);
+    const workerNameById = new Map(workers.map((worker) => [worker.id, worker.name]));
+    const dispatches = store.listRecentDispatches(workspace.id, MAX_RECENT_DISPATCHES);
+    return {
+        action_center: buildActionCenterSummary({
+            includeTextEvidence: false,
+            store,
+            workspaceId: workspace.id,
+        }),
+        id: workspace.id,
+        name: workspace.name,
+        path: redactWorkspacePath(workspace.path),
+        recent_dispatches: dispatches.map((dispatch) => ({
+            artifact_count: dispatch.artifacts.length,
+            created_at: dispatch.createdAt,
+            from_agent_id: dispatch.fromAgentId,
+            has_label: dispatch.label !== null,
+            has_phase: dispatch.phase !== null,
+            has_report: Boolean(dispatch.reportText),
+            id: dispatch.id,
+            report_text_length: dispatch.reportText?.length ?? 0,
+            reported_at: dispatch.reportedAt,
+            status: dispatch.status,
+            submitted_at: dispatch.submittedAt,
+            task_text_length: dispatch.text.length,
+            to_agent_id: dispatch.toAgentId,
+            to_worker_name: workerNameById.get(dispatch.toAgentId) ?? null,
+            workflow_run_id: dispatch.workflowRunId,
+        })),
+        runs: store.listTerminalRuns(workspace.id).slice(0, MAX_RUNS_PER_WORKSPACE),
+        workers: workers.map((worker) => ({
+            command_preset_id: worker.commandPresetId ??
+                store.peekAgentLaunchConfig(workspace.id, worker.id)?.commandPresetId ??
+                null,
+            ephemeral: worker.ephemeral === true,
+            has_last_pty_line: Boolean(store.getLastPtyLineForAgent(workspace.id, worker.id)),
+            id: worker.id,
+            name: worker.name,
+            pending_task_count: worker.pendingTaskCount,
+            role: worker.role,
+            spawned_by: worker.spawnedBy ?? null,
+            status: worker.status,
+        })),
+        workers_truncated: allWorkers.length > MAX_WORKERS_PER_WORKSPACE,
+    };
+};
+export const buildDiagnosticsSupportBundle = (input) => {
+    const now = input.now ?? Date.now();
+    const workspaces = input.store.listWorkspaces();
+    const includedWorkspaces = workspaces.slice(0, MAX_INCLUDED_WORKSPACES);
+    return {
+        app: {
+            current_version: input.version.current_version,
+            install_hint: input.version.install_hint,
+            latest_version: input.version.latest_version,
+            package_name: input.version.package_name,
+            update_available: input.version.update_available,
+        },
+        generated_at: now,
+        /* Local-only per-day protocol activity counters (issue #23) — counts only,
+           no task text, no names; safe for a shareable bundle. */
+        retention: input.store.getRetentionSignals(),
+        privacy: {
+            omitted: [
+                'tokens',
+                'cookies',
+                'remote_device_keys',
+                'environment_variables',
+                'full_terminal_transcripts',
+                'remote_ws_input_previews',
+                'dispatch_text_previews',
+                'report_text_previews',
+                'last_pty_line_previews',
+                'project_source_files',
+                'full_workspace_paths',
+                'custom_gateway_urls',
+            ],
+            included_as_metadata_only: [
+                'dispatch_text',
+                'report_text',
+                'last_pty_line',
+                'dispatch_labels',
+                'dispatch_phases',
+            ],
+        },
+        remote: buildRemoteSummary(input.store),
+        runtime: {
+            arch: arch(),
+            node_version: process.version,
+            os_release: release(),
+            platform: platform(),
+        },
+        schema_version: 1,
+        workspaces: {
+            active_workspace_id: input.store.settings.getAppState(ACTIVE_WORKSPACE_KEY)?.value ?? null,
+            included_count: includedWorkspaces.length,
+            items: includedWorkspaces.map((workspace) => buildWorkspaceDiagnostics(input.store, workspace)),
+            total_count: workspaces.length,
+            truncated: workspaces.length > includedWorkspaces.length,
+        },
+    };
+};

package/dist/src/server/dispatch-ledger-store.d.ts

@@ -53,16 +53,20 @@ export declare const createDispatchLedgerStore: (db: Database) => {
     deleteWorkspaceDispatches: (workspaceId: string) => void;
     findOpenDispatch: (workspaceId: string, toAgentId: string, dispatchId?: string) => DispatchRecord | undefined;
     findOpenDispatchById: (workspaceId: string, dispatchId: string) => DispatchRecord | undefined;
+    claimQueuedDispatch: (dispatchId: string) => boolean;
+    reparkClaimedDispatch: (dispatchId: string) => boolean;
     listOpenDispatchKinds: () => Array<{
         type: "send";
         worker_id: string;
         workspace_id: string;
     }>;
     listOpenDispatchIdsForRun: (runId: string) => string[];
+    listOpenWorkspaceDispatches: (workspaceId: string) => DispatchRecord[];
     listOpenWorkflowDispatchesForWorker: (workspaceId: string, workerId: string) => Array<{
         dispatchId: string;
         runId: string;
     }>;
+    listRecentWorkspaceDispatches: (workspaceId: string, limit?: number) => DispatchRecord[];
     listWorkflowRunDispatches: (runId: string) => DispatchRecord[];
     listWorkspaceDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     markCancelled: (input: CancelDispatchInput) => {
@@ -103,6 +107,5 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         workflowRunId: string | null;
         workspaceId: string;
     } | undefined;
-    markSubmitted: (dispatchId: string) => void;
 };
 export {};

package/dist/src/server/dispatch-ledger-store.js

@@ -75,11 +75,28 @@ export const createDispatchLedgerStore = (db) => {
     const deleteDispatch = (dispatchId) => {
         db.prepare('DELETE FROM dispatches WHERE id = ?').run(dispatchId);
     };
-    const markSubmitted = (dispatchId) => {
-        const submittedAt = Date.now();
-        db.prepare(`UPDATE dispatches
-       SET status = ?, submitted_at = ?
-       WHERE id = ?`).run('submitted', submittedAt, dispatchId);
+    /** Atomic claim for delivery: flips queued → submitted only if still
+     *  queued. Exactly one of N racing deliverers (send path, start replay)
+     *  wins; the rest skip the PTY write. */
+    const claimQueuedDispatch = (dispatchId) => {
+        const result = db
+            .prepare(`UPDATE dispatches
+         SET status = 'submitted', submitted_at = ?
+         WHERE id = ? AND status = 'queued'`)
+            .run(Date.now(), dispatchId);
+        return result.changes === 1;
+    };
+    /** Inverse of claimQueuedDispatch for replay failures: the write never
+     *  reached a live PTY (PtyInactive), so the dispatch goes back to parked
+     *  instead of being cancelled — the next worker start retries it. Only a
+     *  still-'submitted' row can be reparked (a report/cancel wins). */
+    const reparkClaimedDispatch = (dispatchId) => {
+        const result = db
+            .prepare(`UPDATE dispatches
+         SET status = 'queued', submitted_at = NULL
+         WHERE id = ? AND status = 'submitted'`)
+            .run(dispatchId);
+        return result.changes === 1;
     };
     const findOpenDispatch = (workspaceId, toAgentId, dispatchId) => {
         if (dispatchId) {
@@ -175,6 +192,26 @@ export const createDispatchLedgerStore = (db) => {
            LIMIT ? OFFSET ?`)
             .all(workspaceId, limit, offset).map(toRecord);
     };
+    const listRecentWorkspaceDispatches = (workspaceId, limit = 100) => {
+        const rows = db
+            .prepare(`SELECT *
+         FROM dispatches
+         WHERE workspace_id = ?
+         ORDER BY sequence DESC, created_at DESC
+         LIMIT ?`)
+            .all(workspaceId, limit);
+        return rows.map(toRecord);
+    };
+    const listOpenWorkspaceDispatches = (workspaceId) => {
+        const rows = db
+            .prepare(`SELECT *
+         FROM dispatches
+         WHERE workspace_id = ?
+           AND status IN ('queued', 'submitted')
+         ORDER BY sequence ASC, created_at ASC`)
+            .all(workspaceId);
+        return rows.map(toRecord);
+    };
     const listOpenDispatchKinds = () => {
         return db
             .prepare(`SELECT workspace_id, to_agent_id AS worker_id, 'send' AS type
@@ -229,13 +266,16 @@ export const createDispatchLedgerStore = (db) => {
         deleteWorkspaceDispatches,
         findOpenDispatch,
         findOpenDispatchById,
+        claimQueuedDispatch,
+        reparkClaimedDispatch,
         listOpenDispatchKinds,
         listOpenDispatchIdsForRun,
+        listOpenWorkspaceDispatches,
         listOpenWorkflowDispatchesForWorker,
+        listRecentWorkspaceDispatches,
         listWorkflowRunDispatches,
         listWorkspaceDispatches,
         markCancelled,
         markReportedByWorker,
-        markSubmitted,
     };
 };

package/dist/src/server/hive-envelope-escape.d.ts

@@ -0,0 +1,2 @@
+export declare const escapeHiveEnvelopeText: (value: string) => string;
+export declare const escapeHiveEnvelopeAttribute: (value: string) => string;

package/dist/src/server/hive-envelope-escape.js

@@ -0,0 +1,2 @@
+export const escapeHiveEnvelopeText = (value) => value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+export const escapeHiveEnvelopeAttribute = (value) => escapeHiveEnvelopeText(value).replaceAll('"', '&quot;').replaceAll("'", '&#39;');

package/dist/src/server/hive-team-guidance.d.ts

@@ -5,7 +5,7 @@ import { type WorkflowCliPolicy } from './workflow-cli-policy.js';
  * Tail reminder appended to every message that flows INTO the orchestrator
  * (worker reports, worker status updates, user chat input). Re-anchors the
  * role + dispatch syntax after the agent's CLI internally compacts the
- * conversation transcript (`/compact` in CC, auto-summarize in Codex, etc.)
+ * conversation transcript (manual compaction, auto-summarization, etc.)
  * and forgets the original startup instructions.
  *
  * Format choice (XML envelope, position at message tail, action-menu wording)