hivehq 2.0.0

package/dist/src/server/team-memory-digest.js

@@ -0,0 +1,200 @@
+import { readWorkspaceMemoryEnabled, workspaceMemoryEnabledKey } from './team-memory-feature.js';
+export const STARTUP_MEMORY_BUDGET_CHARS = 1200;
+export const RECOVERY_MEMORY_BUDGET_CHARS = 800;
+export const DISPATCH_MEMORY_BUDGET_CHARS = 1500;
+export const MEMORY_DIGEST_ENTRY_LIMIT = 20;
+export const DISPATCH_MEMORY_ENTRY_LIMIT = 5;
+export const DISPATCH_MEMORY_CANDIDATE_LIMIT = 20;
+export const DISPATCH_MEMORY_MIN_CONFIDENCE = 0.5;
+export const DISPATCH_MEMORY_RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
+const charLength = (value) => [...value].length;
+const truncateChars = (value, maxChars) => {
+    if (charLength(value) <= maxChars)
+        return value;
+    if (maxChars <= 3)
+        return '.'.repeat(Math.max(0, maxChars));
+    return `${[...value].slice(0, maxChars - 3).join('')}...`;
+};
+const escapeMemoryText = (value) => value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const formatEntryLine = (entry) => {
+    const labels = [entry.kind];
+    if (entry.pinned)
+        labels.push('pinned');
+    if (entry.source === 'dream')
+        labels.push('dream');
+    const source = entry.sources[0];
+    if (source?.actorNameSnapshot)
+        labels.push(`from: ${escapeMemoryText(source.actorNameSnapshot)}`);
+    if (entry.tags.length > 0) {
+        labels.push(`tags: ${entry.tags.map(escapeMemoryText).join(', ')}`);
+    }
+    return `- [${labels.join(', ')}] ${escapeMemoryText(entry.body)}`;
+};
+const appendWithinBudget = (lines, line, budget, tail) => {
+    const candidate = [...lines, line, tail].join('\n');
+    if (charLength(candidate) <= budget)
+        return line;
+    const base = [...lines, tail].join('\n');
+    const remaining = budget - charLength(base) - 1;
+    if (remaining < 24)
+        return null;
+    const truncated = truncateChars(line, remaining);
+    return charLength([...lines, truncated, tail].join('\n')) <= budget ? truncated : null;
+};
+const appendSection = (lines, title, entries, includedIds, budget, tail) => {
+    let titleAdded = false;
+    for (const entry of entries) {
+        const sectionLines = titleAdded ? lines : [...lines, title];
+        const line = appendWithinBudget(sectionLines, formatEntryLine(entry), budget, tail);
+        if (!line)
+            break;
+        if (!titleAdded) {
+            lines.push(title);
+            titleAdded = true;
+        }
+        lines.push(line);
+        includedIds.push(entry.id);
+    }
+};
+export const formatMemoryDigestBlock = ({ budget, contextType, entries, }) => {
+    const activeEntries = entries.filter((entry) => entry.status === 'active' && !entry.disabled);
+    if (activeEntries.length === 0)
+        return null;
+    const tail = '</hive-memory>';
+    const lines = [
+        `<hive-memory context="${contextType}">`,
+        'Workspace memory that may be relevant. Verify before relying on it.',
+    ];
+    const includedIds = [];
+    const pinned = activeEntries.filter((entry) => entry.pinned);
+    const digest = activeEntries.filter((entry) => !entry.pinned);
+    appendSection(lines, 'Pinned:', pinned, includedIds, budget, tail);
+    appendSection(lines, 'Digest:', digest, includedIds, budget, tail);
+    if (includedIds.length === 0)
+        return null;
+    lines.push(tail);
+    return {
+        memoryIds: includedIds,
+        text: lines.join('\n'),
+    };
+};
+const confidenceForDispatch = (entry) => entry.confidence ?? (entry.source === 'manual' ? 1 : 0);
+// pinned = the operator's explicit "always surface this" signal: it ranks ahead of
+// everything and skips recency decay, so a deliberately pinned fact never sinks out of
+// the dispatch budget just because it's old or low-confidence.
+const dispatchRank = (entry, newestUpdatedAt) => ({
+    adjustedScore: entry.score +
+        (entry.pinned
+            ? 0
+            : Math.max(0, newestUpdatedAt - entry.updatedAt) / DISPATCH_MEMORY_RECENCY_DECAY_MS),
+    confidence: confidenceForDispatch(entry),
+    pinnedRank: entry.pinned ? 0 : 1,
+    sourceRank: entry.source === 'manual' ? 0 : 1,
+});
+const sortDispatchEntries = (entries) => {
+    const newestUpdatedAt = Math.max(...entries.map((entry) => entry.updatedAt), 0);
+    return [...entries].sort((left, right) => {
+        const leftRank = dispatchRank(left, newestUpdatedAt);
+        const rightRank = dispatchRank(right, newestUpdatedAt);
+        return (leftRank.pinnedRank - rightRank.pinnedRank ||
+            leftRank.sourceRank - rightRank.sourceRank ||
+            rightRank.confidence - leftRank.confidence ||
+            leftRank.adjustedScore - rightRank.adjustedScore ||
+            right.updatedAt - left.updatedAt ||
+            right.createdAt - left.createdAt ||
+            left.id.localeCompare(right.id));
+    });
+};
+const toDispatchSearchTerms = (value) => value
+    .replace(/[^\p{L}\p{N}_-]+/gu, ' ')
+    .trim()
+    .split(/\s+/)
+    .filter((term) => [...term].length >= 2);
+const unique = (values) => {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const normalized = value.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+};
+const buildDispatchQueries = (text, maxTerms) => unique([truncateChars(text, 500), ...toDispatchSearchTerms(text).slice(0, maxTerms)]);
+const mergeSearchResults = (results) => {
+    const byId = new Map();
+    for (const result of results) {
+        const previous = byId.get(result.id);
+        if (!previous || result.score < previous.score)
+            byId.set(result.id, result);
+    }
+    return [...byId.values()];
+};
+export const formatDispatchMemoryBlock = ({ entries, }) => {
+    const activeEntries = sortDispatchEntries(entries.filter((entry) => entry.status === 'active' &&
+        !entry.disabled &&
+        (entry.pinned || confidenceForDispatch(entry) >= DISPATCH_MEMORY_MIN_CONFIDENCE))).slice(0, DISPATCH_MEMORY_ENTRY_LIMIT);
+    if (activeEntries.length === 0)
+        return null;
+    const tail = '</hive-memory>';
+    const lines = [
+        '<hive-memory context="dispatch">',
+        'Team memory that may be relevant (workspace knowledge, verify before relying on it):',
+    ];
+    const includedIds = [];
+    for (const entry of activeEntries) {
+        const line = appendWithinBudget(lines, formatEntryLine(entry), DISPATCH_MEMORY_BUDGET_CHARS, tail);
+        if (!line)
+            break;
+        lines.push(line);
+        includedIds.push(entry.id);
+    }
+    if (includedIds.length === 0)
+        return null;
+    lines.push(tail);
+    return {
+        memoryIds: includedIds,
+        text: lines.join('\n'),
+    };
+};
+export const createWorkspaceMemoryDigestProvider = ({ memoryStore, settings, }) => {
+    const enabledFor = (workspaceId) => readWorkspaceMemoryEnabled(settings.getAppState(workspaceMemoryEnabledKey(workspaceId))?.value ?? null);
+    return {
+        buildDigest({ contextType, workspaceId }) {
+            if (!enabledFor(workspaceId))
+                return null;
+            const entries = memoryStore.listDigestEntries(workspaceId, {
+                limit: MEMORY_DIGEST_ENTRY_LIMIT,
+            });
+            return formatMemoryDigestBlock({
+                budget: contextType === 'startup' ? STARTUP_MEMORY_BUDGET_CHARS : RECOVERY_MEMORY_BUDGET_CHARS,
+                contextType,
+                entries,
+            });
+        },
+        buildDispatchDigest({ taskText, workerDescription, workspaceId }) {
+            if (!enabledFor(workspaceId) || !memoryStore.searchEntries)
+                return null;
+            const search = (queries) => mergeSearchResults(queries.flatMap((query) => memoryStore.searchEntries?.(workspaceId, query, {
+                limit: DISPATCH_MEMORY_CANDIDATE_LIMIT,
+                statuses: ['active'],
+            }) ?? []));
+            const taskEntries = search(buildDispatchQueries(taskText, 8));
+            if (taskEntries.length === 0)
+                return null;
+            const roleMatches = new Map(search(buildDispatchQueries(workerDescription, 6)).map((entry) => [entry.id, entry]));
+            const entries = taskEntries.map((entry) => {
+                const roleMatch = roleMatches.get(entry.id);
+                if (!roleMatch)
+                    return entry;
+                return {
+                    ...entry,
+                    score: Math.min(entry.score, roleMatch.score),
+                };
+            });
+            return formatDispatchMemoryBlock({ entries });
+        },
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { Database } from 'better-sqlite3';
+import { type DreamRunRecord } from './team-memory-dream-types.js';
+export declare const createDreamOperationApplier: (db: Database) => {
+    applyAndCompleteRun: (workspaceId: string, runId: string, rawOps: unknown) => DreamRunRecord;
+};

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

@@ -0,0 +1,234 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { DreamRunValidationError, parseDreamOperations, } from './team-memory-dream-ops.js';
+import { toDreamRunRecord, } from './team-memory-dream-types.js';
+const hashText = (text) => createHash('sha256').update(text).digest('hex');
+const DREAM_SOURCE_MESSAGE_TYPES = "'user_input', 'send', 'report'";
+const excerptFor = (text) => (text ? [...text].slice(0, 500).join('') : null);
+const parseTags = (tags) => {
+    if (!tags)
+        return [];
+    const parsed = JSON.parse(tags);
+    return Array.isArray(parsed) ? parsed.filter((tag) => typeof tag === 'string') : [];
+};
+export const createDreamOperationApplier = (db) => {
+    const requireWorkspace = (workspaceId) => {
+        const row = db.prepare('SELECT id FROM workspaces WHERE id = ? LIMIT 1').get(workspaceId);
+        if (!row)
+            throw new DreamRunValidationError('Dream workspace no longer exists');
+    };
+    const requireRunningRunRow = (workspaceId, runId) => {
+        const row = db
+            .prepare(`SELECT *
+         FROM dream_runs
+         WHERE id = ?
+           AND workspace_id = ?
+           AND status = 'running'
+         LIMIT 1`)
+            .get(runId, workspaceId);
+        if (!row)
+            throw new DreamRunValidationError('Dream run is no longer running');
+        return row;
+    };
+    const getMemoryRow = (workspaceId, memoryId) => db
+        .prepare(`SELECT *
+         FROM memory_entries
+         WHERE id = ?
+           AND scope = 'workspace'
+           AND workspace_id = ?
+         LIMIT 1`)
+        .get(memoryId, workspaceId);
+    const requireMemoryRow = (workspaceId, memoryId) => {
+        const row = getMemoryRow(workspaceId, memoryId);
+        if (!row)
+            throw new DreamRunValidationError('Dream op memory id is outside this workspace');
+        return row;
+    };
+    const listSourceRows = (memoryId) => db
+        .prepare(`SELECT *
+         FROM memory_sources
+         WHERE memory_id = ?
+         ORDER BY created_at ASC, id ASC`)
+        .all(memoryId);
+    const nextFtsRowid = () => db.prepare('SELECT COALESCE(MAX(fts_rowid), 0) + 1 AS next FROM memory_entries').get().next;
+    const getMessageSource = (workspaceId, run, sequence) => {
+        if (run.input_seq_from === null || run.input_seq_to === null)
+            return undefined;
+        return db
+            .prepare(`SELECT sequence, text
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence = ?
+           AND sequence BETWEEN ? AND ?
+           AND type IN (${DREAM_SOURCE_MESSAGE_TYPES})
+         LIMIT 1`)
+            .get(workspaceId, sequence, run.input_seq_from, run.input_seq_to);
+    };
+    const rememberPrior = (prior, workspaceId, memoryId) => {
+        if (prior.has(memoryId))
+            return;
+        const row = requireMemoryRow(workspaceId, memoryId);
+        prior.set(memoryId, { entry: row, sources: listSourceRows(memoryId) });
+    };
+    const validateTouchedIds = (operations) => {
+        const touched = new Set();
+        for (const op of operations) {
+            const ids = op.op === 'add' ? [] : op.op === 'merge' ? [op.into, ...op.from] : [op.id];
+            for (const id of ids) {
+                if (touched.has(id)) {
+                    throw new DreamRunValidationError('Dream ops must not touch the same memory twice');
+                }
+                touched.add(id);
+            }
+        }
+    };
+    const insertDreamSource = (memoryId, sourceSequence, messageText, now) => {
+        const sourceType = sourceSequence === null ? 'dream' : 'message';
+        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 (?, ?, ?, NULL, ?, ?, ?, NULL, NULL, NULL, ?)`).run(randomUUID(), memoryId, sourceType, sourceSequence, excerptFor(messageText), messageText ? hashText(messageText) : null, now);
+    };
+    const insertDreamMemory = (workspaceId, run, op, now) => {
+        const id = randomUUID();
+        db.prepare(`INSERT INTO memory_entries (
+        id,
+        workspace_id,
+        scope,
+        fts_rowid,
+        kind,
+        body,
+        tags,
+        status,
+        source,
+        confidence,
+        pinned,
+        disabled,
+        created_at,
+        updated_at,
+        archived_at,
+        last_injected_at
+      ) VALUES (?, ?, 'workspace', ?, ?, ?, ?, 'active', 'dream', ?, 0, 0, ?, ?, NULL, NULL)`).run(id, workspaceId, nextFtsRowid(), op.kind, op.body, JSON.stringify(op.tags), op.confidence, now, now);
+        if (op.sources.length === 0) {
+            insertDreamSource(id, null, null, now);
+        }
+        else {
+            for (const sequence of op.sources) {
+                const source = getMessageSource(workspaceId, run, sequence);
+                if (!source)
+                    throw new DreamRunValidationError('Dream op source is outside this run input');
+                insertDreamSource(id, sequence, source.text, now);
+            }
+        }
+        return { body: op.body, id, kind: op.kind };
+    };
+    const updateEntryBody = (workspaceId, memoryId, input, now) => {
+        const current = requireMemoryRow(workspaceId, memoryId);
+        db.prepare(`UPDATE memory_entries
+       SET body = ?,
+           tags = ?,
+           kind = ?,
+           confidence = ?,
+           updated_at = ?
+       WHERE id = ?
+         AND workspace_id = ?
+         AND scope = 'workspace'`).run(input.body, JSON.stringify(input.tags ?? parseTags(current.tags)), input.kind ?? current.kind, input.confidence === undefined ? current.confidence : input.confidence, now, memoryId, workspaceId);
+        insertDreamSource(memoryId, null, null, now);
+    };
+    const archiveEntry = (workspaceId, memoryId, now) => {
+        requireMemoryRow(workspaceId, memoryId);
+        db.prepare(`UPDATE memory_entries
+       SET status = 'archived',
+           archived_at = COALESCE(archived_at, ?),
+           updated_at = ?
+       WHERE id = ?
+         AND workspace_id = ?
+         AND scope = 'workspace'`).run(now, now, memoryId, workspaceId);
+        insertDreamSource(memoryId, null, null, now);
+    };
+    const buildPriorState = (workspaceId, run, operations) => {
+        validateTouchedIds(operations);
+        const prior = new Map();
+        for (const op of operations) {
+            if (op.op === 'add') {
+                for (const sequence of op.sources) {
+                    if (!getMessageSource(workspaceId, run, sequence)) {
+                        throw new DreamRunValidationError('Dream op source is outside this run input');
+                    }
+                }
+                continue;
+            }
+            if (op.op === 'merge' && op.from.includes(op.into)) {
+                throw new DreamRunValidationError('Dream merge cannot merge a memory into itself');
+            }
+            const ids = op.op === 'merge' ? [op.into, ...op.from] : [op.id];
+            for (const id of ids)
+                rememberPrior(prior, workspaceId, id);
+        }
+        return prior;
+    };
+    const applyOperations = (workspaceId, run, operations) => {
+        const prior = buildPriorState(workspaceId, run, operations);
+        const report = { added: [], archived: [], merged: [], rewritten: [] };
+        const addedEntryIds = [];
+        const now = Date.now();
+        for (const op of operations) {
+            if (op.op === 'add') {
+                const added = insertDreamMemory(workspaceId, run, op, now);
+                addedEntryIds.push(added.id);
+                report.added.push(added);
+            }
+            else if (op.op === 'archive') {
+                archiveEntry(workspaceId, op.id, now);
+                report.archived.push({ id: op.id, reason: op.reason });
+            }
+            else if (op.op === 'rewrite') {
+                updateEntryBody(workspaceId, op.id, op, now);
+                report.rewritten.push({ id: op.id });
+            }
+            else {
+                updateEntryBody(workspaceId, op.into, op, now);
+                for (const id of op.from)
+                    archiveEntry(workspaceId, id, now);
+                report.merged.push({ from: op.from, into: op.into });
+            }
+        }
+        return {
+            report,
+            revertBlob: {
+                added_entry_ids: addedEntryIds,
+                prior_entries: [...prior.values()],
+            },
+        };
+    };
+    const applyAndCompleteRunTransaction = db.transaction((workspaceId, runId, rawOps) => {
+        requireWorkspace(workspaceId);
+        const run = requireRunningRunRow(workspaceId, runId);
+        const { report, revertBlob } = applyOperations(workspaceId, run, parseDreamOperations(rawOps));
+        db.prepare(`UPDATE dream_runs
+         SET status = 'completed',
+             finished_at = ?,
+             report = ?,
+             revert_blob = ?,
+             error = NULL
+         WHERE id = ?
+           AND workspace_id = ?
+           AND status = 'running'`).run(Date.now(), JSON.stringify(report), JSON.stringify(revertBlob), runId, workspaceId);
+        const completedRow = db
+            .prepare('SELECT * FROM dream_runs WHERE id = ? AND workspace_id = ? LIMIT 1')
+            .get(runId, workspaceId);
+        if (!completedRow)
+            throw new DreamRunValidationError('Dream run disappeared');
+        return toDreamRunRecord(completedRow);
+    });
+    const applyAndCompleteRun = (workspaceId, runId, rawOps) => applyAndCompleteRunTransaction(workspaceId, runId, rawOps);
+    return { applyAndCompleteRun };
+};

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

@@ -0,0 +1,13 @@
+import type { DreamRunRecord } from './team-memory-dream-store.js';
+export declare const serializeDreamRun: (run: DreamRunRecord) => {
+    error: string | null;
+    finished_at: number | null;
+    id: string;
+    input_seq_from: number | null;
+    input_seq_to: number | null;
+    report: import("./team-memory-dream-types.js").DreamRunReport | null;
+    started_at: number;
+    status: import("./team-memory-dream-types.js").DreamRunStatus;
+    trigger: import("./team-memory-dream-types.js").DreamRunTrigger;
+    workspace_id: string;
+};

package/dist/src/server/team-memory-dream-http-serializers.js

@@ -0,0 +1,12 @@
+export const serializeDreamRun = (run) => ({
+    error: run.error,
+    finished_at: run.finishedAt,
+    id: run.id,
+    input_seq_from: run.inputSeqFrom,
+    input_seq_to: run.inputSeqTo,
+    report: run.report,
+    started_at: run.startedAt,
+    status: run.status,
+    trigger: run.trigger,
+    workspace_id: run.workspaceId,
+});

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

@@ -0,0 +1,40 @@
+import { type MemoryKind } from '../shared/team-memory.js';
+interface DreamOperationBase {
+    op: string;
+}
+export interface DreamAddOperation extends DreamOperationBase {
+    body: string;
+    confidence: number;
+    kind: MemoryKind;
+    op: 'add';
+    sources: number[];
+    tags: string[];
+}
+export interface DreamRewriteOperation extends DreamOperationBase {
+    body: string;
+    confidence?: number | null | undefined;
+    id: string;
+    kind?: MemoryKind | undefined;
+    op: 'rewrite';
+    tags?: string[] | undefined;
+}
+export interface DreamArchiveOperation extends DreamOperationBase {
+    id: string;
+    op: 'archive';
+    reason: string | null;
+}
+export interface DreamMergeOperation extends DreamOperationBase {
+    body: string;
+    confidence?: number | null | undefined;
+    from: string[];
+    into: string;
+    kind?: MemoryKind | undefined;
+    op: 'merge';
+    tags?: string[] | undefined;
+}
+export type DreamOperation = DreamAddOperation | DreamArchiveOperation | DreamMergeOperation | DreamRewriteOperation;
+export declare class DreamRunValidationError extends Error {
+    readonly code = "dream_validation_failed";
+}
+export declare const parseDreamOperations: (rawOps: unknown) => DreamOperation[];
+export {};

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