@tt-a1i/hive 1.7.0 → 2.0.2

package/dist/src/server/team-memory-dream-runner.js

@@ -0,0 +1,178 @@
+import { spawn } from 'node:child_process';
+import { DreamRunAlreadyRunningError } from './team-memory-dream-store.js';
+const DREAM_CLI_TIMEOUT_MS = 120_000;
+export const defaultDreamCliCommand = () => ({
+    args: [],
+    command: 'claude',
+});
+export const dreamCliCommandForLaunchCommand = (command) => {
+    const normalized = command.trim();
+    const executable = normalized.split(/[\\/]/).at(-1)?.toLowerCase() ?? normalized.toLowerCase();
+    if (executable === 'claude' || executable === 'claude.exe') {
+        return { args: ['-p'], command: normalized };
+    }
+    return { args: [], command: normalized };
+};
+const formatMessages = (messages) => {
+    if (messages.length === 0)
+        return 'No new protocol messages.';
+    return messages
+        .map((message) => [
+        `#${message.sequence} ${message.type} worker=${message.workerId}`,
+        message.status ? `status=${message.status}` : null,
+        message.artifacts ? `artifacts=${message.artifacts}` : null,
+        message.text?.trim() || '(empty)',
+    ]
+        .filter((line) => Boolean(line))
+        .join('\n'))
+        .join('\n\n');
+};
+const formatMemories = (memories) => {
+    if (memories.length === 0)
+        return 'No current memory entries.';
+    return memories
+        .map((memory) => [
+        `id=${memory.id} status=${memory.status} kind=${memory.kind} source=${memory.source}`,
+        memory.body,
+        memory.tags.length > 0 ? `tags=${memory.tags.join(', ')}` : null,
+    ]
+        .filter((line) => Boolean(line))
+        .join('\n'))
+        .join('\n\n');
+};
+export const buildDreamPrompt = (input) => [
+    'You are Hive Dream, an offline memory consolidation agent.',
+    'Read only the protocol messages and current Hive memory entries below.',
+    'Return strict JSON only, with shape {"ops":[...]} and no prose.',
+    '',
+    'Allowed ops:',
+    '- {"op":"add","kind":"fact|preference|decision|pitfall|procedure_ref","body":"...","tags":[],"confidence":0.0-1.0,"sources":[{"sequence":123}]}',
+    '- {"op":"rewrite","id":"<memory-id>","body":"...","tags":[]}',
+    '- {"op":"archive","id":"<memory-id>","reason":"..."}',
+    '- {"op":"merge","into":"<memory-id>","from":["<memory-id>"],"body":"..."}',
+    '',
+    'Rules: add at most 10 entries; every body must be 500 characters or fewer; archive never deletes; if nothing is worth remembering, return {"ops":[]}.',
+    'Use protocol evidence only: report text, dispatch status, user input, and artifacts. Do not trust self-praise without a concrete report or failure signal.',
+    'If newer protocol evidence contradicts an active memory entry, add or rewrite the newer durable fact and archive the contradicted old memory with a supersession reason. Do not leave contradictory active entries side by side.',
+    '',
+    `Workspace: ${input.workspaceId}`,
+    '',
+    '## New protocol messages',
+    formatMessages(input.messages),
+    '',
+    '## Current memory entries',
+    formatMemories(input.memories),
+].join('\n');
+const parseJson = (value) => JSON.parse(value);
+const extractDreamOutput = (stdout) => {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        throw new Error('Dream CLI returned empty output');
+    try {
+        return parseJson(trimmed);
+    }
+    catch {
+        const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (fenced?.[1])
+            return parseJson(fenced[1].trim());
+        throw new Error('Dream CLI output did not contain valid JSON');
+    }
+};
+const getOps = (parsed) => {
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('Dream CLI JSON must be an object');
+    }
+    const ops = parsed.ops;
+    if (!Array.isArray(ops))
+        throw new Error('Dream CLI JSON must include ops array');
+    return ops;
+};
+const truncateError = (value) => [...value].slice(0, 1000).join('');
+const runHeadlessCli = async (input) => new Promise((resolve, reject) => {
+    const child = spawn(input.command.command, input.command.args, {
+        cwd: input.cwd,
+        env: { ...process.env, HIVE_DREAM_RUN: '1' },
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let forceKillTimer;
+    const timeout = setTimeout(() => {
+        if (settled)
+            return;
+        settled = true;
+        child.kill('SIGTERM');
+        forceKillTimer = setTimeout(() => child.kill('SIGKILL'), 1000);
+        forceKillTimer.unref?.();
+        reject(new Error('Dream CLI timed out'));
+    }, DREAM_CLI_TIMEOUT_MS);
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    child.on('error', (error) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timeout);
+        reject(error);
+    });
+    child.on('close', (code) => {
+        if (forceKillTimer)
+            clearTimeout(forceKillTimer);
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timeout);
+        if (code === 0) {
+            resolve(stdout);
+            return;
+        }
+        reject(new Error(`Dream CLI exited ${code}: ${truncateError(stderr)}`));
+    });
+    child.stdin.end(input.prompt);
+});
+export const createTeamMemoryDreamRunner = (deps) => {
+    const runningWorkspaceIds = new Set();
+    const run = async (workspaceId, trigger) => {
+        if (runningWorkspaceIds.has(workspaceId))
+            throw new DreamRunAlreadyRunningError(workspaceId);
+        runningWorkspaceIds.add(workspaceId);
+        let runRecord;
+        try {
+            runRecord = deps.dreamStore.createRun({ trigger, workspaceId });
+            const messages = deps.dreamStore.listInputMessages(workspaceId, runRecord.inputSeqFrom, runRecord.inputSeqTo);
+            const memories = deps.memoryStore.listAllEntries(workspaceId);
+            const prompt = buildDreamPrompt({ memories, messages, workspaceId });
+            const stdout = await runHeadlessCli({
+                command: deps.getDreamCliCommand?.(workspaceId) ?? defaultDreamCliCommand(),
+                cwd: deps.getWorkspacePath(workspaceId),
+                prompt,
+            });
+            const ops = getOps(extractDreamOutput(stdout));
+            const completed = deps.dreamStore.applyAndCompleteRun(workspaceId, runRecord.id, ops);
+            deps.scheduleExport(workspaceId);
+            return completed;
+        }
+        catch (error) {
+            if (!runRecord)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            const failed = deps.dreamStore.markFailed(runRecord.id, truncateError(message), runRecord);
+            deps.scheduleExport(workspaceId);
+            return failed;
+        }
+        finally {
+            runningWorkspaceIds.delete(workspaceId);
+        }
+    };
+    return {
+        runManual: (workspaceId) => run(workspaceId, 'manual'),
+        runScheduled: (workspaceId) => run(workspaceId, 'scheduled'),
+    };
+};

package/dist/src/server/team-memory-dream-scheduler.d.ts

@@ -0,0 +1,32 @@
+import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import type { SettingsStore } from './settings-store.js';
+import type { DreamScheduleState } from './team-memory-dream-store.js';
+export declare const DREAM_SCHEDULER_FLOOR_MS: number;
+export declare const DREAM_SCHEDULER_BACKOFF_CAP = 5;
+export declare const DREAM_SCHEDULER_IDLE_DEBOUNCE_MS = 60000;
+export declare const DREAM_SCHEDULER_MIN_MESSAGES = 1;
+export declare const DREAM_SCHEDULER_TICK_INTERVAL_MS = 30000;
+interface WorkspaceSnapshot {
+    agents: AgentSummary[];
+}
+export interface TeamMemoryDreamSchedulerDeps {
+    floorMs?: number;
+    getScheduleState: (workspaceId: string) => DreamScheduleState;
+    getWorkspaceSnapshot: (workspaceId: string) => WorkspaceSnapshot;
+    idleDebounceMs?: number;
+    listWorkspaces: () => WorkspaceSummary[];
+    logError?: (workspaceId: string, error: unknown) => void;
+    minMessages?: number;
+    now?: () => number;
+    runScheduled: (workspaceId: string) => Promise<unknown>;
+    settings: SettingsStore;
+}
+export interface TeamMemoryDreamScheduler {
+    close: () => Promise<void>;
+    start: (input?: {
+        tickIntervalMs?: number;
+    }) => void;
+    tick: (now?: number) => Promise<void>;
+}
+export declare const createTeamMemoryDreamScheduler: (deps: TeamMemoryDreamSchedulerDeps) => TeamMemoryDreamScheduler;
+export {};

package/dist/src/server/team-memory-dream-scheduler.js

@@ -0,0 +1,115 @@
+import { readWorkspaceMemoryDreamEnabled, readWorkspaceMemoryEnabled, workspaceMemoryDreamEnabledKey, workspaceMemoryEnabledKey, } from './team-memory-feature.js';
+export const DREAM_SCHEDULER_FLOOR_MS = 20 * 60 * 1000;
+// The first failure still retries at the base floor (transient hiccups recover fast);
+// each *additional* consecutive scheduled failure doubles the floor (capped), so a window
+// that keeps failing is retried ever more slowly instead of burning the CLI every floor.
+// At 20min × 2^5 the slowest retry is ~10.6h; a success resets the count and the floor.
+export const DREAM_SCHEDULER_BACKOFF_CAP = 5;
+export const DREAM_SCHEDULER_IDLE_DEBOUNCE_MS = 60_000;
+export const DREAM_SCHEDULER_MIN_MESSAGES = 1;
+export const DREAM_SCHEDULER_TICK_INTERVAL_MS = 30_000;
+const hasWorkingAgent = (agents) => agents.some((agent) => agent.status === 'working');
+const isDreamEnabled = (settings, workspaceId) => readWorkspaceMemoryEnabled(settings.getAppState(workspaceMemoryEnabledKey(workspaceId))?.value) &&
+    readWorkspaceMemoryDreamEnabled(settings.getAppState(workspaceMemoryDreamEnabledKey(workspaceId))?.value);
+export const createTeamMemoryDreamScheduler = (deps) => {
+    const floorMs = deps.floorMs ?? DREAM_SCHEDULER_FLOOR_MS;
+    const idleDebounceMs = deps.idleDebounceMs ?? DREAM_SCHEDULER_IDLE_DEBOUNCE_MS;
+    const minMessages = deps.minMessages ?? DREAM_SCHEDULER_MIN_MESSAGES;
+    const now = deps.now ?? (() => Date.now());
+    const logError = deps.logError ??
+        ((workspaceId, error) => {
+            console.error('[hive] memory dream scheduler failed', { workspaceId, error });
+        });
+    let timer;
+    let closed = false;
+    let tickInFlight = false;
+    let tickPromise;
+    const idleSinceByWorkspace = new Map();
+    const clearTimer = () => {
+        if (!timer)
+            return;
+        clearInterval(timer);
+        timer = undefined;
+    };
+    const scheduler = {
+        async close() {
+            closed = true;
+            clearTimer();
+            await tickPromise?.catch((error) => {
+                console.error('[hive] swallowed:memory-dream-scheduler.close', error);
+            });
+        },
+        start({ tickIntervalMs = DREAM_SCHEDULER_TICK_INTERVAL_MS } = {}) {
+            closed = false;
+            clearTimer();
+            timer = setInterval(() => {
+                void scheduler.tick().catch((error) => {
+                    console.error('[hive] swallowed:memory-dream-scheduler.tick', error);
+                });
+            }, tickIntervalMs);
+            timer.unref?.();
+        },
+        async tick(tickNow = now()) {
+            if (closed)
+                return;
+            if (tickInFlight) {
+                await tickPromise;
+                return;
+            }
+            tickInFlight = true;
+            tickPromise = (async () => {
+                const eligibleWorkspaces = [];
+                for (const workspace of deps.listWorkspaces()) {
+                    try {
+                        if (!isDreamEnabled(deps.settings, workspace.id)) {
+                            idleSinceByWorkspace.delete(workspace.id);
+                            continue;
+                        }
+                        if (hasWorkingAgent(deps.getWorkspaceSnapshot(workspace.id).agents)) {
+                            idleSinceByWorkspace.delete(workspace.id);
+                            continue;
+                        }
+                        const previousIdleSince = idleSinceByWorkspace.get(workspace.id);
+                        const idleSince = previousIdleSince === undefined || tickNow < previousIdleSince
+                            ? tickNow
+                            : previousIdleSince;
+                        idleSinceByWorkspace.set(workspace.id, idleSince);
+                        if (tickNow - idleSince < idleDebounceMs)
+                            continue;
+                        const state = deps.getScheduleState(workspace.id);
+                        if (state.hasRunningRun)
+                            continue;
+                        if (state.pendingMessageCount < minMessages)
+                            continue;
+                        const effectiveFloorMs = floorMs *
+                            2 **
+                                Math.min(Math.max(0, state.consecutiveScheduledFailures - 1), DREAM_SCHEDULER_BACKOFF_CAP);
+                        const sinceLastScheduled = state.lastScheduledAt === null ? null : tickNow - state.lastScheduledAt;
+                        if (sinceLastScheduled !== null && sinceLastScheduled < effectiveFloorMs)
+                            continue;
+                        eligibleWorkspaces.push(workspace);
+                    }
+                    catch (error) {
+                        logError(workspace.id, error);
+                    }
+                }
+                await Promise.all(eligibleWorkspaces.map(async (workspace) => {
+                    try {
+                        await deps.runScheduled(workspace.id);
+                    }
+                    catch (error) {
+                        logError(workspace.id, error);
+                    }
+                }));
+            })();
+            try {
+                await tickPromise;
+            }
+            finally {
+                tickPromise = undefined;
+                tickInFlight = false;
+            }
+        },
+    };
+    return scheduler;
+};

package/dist/src/server/team-memory-dream-store.d.ts

@@ -0,0 +1,19 @@
+import type { Database } from 'better-sqlite3';
+export { DreamRunValidationError } from './team-memory-dream-ops.js';
+export { DreamRunNotFoundError, DreamRunRevertDataError, DreamRunRevertStatusError, } from './team-memory-dream-reverter.js';
+export { DREAM_RUNNING_STALE_MS, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
+export type { DreamMessageInput, DreamRunRecord, DreamRunReport, DreamRunRevertBlob, DreamRunStatus, DreamRunTrigger, DreamScheduleState, } from './team-memory-dream-types.js';
+export declare const createTeamMemoryDreamStore: (db: Database) => {
+    revertRun: (workspaceId: string, runId: string) => import("./team-memory-dream-types.js").DreamRunRecord;
+    applyAndCompleteRun: (workspaceId: string, runId: string, rawOps: unknown) => import("./team-memory-dream-types.js").DreamRunRecord;
+    createRun: (input: {
+        trigger: import("./team-memory-dream-types.js").DreamRunTrigger;
+        workspaceId: string;
+    }) => import("./team-memory-dream-types.js").DreamRunRecord;
+    deleteWorkspaceDreamRuns: (workspaceId: string) => void;
+    getScheduleState: (workspaceId: string) => import("./team-memory-dream-types.js").DreamScheduleState;
+    getRun: (runId: string) => import("./team-memory-dream-types.js").DreamRunRecord | undefined;
+    listInputMessages: (workspaceId: string, from: number | null, to: number | null) => import("./team-memory-dream-types.js").DreamMessageInput[];
+    listRuns: (workspaceId: string, limit?: number) => import("./team-memory-dream-types.js").DreamRunRecord[];
+    markFailed: (runId: string, error: string, fallback?: import("./team-memory-dream-types.js").DreamRunRecord) => import("./team-memory-dream-types.js").DreamRunRecord;
+};

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

@@ -0,0 +1,16 @@
+import { createDreamOperationApplier } from './team-memory-dream-applier.js';
+import { createDreamRunReverter } from './team-memory-dream-reverter.js';
+import { createDreamRunStore } from './team-memory-dream-run-store.js';
+export { DreamRunValidationError } from './team-memory-dream-ops.js';
+export { DreamRunNotFoundError, DreamRunRevertDataError, DreamRunRevertStatusError, } from './team-memory-dream-reverter.js';
+export { DREAM_RUNNING_STALE_MS, DreamRunAlreadyRunningError, DreamWorkspaceMissingError, } from './team-memory-dream-run-store.js';
+export const createTeamMemoryDreamStore = (db) => {
+    const runStore = createDreamRunStore(db);
+    const applier = createDreamOperationApplier(db);
+    const reverter = createDreamRunReverter(db);
+    return {
+        ...runStore,
+        ...applier,
+        ...reverter,
+    };
+};

package/dist/src/server/team-memory-dream-types.d.ts

@@ -0,0 +1,104 @@
+import type { MemoryKind } from '../shared/team-memory.js';
+import type { MemorySource, MemorySourceType, MemoryStatus } from './team-memory-store.js';
+export type DreamRunTrigger = 'manual' | 'scheduled';
+export type DreamRunStatus = 'running' | 'completed' | 'failed' | 'reverted';
+export interface DreamRunReport {
+    added: Array<{
+        body: string;
+        id: string;
+        kind: MemoryKind;
+    }>;
+    archived: Array<{
+        id: string;
+        reason: string | null;
+    }>;
+    merged: Array<{
+        from: string[];
+        into: string;
+    }>;
+    rewritten: Array<{
+        id: string;
+    }>;
+}
+export interface MemoryEntryRow {
+    archived_at: number | null;
+    body: string;
+    confidence: number | null;
+    created_at: number;
+    disabled: number;
+    fts_rowid: number;
+    id: string;
+    kind: MemoryKind;
+    last_injected_at: number | null;
+    pinned: number;
+    scope: 'workspace' | 'user';
+    source: MemorySource;
+    status: MemoryStatus;
+    tags: string | null;
+    updated_at: number;
+    workspace_id: string | null;
+}
+export interface MemorySourceRow {
+    actor_agent_id_snapshot: string | null;
+    actor_name_snapshot: string | null;
+    actor_role_snapshot: string | null;
+    created_at: number;
+    excerpt: string | null;
+    id: string;
+    memory_id: string;
+    source_id: string | null;
+    source_sequence: number | null;
+    source_type: MemorySourceType;
+    text_hash: string | null;
+}
+export interface DreamRunRevertBlob {
+    added_entry_ids: string[];
+    prior_entries: Array<{
+        entry: MemoryEntryRow;
+        sources: MemorySourceRow[];
+    }>;
+}
+export interface DreamRunRecord {
+    error: string | null;
+    finishedAt: number | null;
+    id: string;
+    inputSeqFrom: number | null;
+    inputSeqTo: number | null;
+    report: DreamRunReport | null;
+    revertBlob: DreamRunRevertBlob | null;
+    startedAt: number;
+    status: DreamRunStatus;
+    trigger: DreamRunTrigger;
+    workspaceId: string;
+}
+export interface DreamScheduleState {
+    consecutiveScheduledFailures: number;
+    hasRunningRun: boolean;
+    lastScheduledAt: number | null;
+    pendingMessageCount: number;
+}
+export interface DreamMessageInput {
+    artifacts: string | null;
+    createdAt: number;
+    fromAgentId: string | null;
+    sequence: number;
+    status: string | null;
+    text: string | null;
+    toAgentId: string | null;
+    type: string;
+    workerId: string;
+}
+export interface DreamRunRow {
+    error: string | null;
+    finished_at: number | null;
+    id: string;
+    input_seq_from: number | null;
+    input_seq_to: number | null;
+    report: string | null;
+    revert_blob: string | null;
+    started_at: number;
+    status: DreamRunStatus;
+    trigger: DreamRunTrigger;
+    workspace_id: string;
+}
+export declare const toDreamRunRecord: (row: DreamRunRow) => DreamRunRecord;

package/dist/src/server/team-memory-dream-types.js

@@ -0,0 +1,23 @@
+const parseJsonField = (value) => {
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
+export const toDreamRunRecord = (row) => ({
+    error: row.error,
+    finishedAt: row.finished_at,
+    id: row.id,
+    inputSeqFrom: row.input_seq_from,
+    inputSeqTo: row.input_seq_to,
+    report: parseJsonField(row.report),
+    revertBlob: parseJsonField(row.revert_blob),
+    startedAt: row.started_at,
+    status: row.status,
+    trigger: row.trigger,
+    workspaceId: row.workspace_id,
+});

package/dist/src/server/team-memory-export.d.ts

@@ -0,0 +1,22 @@
+import type { DreamRunRecord } from './team-memory-dream-store.js';
+import type { MemoryEntryWithSources } from './team-memory-store.js';
+export declare const MEMORY_FILE_NAME = "memory.md";
+export declare const MEMORY_RELATIVE_PATH = ".hive/memory.md";
+export declare const MEMORY_EXPORT_DEBOUNCE_MS = 2000;
+export declare const MEMORY_EXPORT_DREAM_CHANGELOG_LIMIT = 10;
+export declare const getMemoryFilePath: (workspacePath: string) => string;
+export declare const renderMemoryExport: (entries: MemoryEntryWithSources[], dreamRuns?: DreamRunRecord[]) => string;
+export interface TeamMemoryExportService {
+    cancel: (workspaceId: string) => void;
+    close: () => Promise<void>;
+    flush: (workspaceId: string) => Promise<void>;
+    schedule: (workspaceId: string) => void;
+}
+export declare const createTeamMemoryExportService: ({ debounceMs, getWorkspacePath, listDreamRuns, listEntries, logError, now, }: {
+    debounceMs?: number;
+    getWorkspacePath: (workspaceId: string) => string;
+    listDreamRuns?: (workspaceId: string) => DreamRunRecord[];
+    listEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    logError?: (workspaceId: string, error: unknown) => void;
+    now?: () => number;
+}) => TeamMemoryExportService;