hivehq 2.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,220 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { HIVE_DIR_NAME } from './tasks-file.js';
+export const MEMORY_FILE_NAME = 'memory.md';
+export const MEMORY_RELATIVE_PATH = `${HIVE_DIR_NAME}/${MEMORY_FILE_NAME}`;
+export const MEMORY_EXPORT_DEBOUNCE_MS = 2000;
+export const MEMORY_EXPORT_DREAM_CHANGELOG_LIMIT = 10;
+const GENERATED_MARKER = '<!-- hive-memory:generated v1';
+const GENERATED_END_MARKER = '<!-- /hive-memory:generated -->';
+const GENERATED_WARNING = 'Generated by Hive from SQLite. Do not edit this file by hand; user edits are backed up before regeneration.';
+const KIND_TITLES = {
+    decision: 'Decisions',
+    fact: 'Facts',
+    pitfall: 'Pitfalls',
+    preference: 'Preferences',
+    procedure_ref: 'Procedure refs',
+};
+export const getMemoryFilePath = (workspacePath) => join(workspacePath, HIVE_DIR_NAME, MEMORY_FILE_NAME);
+const hashText = (text) => createHash('sha256').update(text).digest('hex');
+const writeUtf8FileAtomically = (targetPath, content) => {
+    const tempPath = join(dirname(targetPath), `.${basename(targetPath)}.${randomUUID()}.tmp`);
+    let committed = false;
+    let fd = null;
+    try {
+        try {
+            fd = openSync(tempPath, 'w');
+            writeFileSync(fd, content, 'utf8');
+            fsyncSync(fd);
+        }
+        finally {
+            if (fd !== null) {
+                closeSync(fd);
+                fd = null;
+            }
+        }
+        renameSync(tempPath, targetPath);
+        committed = true;
+    }
+    finally {
+        if (!committed && existsSync(tempPath))
+            rmSync(tempPath, { force: true });
+    }
+};
+const normalizeInline = (value) => value.replace(/\s+/g, ' ').trim();
+const formatBody = (body) => body
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .split('\n')
+    .map((line, index) => (index === 0 ? normalizeInline(line) : `  ${line.trim()}`))
+    .join('\n');
+const formatEntryLine = (entry) => {
+    const labels = [entry.kind];
+    if (entry.pinned)
+        labels.push('pinned');
+    if (entry.disabled)
+        labels.push('disabled');
+    labels.push(`source: ${entry.source}`);
+    const source = entry.sources[0];
+    if (source?.actorNameSnapshot)
+        labels.push(`from: ${source.actorNameSnapshot}`);
+    if (entry.tags.length > 0)
+        labels.push(`tags: ${entry.tags.join(', ')}`);
+    return `- [${labels.join(', ')}] ${formatBody(entry.body)}`;
+};
+const formatDreamRunLine = (run) => {
+    const report = run.report;
+    const counts = report
+        ? [
+            `${report.added.length} added`,
+            `${report.rewritten.length} rewritten`,
+            `${report.archived.length} archived`,
+            `${report.merged.length} merged`,
+        ].join(', ')
+        : run.error
+            ? `error: ${normalizeInline(run.error)}`
+            : 'no report';
+    const finished = run.finishedAt ? new Date(run.finishedAt).toISOString() : 'running';
+    const window = run.inputSeqFrom === null || run.inputSeqTo === null
+        ? 'no input'
+        : `seq ${run.inputSeqFrom}-${run.inputSeqTo}`;
+    return `- [${run.status}, ${run.trigger}, ${finished}, ${window}] ${counts}`;
+};
+const renderDreamChangelog = (dreamRuns) => {
+    if (dreamRuns.length === 0)
+        return ['## Dream changelog', 'No dream runs yet.', ''];
+    return ['## Dream changelog', ...dreamRuns.map(formatDreamRunLine), ''];
+};
+const renderMemoryBody = (entries, dreamRuns) => {
+    const activeEntries = entries.filter((entry) => entry.status === 'active');
+    const lines = [];
+    if (activeEntries.length === 0) {
+        lines.push('No active memory entries.', '');
+    }
+    else {
+        for (const kind of Object.keys(KIND_TITLES)) {
+            const group = activeEntries.filter((entry) => entry.kind === kind);
+            if (group.length === 0)
+                continue;
+            lines.push(`## ${KIND_TITLES[kind]}`);
+            for (const entry of group)
+                lines.push(formatEntryLine(entry));
+            lines.push('');
+        }
+    }
+    lines.push(...renderDreamChangelog(dreamRuns));
+    return lines.join('\n');
+};
+export const renderMemoryExport = (entries, dreamRuns = []) => {
+    const body = renderMemoryBody(entries, dreamRuns);
+    return `${renderGeneratedPrefix(hashText(body))}${body}`;
+};
+const renderGeneratedPrefix = (hash) => `${[
+    '# Hive Memory',
+    '',
+    `${GENERATED_MARKER} sha256=${hash} -->`,
+    GENERATED_WARNING,
+    GENERATED_END_MARKER,
+    '',
+].join('\n')}\n`;
+const parseGeneratedBody = (content) => {
+    const markerMatch = content.match(/<!-- hive-memory:generated v1 sha256=([a-f0-9]+) -->/u);
+    const endIndex = content.indexOf(GENERATED_END_MARKER);
+    if (!markerMatch?.[1] || endIndex === -1)
+        return null;
+    const bodyStart = endIndex + GENERATED_END_MARKER.length;
+    return {
+        body: content.slice(bodyStart).replace(/^\n+/, ''),
+        hash: markerMatch[1],
+    };
+};
+const shouldBackupExisting = (content) => {
+    if (!content.includes(GENERATED_MARKER))
+        return true;
+    const generated = parseGeneratedBody(content);
+    if (!generated)
+        return true;
+    if (content !== `${renderGeneratedPrefix(generated.hash)}${generated.body}`)
+        return true;
+    return hashText(generated.body) !== generated.hash;
+};
+const backupExistingIfNeeded = (targetPath, now) => {
+    if (!existsSync(targetPath))
+        return;
+    const existing = readFileSync(targetPath, 'utf8');
+    if (!shouldBackupExisting(existing))
+        return;
+    const backupPath = `${targetPath}.backup-${now()}-${randomUUID()}`;
+    writeUtf8FileAtomically(backupPath, existing);
+};
+export const createTeamMemoryExportService = ({ debounceMs = MEMORY_EXPORT_DEBOUNCE_MS, getWorkspacePath, listDreamRuns = () => [], listEntries, logError = (workspaceId, error) => console.error(`[hive] failed to export memory for workspace ${workspaceId}`, error), now = () => Date.now(), }) => {
+    const timers = new Map();
+    const pending = new Set();
+    const cancel = (workspaceId) => {
+        const timer = timers.get(workspaceId);
+        if (timer)
+            clearTimeout(timer);
+        timers.delete(workspaceId);
+        pending.delete(workspaceId);
+    };
+    const flush = async (workspaceId) => {
+        const timer = timers.get(workspaceId);
+        if (timer)
+            clearTimeout(timer);
+        timers.delete(workspaceId);
+        const wasPending = pending.has(workspaceId);
+        let workspacePath;
+        try {
+            workspacePath = getWorkspacePath(workspaceId);
+        }
+        catch {
+            pending.delete(workspaceId);
+            return;
+        }
+        if (!existsSync(workspacePath)) {
+            pending.delete(workspaceId);
+            return;
+        }
+        const targetPath = getMemoryFilePath(workspacePath);
+        try {
+            mkdirSync(dirname(targetPath), { recursive: true });
+            backupExistingIfNeeded(targetPath, now);
+            writeUtf8FileAtomically(targetPath, renderMemoryExport(listEntries(workspaceId), listDreamRuns(workspaceId)));
+            pending.delete(workspaceId);
+        }
+        catch (error) {
+            if (wasPending)
+                pending.add(workspaceId);
+            throw error;
+        }
+    };
+    return {
+        cancel,
+        async close() {
+            const workspaceIds = [...pending];
+            for (const workspaceId of workspaceIds) {
+                try {
+                    await flush(workspaceId);
+                }
+                catch (error) {
+                    logError(workspaceId, error);
+                }
+            }
+            for (const workspaceId of [...timers.keys()])
+                cancel(workspaceId);
+        },
+        flush,
+        schedule(workspaceId) {
+            const existing = timers.get(workspaceId);
+            if (existing)
+                clearTimeout(existing);
+            pending.add(workspaceId);
+            const timer = setTimeout(() => {
+                void flush(workspaceId).catch((error) => logError(workspaceId, error));
+            }, debounceMs);
+            timer.unref?.();
+            timers.set(workspaceId, timer);
+        },
+    };
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Workspace memory total switch.
+ *
+ * Stored per workspace in app_state. Absent / any value other than "false"
+ * reads as enabled so existing workspaces gain memory behavior by default.
+ */
+export declare const workspaceMemoryEnabledKey: (workspaceId: string) => string;
+export declare const workspaceMemoryDreamEnabledKey: (workspaceId: string) => string;
+export declare const readWorkspaceMemoryEnabled: (raw: string | null | undefined) => boolean;
+export declare const serializeWorkspaceMemoryEnabled: (enabled: boolean) => string;
+export declare const readWorkspaceMemoryDreamEnabled: (raw: string | null | undefined) => boolean;
+export declare const serializeWorkspaceMemoryDreamEnabled: (enabled: boolean) => string;

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

@@ -0,0 +1,12 @@
+/**
+ * Workspace memory total switch.
+ *
+ * Stored per workspace in app_state. Absent / any value other than "false"
+ * reads as enabled so existing workspaces gain memory behavior by default.
+ */
+export const workspaceMemoryEnabledKey = (workspaceId) => `workspace.${workspaceId}.memory.enabled`;
+export const workspaceMemoryDreamEnabledKey = (workspaceId) => `workspace.${workspaceId}.memory.dream.enabled`;
+export const readWorkspaceMemoryEnabled = (raw) => raw !== 'false';
+export const serializeWorkspaceMemoryEnabled = (enabled) => enabled ? 'true' : 'false';
+export const readWorkspaceMemoryDreamEnabled = (raw) => raw !== 'false';
+export const serializeWorkspaceMemoryDreamEnabled = (enabled) => enabled ? 'true' : 'false';