hivehq 2.0.0

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

@@ -0,0 +1,221 @@
+import { isMemoryKind } from '../shared/team-memory.js';
+import { toDreamRunRecord, } from './team-memory-dream-types.js';
+const MEMORY_STATUSES = new Set(['active', 'candidate', 'archived', 'rejected']);
+const MEMORY_SOURCES = new Set(['manual', 'dream']);
+const MEMORY_SOURCE_TYPES = new Set(['manual', 'message', 'dispatch', 'report', 'dream']);
+const isObject = (value) => typeof value === 'object' && value !== null;
+const hasValidMemoryEntryShape = (value) => {
+    if (!isObject(value))
+        return false;
+    return ((typeof value.archived_at === 'number' || value.archived_at === null) &&
+        typeof value.id === 'string' &&
+        typeof value.body === 'string' &&
+        (typeof value.confidence === 'number' || value.confidence === null) &&
+        typeof value.created_at === 'number' &&
+        (value.disabled === 0 || value.disabled === 1) &&
+        typeof value.fts_rowid === 'number' &&
+        isMemoryKind(value.kind) &&
+        (typeof value.last_injected_at === 'number' || value.last_injected_at === null) &&
+        (value.pinned === 0 || value.pinned === 1) &&
+        value.scope === 'workspace' &&
+        typeof value.source === 'string' &&
+        MEMORY_SOURCES.has(value.source) &&
+        typeof value.status === 'string' &&
+        MEMORY_STATUSES.has(value.status) &&
+        (typeof value.tags === 'string' || value.tags === null) &&
+        typeof value.updated_at === 'number' &&
+        (typeof value.workspace_id === 'string' || value.workspace_id === null));
+};
+const hasValidMemorySourceShape = (value) => {
+    if (!isObject(value))
+        return false;
+    return ((typeof value.actor_agent_id_snapshot === 'string' || value.actor_agent_id_snapshot === null) &&
+        (typeof value.actor_name_snapshot === 'string' || value.actor_name_snapshot === null) &&
+        (typeof value.actor_role_snapshot === 'string' || value.actor_role_snapshot === null) &&
+        typeof value.id === 'string' &&
+        typeof value.memory_id === 'string' &&
+        (typeof value.excerpt === 'string' || value.excerpt === null) &&
+        (typeof value.source_id === 'string' || value.source_id === null) &&
+        (typeof value.source_sequence === 'number' || value.source_sequence === null) &&
+        typeof value.source_type === 'string' &&
+        MEMORY_SOURCE_TYPES.has(value.source_type) &&
+        (typeof value.text_hash === 'string' || value.text_hash === null) &&
+        typeof value.created_at === 'number');
+};
+const hasValidRevertBlobShape = (value) => {
+    if (!isObject(value))
+        return false;
+    if (!Array.isArray(value.added_entry_ids) ||
+        !value.added_entry_ids.every((id) => typeof id === 'string')) {
+        return false;
+    }
+    if (!Array.isArray(value.prior_entries))
+        return false;
+    return value.prior_entries.every((prior) => {
+        if (!isObject(prior))
+            return false;
+        if (!hasValidMemoryEntryShape(prior.entry))
+            return false;
+        return Array.isArray(prior.sources) && prior.sources.every(hasValidMemorySourceShape);
+    });
+};
+export class DreamRunNotFoundError extends Error {
+    runId;
+    workspaceId;
+    constructor(workspaceId, runId) {
+        super(`Dream run not found: ${runId}`);
+        this.name = 'DreamRunNotFoundError';
+        this.workspaceId = workspaceId;
+        this.runId = runId;
+    }
+}
+export class DreamRunRevertDataError extends Error {
+    runId;
+    workspaceId;
+    constructor(workspaceId, runId, message) {
+        super(message);
+        this.name = 'DreamRunRevertDataError';
+        this.workspaceId = workspaceId;
+        this.runId = runId;
+    }
+}
+export class DreamRunRevertStatusError extends Error {
+    actualStatus;
+    expectedStatus = 'completed';
+    runId;
+    workspaceId;
+    constructor(workspaceId, runId, actualStatus) {
+        super(`Dream run has status ${actualStatus}; expected completed`);
+        this.name = 'DreamRunRevertStatusError';
+        this.workspaceId = workspaceId;
+        this.runId = runId;
+        this.actualStatus = actualStatus;
+    }
+}
+export const createDreamRunReverter = (db) => {
+    const getRunRow = (workspaceId, runId) => db
+        .prepare(`SELECT *
+         FROM dream_runs
+         WHERE id = ?
+           AND workspace_id = ?
+         LIMIT 1`)
+        .get(runId, workspaceId);
+    const requireCompletedRun = (workspaceId, runId) => {
+        const row = getRunRow(workspaceId, runId);
+        if (!row)
+            throw new DreamRunNotFoundError(workspaceId, runId);
+        if (row.status !== 'completed') {
+            throw new DreamRunRevertStatusError(workspaceId, runId, row.status);
+        }
+        return row;
+    };
+    const assertPriorEntry = (workspaceId, runId, entry) => {
+        if (entry.scope !== 'workspace' || entry.workspace_id !== workspaceId) {
+            throw new DreamRunRevertDataError(workspaceId, runId, 'Dream revert entry is out of scope');
+        }
+    };
+    const restoreSource = (workspaceId, runId, memoryId, source) => {
+        if (source.memory_id !== memoryId) {
+            throw new DreamRunRevertDataError(workspaceId, runId, 'Dream revert source is out of scope');
+        }
+        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(source.id, source.memory_id, source.source_type, source.source_id, source.source_sequence, source.excerpt, source.text_hash, source.actor_agent_id_snapshot, source.actor_name_snapshot, source.actor_role_snapshot, source.created_at);
+    };
+    const restorePriorEntry = (workspaceId, runId, prior) => {
+        assertPriorEntry(workspaceId, runId, prior.entry);
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET workspace_id = ?,
+             scope = ?,
+             fts_rowid = ?,
+             kind = ?,
+             body = ?,
+             tags = ?,
+             status = ?,
+             source = ?,
+             confidence = ?,
+             pinned = ?,
+             disabled = ?,
+             created_at = ?,
+             updated_at = ?,
+             archived_at = ?,
+             last_injected_at = ?
+         WHERE id = ?
+           AND workspace_id = ?
+           AND scope = 'workspace'`)
+            .run(prior.entry.workspace_id, prior.entry.scope, prior.entry.fts_rowid, prior.entry.kind, prior.entry.body, prior.entry.tags, prior.entry.status, prior.entry.source, prior.entry.confidence, prior.entry.pinned, prior.entry.disabled, prior.entry.created_at, prior.entry.updated_at, prior.entry.archived_at, prior.entry.last_injected_at, prior.entry.id, workspaceId);
+        if (result.changes === 0) {
+            throw new DreamRunRevertDataError(workspaceId, runId, 'Dream revert prior entry is missing');
+        }
+        db.prepare('DELETE FROM memory_sources WHERE memory_id = ?').run(prior.entry.id);
+        for (const source of prior.sources)
+            restoreSource(workspaceId, runId, prior.entry.id, source);
+    };
+    const archiveAddedEntry = (workspaceId, runId, memoryId, now) => {
+        const result = db
+            .prepare(`UPDATE memory_entries
+         SET status = 'archived',
+             archived_at = COALESCE(archived_at, ?),
+             updated_at = ?
+         WHERE id = ?
+           AND workspace_id = ?
+           AND scope = 'workspace'
+           AND source = 'dream'`)
+            .run(now, now, memoryId, workspaceId);
+        if (result.changes === 0) {
+            throw new DreamRunRevertDataError(workspaceId, runId, 'Dream added entry is missing');
+        }
+    };
+    const parseCompletedRun = (workspaceId, runId, row) => {
+        try {
+            const run = toDreamRunRecord(row);
+            if (!run.revertBlob || !hasValidRevertBlobShape(run.revertBlob)) {
+                throw new DreamRunRevertDataError(workspaceId, runId, 'Dream run has no revert data');
+            }
+            return run;
+        }
+        catch (error) {
+            if (error instanceof DreamRunRevertDataError)
+                throw error;
+            throw new DreamRunRevertDataError(workspaceId, runId, 'Dream run revert data is invalid');
+        }
+    };
+    const revertRunTransaction = db.transaction((workspaceId, runId) => {
+        const run = parseCompletedRun(workspaceId, runId, requireCompletedRun(workspaceId, runId));
+        const now = Date.now();
+        for (const prior of run.revertBlob.prior_entries) {
+            restorePriorEntry(workspaceId, runId, prior);
+        }
+        for (const memoryId of run.revertBlob.added_entry_ids) {
+            archiveAddedEntry(workspaceId, runId, memoryId, now);
+        }
+        const result = db
+            .prepare(`UPDATE dream_runs
+           SET status = 'reverted',
+               finished_at = ?
+           WHERE id = ?
+             AND workspace_id = ?
+             AND status = 'completed'`)
+            .run(now, runId, workspaceId);
+        if (result.changes === 0) {
+            throw new DreamRunRevertStatusError(workspaceId, runId, run.status);
+        }
+        const reverted = getRunRow(workspaceId, runId);
+        if (!reverted)
+            throw new DreamRunNotFoundError(workspaceId, runId);
+        return toDreamRunRecord(reverted);
+    });
+    const revertRun = (workspaceId, runId) => revertRunTransaction(workspaceId, runId);
+    return { revertRun };
+};

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

@@ -0,0 +1,23 @@
+import type { Database } from 'better-sqlite3';
+import { type DreamMessageInput, type DreamRunRecord, type DreamRunTrigger, type DreamScheduleState } from './team-memory-dream-types.js';
+export declare const DREAM_RUNNING_STALE_MS: number;
+export declare class DreamRunAlreadyRunningError extends Error {
+    readonly workspaceId: string;
+    constructor(workspaceId: string);
+}
+export declare class DreamWorkspaceMissingError extends Error {
+    readonly workspaceId: string;
+    constructor(workspaceId: string);
+}
+export declare const createDreamRunStore: (db: Database) => {
+    createRun: (input: {
+        trigger: DreamRunTrigger;
+        workspaceId: string;
+    }) => DreamRunRecord;
+    deleteWorkspaceDreamRuns: (workspaceId: string) => void;
+    getScheduleState: (workspaceId: string) => DreamScheduleState;
+    getRun: (runId: string) => DreamRunRecord | undefined;
+    listInputMessages: (workspaceId: string, from: number | null, to: number | null) => DreamMessageInput[];
+    listRuns: (workspaceId: string, limit?: number) => DreamRunRecord[];
+    markFailed: (runId: string, error: string, fallback?: DreamRunRecord) => DreamRunRecord;
+};

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

@@ -0,0 +1,211 @@
+import { randomUUID } from 'node:crypto';
+import { toDreamRunRecord, } from './team-memory-dream-types.js';
+const DREAM_INPUT_MESSAGE_TYPES = "'user_input', 'send', 'report'";
+export const DREAM_RUNNING_STALE_MS = 10 * 60 * 1000;
+const DREAM_STALE_ERROR = 'Dream run exceeded the stale running window';
+export class DreamRunAlreadyRunningError extends Error {
+    workspaceId;
+    constructor(workspaceId) {
+        super(`Dream run already running for workspace: ${workspaceId}`);
+        this.name = 'DreamRunAlreadyRunningError';
+        this.workspaceId = workspaceId;
+    }
+}
+export class DreamWorkspaceMissingError extends Error {
+    workspaceId;
+    constructor(workspaceId) {
+        super(`Dream workspace not found: ${workspaceId}`);
+        this.name = 'DreamWorkspaceMissingError';
+        this.workspaceId = workspaceId;
+    }
+}
+export const createDreamRunStore = (db) => {
+    const requireWorkspace = (workspaceId) => {
+        const row = db.prepare('SELECT id FROM workspaces WHERE id = ? LIMIT 1').get(workspaceId);
+        if (!row)
+            throw new DreamWorkspaceMissingError(workspaceId);
+    };
+    const markStaleRunningRuns = (workspaceId) => {
+        const now = Date.now();
+        db.prepare(`UPDATE dream_runs
+       SET status = 'failed',
+           finished_at = COALESCE(finished_at, ?),
+           error = COALESCE(error, ?)
+       WHERE workspace_id = ?
+         AND status = 'running'
+         AND started_at < ?`).run(now, DREAM_STALE_ERROR, workspaceId, now - DREAM_RUNNING_STALE_MS);
+    };
+    const hasRunningRun = (workspaceId) => db
+        .prepare(`SELECT COUNT(*) AS count
+           FROM dream_runs
+           WHERE workspace_id = ?
+             AND status = 'running'`)
+        .get(workspaceId).count > 0;
+    const getRun = (runId) => {
+        const row = db.prepare('SELECT * FROM dream_runs WHERE id = ? LIMIT 1').get(runId);
+        if (row?.status === 'running') {
+            markStaleRunningRuns(row.workspace_id);
+            const refreshed = db.prepare('SELECT * FROM dream_runs WHERE id = ? LIMIT 1').get(runId);
+            return refreshed ? toDreamRunRecord(refreshed) : undefined;
+        }
+        return row ? toDreamRunRecord(row) : undefined;
+    };
+    const listRuns = (workspaceId, limit = 20) => {
+        markStaleRunningRuns(workspaceId);
+        return db
+            .prepare(`SELECT
+           id,
+           workspace_id,
+           trigger,
+           status,
+           started_at,
+           finished_at,
+           input_seq_from,
+           input_seq_to,
+           report,
+           NULL AS revert_blob,
+           error
+         FROM dream_runs
+         WHERE workspace_id = ?
+         ORDER BY started_at DESC, id DESC
+         LIMIT ?`)
+            .all(workspaceId, limit).map(toDreamRunRecord);
+    };
+    const requireRun = (runId) => {
+        const run = getRun(runId);
+        if (!run)
+            throw new Error(`Dream run not found: ${runId}`);
+        return run;
+    };
+    // Manual and scheduled runs resume from the last *successfully consumed* window
+    // (completed or reverted). A failed run does not advance this watermark, so its window
+    // is retried on the next run rather than silently skipped.
+    const latestConsumedSeq = (workspaceId) => db
+        .prepare(`SELECT MAX(input_seq_to) AS last
+           FROM dream_runs
+           WHERE workspace_id = ?
+             AND status IN ('completed', 'reverted')`)
+        .get(workspaceId).last;
+    const inputWindow = (workspaceId) => {
+        const lastSeq = latestConsumedSeq(workspaceId) ?? 0;
+        return db
+            .prepare(`SELECT MIN(sequence) AS seq_from, MAX(sequence) AS seq_to
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence > ?
+           AND type IN (${DREAM_INPUT_MESSAGE_TYPES})`)
+            .get(workspaceId, lastSeq);
+    };
+    const getScheduleState = (workspaceId) => {
+        markStaleRunningRuns(workspaceId);
+        const lastSeq = latestConsumedSeq(workspaceId) ?? 0;
+        // Scheduled failures after the most recent success mark how many times the current
+        // (un-advanced) window has been retried — used to back the scheduler off.
+        const lastSuccessAt = db
+            .prepare(`SELECT MAX(started_at) AS at
+             FROM dream_runs
+             WHERE workspace_id = ?
+               AND status IN ('completed', 'reverted')`)
+            .get(workspaceId).at ?? 0;
+        const row = db
+            .prepare(`SELECT
+           COALESCE(SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END), 0) AS running_count,
+           COALESCE(
+             SUM(
+               CASE
+                 WHEN trigger = 'scheduled' AND status = 'failed' AND started_at > ?
+                 THEN 1 ELSE 0
+               END
+             ),
+             0
+           ) AS consecutive_scheduled_failures,
+           MAX(CASE WHEN trigger = 'scheduled' THEN started_at ELSE NULL END) AS last_scheduled_at,
+           (
+             SELECT COUNT(*)
+             FROM messages
+             WHERE workspace_id = ?
+               AND sequence > ?
+               AND type IN (${DREAM_INPUT_MESSAGE_TYPES})
+           ) AS pending_message_count
+         FROM dream_runs
+         WHERE workspace_id = ?`)
+            .get(lastSuccessAt, workspaceId, lastSeq, workspaceId);
+        return {
+            consecutiveScheduledFailures: row.consecutive_scheduled_failures,
+            hasRunningRun: row.running_count > 0,
+            lastScheduledAt: row.last_scheduled_at,
+            pendingMessageCount: row.pending_message_count,
+        };
+    };
+    const createRun = (input) => {
+        requireWorkspace(input.workspaceId);
+        markStaleRunningRuns(input.workspaceId);
+        if (hasRunningRun(input.workspaceId))
+            throw new DreamRunAlreadyRunningError(input.workspaceId);
+        const id = randomUUID();
+        const now = Date.now();
+        const window = inputWindow(input.workspaceId);
+        db.prepare(`INSERT INTO dream_runs (
+        id,
+        workspace_id,
+        trigger,
+        status,
+        started_at,
+        finished_at,
+        input_seq_from,
+        input_seq_to,
+        report,
+        revert_blob,
+        error
+      ) VALUES (?, ?, ?, 'running', ?, NULL, ?, ?, NULL, NULL, NULL)`).run(id, input.workspaceId, input.trigger, now, window.seq_from, window.seq_to);
+        return requireRun(id);
+    };
+    const markFailed = (runId, error, fallback) => {
+        const finishedAt = Date.now();
+        db.prepare(`UPDATE dream_runs
+       SET status = 'failed',
+           finished_at = ?,
+           error = ?
+       WHERE id = ?
+         AND status = 'running'`).run(finishedAt, error, runId);
+        const run = getRun(runId);
+        if (run)
+            return run;
+        if (fallback)
+            return { ...fallback, error, finishedAt, status: 'failed' };
+        throw new Error(`Dream run not found: ${runId}`);
+    };
+    const listInputMessages = (workspaceId, from, to) => {
+        if (from === null || to === null)
+            return [];
+        return db
+            .prepare(`SELECT
+           sequence,
+           worker_id AS workerId,
+           type,
+           from_agent_id AS fromAgentId,
+           to_agent_id AS toAgentId,
+           text,
+           status,
+           artifacts,
+           created_at AS createdAt
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence BETWEEN ? AND ?
+           AND type IN (${DREAM_INPUT_MESSAGE_TYPES})
+         ORDER BY sequence ASC`)
+            .all(workspaceId, from, to);
+    };
+    const deleteWorkspaceDreamRuns = (workspaceId) => {
+        db.prepare('DELETE FROM dream_runs WHERE workspace_id = ?').run(workspaceId);
+    };
+    return {
+        createRun,
+        deleteWorkspaceDreamRuns,
+        getScheduleState,
+        getRun,
+        listInputMessages,
+        listRuns,
+        markFailed,
+    };
+};

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

@@ -0,0 +1,37 @@
+import type { DreamMessageInput, DreamRunRecord, DreamRunTrigger } from './team-memory-dream-store.js';
+import type { MemoryEntryWithSources } from './team-memory-store.js';
+interface DreamStorePort {
+    applyAndCompleteRun: (workspaceId: string, runId: string, rawOps: unknown) => DreamRunRecord;
+    createRun: (input: {
+        trigger: DreamRunTrigger;
+        workspaceId: string;
+    }) => DreamRunRecord;
+    listInputMessages: (workspaceId: string, from: number | null, to: number | null) => DreamMessageInput[];
+    markFailed: (runId: string, error: string, fallback?: DreamRunRecord | undefined) => DreamRunRecord;
+}
+interface MemoryStorePort {
+    listAllEntries: (workspaceId: string) => MemoryEntryWithSources[];
+}
+interface DreamCliCommand {
+    args: string[];
+    command: string;
+}
+export interface TeamMemoryDreamRunner {
+    runManual: (workspaceId: string) => Promise<DreamRunRecord>;
+    runScheduled: (workspaceId: string) => Promise<DreamRunRecord>;
+}
+export declare const defaultDreamCliCommand: () => DreamCliCommand;
+export declare const dreamCliCommandForLaunchCommand: (command: string) => DreamCliCommand;
+export declare const buildDreamPrompt: (input: {
+    memories: MemoryEntryWithSources[];
+    messages: DreamMessageInput[];
+    workspaceId: string;
+}) => string;
+export declare const createTeamMemoryDreamRunner: (deps: {
+    dreamStore: DreamStorePort;
+    getDreamCliCommand?: (workspaceId: string) => DreamCliCommand;
+    getWorkspacePath: (workspaceId: string) => string;
+    memoryStore: MemoryStorePort;
+    scheduleExport: (workspaceId: string) => void;
+}) => TeamMemoryDreamRunner;
+export {};

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'),
+    };
+};