@tt-a1i/hive 1.7.0 → 2.0.2

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

@@ -0,0 +1,153 @@
+import { DREAM_MEMORY_BODY_MAX_CHARS, DREAM_MEMORY_MAX_ADDS_PER_RUN, isMemoryKind, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
+export class DreamRunValidationError extends Error {
+    code = 'dream_validation_failed';
+}
+const asRecord = (value) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new DreamRunValidationError('Dream op must be an object');
+    }
+    return value;
+};
+const requiredString = (record, field) => {
+    const value = record[field];
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new DreamRunValidationError(`Dream op field ${field} must be a non-empty string`);
+    }
+    return value.trim();
+};
+const optionalString = (record, field) => {
+    const value = record[field];
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string') {
+        throw new DreamRunValidationError(`Dream op field ${field} must be a string`);
+    }
+    return value.trim() || null;
+};
+const requiredBody = (record) => {
+    const body = requiredString(record, 'body');
+    if ([...body].length > DREAM_MEMORY_BODY_MAX_CHARS) {
+        throw new DreamRunValidationError(`Dream op body must be ${DREAM_MEMORY_BODY_MAX_CHARS} characters or fewer`);
+    }
+    return body;
+};
+const requiredKind = (record) => {
+    const kind = record.kind;
+    if (!isMemoryKind(kind))
+        throw new DreamRunValidationError('Dream op kind is invalid');
+    return kind;
+};
+const optionalKind = (record) => {
+    const kind = record.kind;
+    if (kind === undefined || kind === null)
+        return undefined;
+    if (!isMemoryKind(kind))
+        throw new DreamRunValidationError('Dream op kind is invalid');
+    return kind;
+};
+const optionalConfidence = (record) => {
+    const value = record.confidence;
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+        throw new DreamRunValidationError('Dream op confidence must be between 0 and 1');
+    }
+    return value;
+};
+const optionalTags = (record) => {
+    const value = record.tags;
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new DreamRunValidationError('Dream op tags must be an array');
+    if (value.length > MEMORY_TAG_MAX_COUNT) {
+        throw new DreamRunValidationError(`Dream op tags can include at most ${MEMORY_TAG_MAX_COUNT}`);
+    }
+    return value.map((tag) => {
+        if (typeof tag !== 'string' || !tag.trim()) {
+            throw new DreamRunValidationError('Dream op tags must be non-empty strings');
+        }
+        const trimmed = tag.trim();
+        if ([...trimmed].length > MEMORY_TAG_MAX_CHARS) {
+            throw new DreamRunValidationError(`Dream op tags must be ${MEMORY_TAG_MAX_CHARS} characters or fewer`);
+        }
+        return trimmed;
+    });
+};
+const optionalSourceSequences = (record) => {
+    const value = record.sources;
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new DreamRunValidationError('Dream op sources must be an array');
+    return value.map((source) => {
+        const sourceRecord = asRecord(source);
+        const sequence = sourceRecord.sequence;
+        if (!Number.isInteger(sequence) || sequence <= 0) {
+            throw new DreamRunValidationError('Dream op source sequence must be a positive integer');
+        }
+        return sequence;
+    });
+};
+export const parseDreamOperations = (rawOps) => {
+    if (!Array.isArray(rawOps))
+        throw new DreamRunValidationError('Dream output ops must be an array');
+    const operations = rawOps.map((rawOp) => {
+        const record = asRecord(rawOp);
+        switch (record.op) {
+            case 'add':
+                return {
+                    body: requiredBody(record),
+                    confidence: optionalConfidence(record) ?? 0.5,
+                    kind: requiredKind(record),
+                    op: 'add',
+                    sources: optionalSourceSequences(record),
+                    tags: optionalTags(record) ?? [],
+                };
+            case 'archive':
+                return {
+                    id: requiredString(record, 'id'),
+                    op: 'archive',
+                    reason: optionalString(record, 'reason'),
+                };
+            case 'merge': {
+                const from = record.from;
+                if (!Array.isArray(from) || from.length === 0) {
+                    throw new DreamRunValidationError('Dream merge op must include from ids');
+                }
+                return {
+                    body: requiredBody(record),
+                    confidence: optionalConfidence(record),
+                    from: from.map((id) => {
+                        if (typeof id !== 'string' || !id.trim()) {
+                            throw new DreamRunValidationError('Dream merge from ids must be non-empty strings');
+                        }
+                        return id.trim();
+                    }),
+                    into: requiredString(record, 'into'),
+                    kind: optionalKind(record),
+                    op: 'merge',
+                    tags: optionalTags(record),
+                };
+            }
+            case 'rewrite':
+                return {
+                    body: requiredBody(record),
+                    confidence: optionalConfidence(record),
+                    id: requiredString(record, 'id'),
+                    kind: optionalKind(record),
+                    op: 'rewrite',
+                    tags: optionalTags(record),
+                };
+            default:
+                throw new DreamRunValidationError('Unsupported dream op');
+        }
+    });
+    const addCount = operations.filter((op) => op.op === 'add').length;
+    if (addCount > DREAM_MEMORY_MAX_ADDS_PER_RUN) {
+        throw new DreamRunValidationError(`Dream run can add at most ${DREAM_MEMORY_MAX_ADDS_PER_RUN} memories`);
+    }
+    return operations;
+};

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

@@ -0,0 +1,22 @@
+import type { Database } from 'better-sqlite3';
+import { type DreamRunRecord, type DreamRunRow } from './team-memory-dream-types.js';
+export declare class DreamRunNotFoundError extends Error {
+    readonly runId: string;
+    readonly workspaceId: string;
+    constructor(workspaceId: string, runId: string);
+}
+export declare class DreamRunRevertDataError extends Error {
+    readonly runId: string;
+    readonly workspaceId: string;
+    constructor(workspaceId: string, runId: string, message: string);
+}
+export declare class DreamRunRevertStatusError extends Error {
+    readonly actualStatus: DreamRunRow['status'];
+    readonly expectedStatus = "completed";
+    readonly runId: string;
+    readonly workspaceId: string;
+    constructor(workspaceId: string, runId: string, actualStatus: DreamRunRow['status']);
+}
+export declare const createDreamRunReverter: (db: Database) => {
+    revertRun: (workspaceId: string, runId: string) => DreamRunRecord;
+};

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 {};