@tt-a1i/hive 1.7.0 → 2.0.1

package/dist/src/server/team-authz.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
-export type TeamCommand = 'send' | 'list' | 'next' | 'report' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
+export type TeamCommand = 'send' | 'list' | 'next' | 'report' | 'recall' | 'memory_add' | 'memory_forget' | 'memory_search' | 'memory_show' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
 export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
 interface AuthenticateInput {
     fromAgentId: string | undefined;

package/dist/src/server/team-authz.js

@@ -5,11 +5,23 @@ const ORCHESTRATOR_COMMANDS = new Set([
     'next',
     'cancel',
     'help',
+    'recall',
+    'memory_add',
+    'memory_forget',
+    'memory_search',
+    'memory_show',
     'spawn',
     'dismiss',
     'workflow',
 ]);
-const WORKER_COMMANDS = new Set(['report', 'status', 'help']);
+const WORKER_COMMANDS = new Set([
+    'report',
+    'status',
+    'help',
+    'recall',
+    'memory_search',
+    'memory_show',
+]);
 const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
 export const commandAllowedForRole = (role, command) => {
     if (role === 'orchestrator')

package/dist/src/server/team-list-enrichment.js

@@ -1,3 +1,4 @@
+import { getBuiltinCommandPresetByCommand } from './command-preset-defaults.js';
 /**
  * Resolves the built-in command preset id for a worker. Mirrors the launch-time
  * lookup in `agent-run-bootstrap.ts::resolveLaunchPreset`: explicit
@@ -16,7 +17,8 @@ export const resolveCommandPresetId = (store, workspaceId, workerId) => {
         return null;
     if (config.commandPresetId)
         return config.commandPresetId;
-    const implicit = store.settings.getCommandPreset(config.command);
+    const implicitBuiltin = getBuiltinCommandPresetByCommand(config.command);
+    const implicit = store.settings.getCommandPreset(implicitBuiltin?.id ?? config.command);
     if (!implicit || implicit.command !== config.command)
         return null;
     return implicit.id;

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

@@ -0,0 +1,52 @@
+import type { MemoryEntryWithSources, MemorySearchResult } from './team-memory-store.js';
+export declare const STARTUP_MEMORY_BUDGET_CHARS = 1200;
+export declare const RECOVERY_MEMORY_BUDGET_CHARS = 800;
+export declare const DISPATCH_MEMORY_BUDGET_CHARS = 1500;
+export declare const MEMORY_DIGEST_ENTRY_LIMIT = 20;
+export declare const DISPATCH_MEMORY_ENTRY_LIMIT = 5;
+export declare const DISPATCH_MEMORY_CANDIDATE_LIMIT = 20;
+export declare const DISPATCH_MEMORY_MIN_CONFIDENCE = 0.5;
+export declare const DISPATCH_MEMORY_RECENCY_DECAY_MS: number;
+export type MemoryDigestContext = 'recovery' | 'startup';
+export interface MemoryDigestPayload {
+    memoryIds: string[];
+    text: string;
+}
+export interface WorkspaceMemoryDigestProvider {
+    buildDigest: (input: {
+        contextType: MemoryDigestContext;
+        workspaceId: string;
+    }) => MemoryDigestPayload | null;
+    buildDispatchDigest: (input: {
+        taskText: string;
+        workerDescription: string;
+        workspaceId: string;
+    }) => MemoryDigestPayload | null;
+}
+interface AppStateReader {
+    getAppState: (key: string) => {
+        value: string | null;
+    } | undefined;
+}
+interface MemoryDigestStore {
+    listDigestEntries: (workspaceId: string, options?: {
+        limit?: number;
+    }) => MemoryEntryWithSources[];
+    searchEntries?: (workspaceId: string, query: string, options?: {
+        limit?: number;
+        statuses?: Array<'active' | 'archived' | 'candidate' | 'rejected'>;
+    }) => MemorySearchResult[];
+}
+export declare const formatMemoryDigestBlock: ({ budget, contextType, entries, }: {
+    budget: number;
+    contextType: MemoryDigestContext;
+    entries: MemoryEntryWithSources[];
+}) => MemoryDigestPayload | null;
+export declare const formatDispatchMemoryBlock: ({ entries, }: {
+    entries: MemorySearchResult[];
+}) => MemoryDigestPayload | null;
+export declare const createWorkspaceMemoryDigestProvider: ({ memoryStore, settings, }: {
+    memoryStore: MemoryDigestStore;
+    settings: AppStateReader;
+}) => WorkspaceMemoryDigestProvider;
+export {};

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