@tt-a1i/hive 1.7.0 → 2.0.2

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';

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

@@ -0,0 +1,102 @@
+import type { MemoryEntryWithSources, MemoryInjectionWithMemory, MemorySearchResult } from './team-memory-store.js';
+export declare const serializeMemoryEntry: (entry: MemoryEntryWithSources) => {
+    archived_at: number | null;
+    body: string;
+    confidence: number | null;
+    created_at: number;
+    disabled: boolean;
+    id: string;
+    kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+    last_injected_at: number | null;
+    pinned: boolean;
+    scope: "workspace" | "user";
+    source: import("./team-memory-store.js").MemorySource;
+    sources: {
+        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: import("./team-memory-store.js").MemorySourceType;
+        text_hash: string | null;
+    }[];
+    status: import("./team-memory-store.js").MemoryStatus;
+    tags: string[];
+    updated_at: number;
+    workspace_id: string | null;
+};
+export declare const serializeMemorySearchResult: (entry: MemorySearchResult) => {
+    index_name: "like" | "trigram" | "unicode";
+    score: number;
+    archived_at: number | null;
+    body: string;
+    confidence: number | null;
+    created_at: number;
+    disabled: boolean;
+    id: string;
+    kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+    last_injected_at: number | null;
+    pinned: boolean;
+    scope: "workspace" | "user";
+    source: import("./team-memory-store.js").MemorySource;
+    sources: {
+        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: import("./team-memory-store.js").MemorySourceType;
+        text_hash: string | null;
+    }[];
+    status: import("./team-memory-store.js").MemoryStatus;
+    tags: string[];
+    updated_at: number;
+    workspace_id: string | null;
+};
+export declare const serializeMemoryInjection: (injection: MemoryInjectionWithMemory) => {
+    context_type: import("./team-memory-store.js").MemoryInjectionContext;
+    dispatch_id: string | null;
+    id: string;
+    injected_at: number;
+    memory: {
+        archived_at: number | null;
+        body: string;
+        confidence: number | null;
+        created_at: number;
+        disabled: boolean;
+        id: string;
+        kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+        last_injected_at: number | null;
+        pinned: boolean;
+        scope: "workspace" | "user";
+        source: import("./team-memory-store.js").MemorySource;
+        sources: {
+            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: import("./team-memory-store.js").MemorySourceType;
+            text_hash: string | null;
+        }[];
+        status: import("./team-memory-store.js").MemoryStatus;
+        tags: string[];
+        updated_at: number;
+        workspace_id: string | null;
+    };
+    memory_id: string;
+    target_agent_id_snapshot: string | null;
+    workspace_id: string | null;
+};

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

@@ -0,0 +1,46 @@
+const serializeMemorySource = (source) => ({
+    actor_agent_id_snapshot: source.actorAgentIdSnapshot,
+    actor_name_snapshot: source.actorNameSnapshot,
+    actor_role_snapshot: source.actorRoleSnapshot,
+    created_at: source.createdAt,
+    excerpt: source.excerpt,
+    id: source.id,
+    memory_id: source.memoryId,
+    source_id: source.sourceId,
+    source_sequence: source.sourceSequence,
+    source_type: source.sourceType,
+    text_hash: source.textHash,
+});
+export const serializeMemoryEntry = (entry) => ({
+    archived_at: entry.archivedAt,
+    body: entry.body,
+    confidence: entry.confidence,
+    created_at: entry.createdAt,
+    disabled: entry.disabled,
+    id: entry.id,
+    kind: entry.kind,
+    last_injected_at: entry.lastInjectedAt,
+    pinned: entry.pinned,
+    scope: entry.scope,
+    source: entry.source,
+    sources: entry.sources.map(serializeMemorySource),
+    status: entry.status,
+    tags: entry.tags,
+    updated_at: entry.updatedAt,
+    workspace_id: entry.workspaceId,
+});
+export const serializeMemorySearchResult = (entry) => ({
+    ...serializeMemoryEntry(entry),
+    index_name: entry.indexName,
+    score: entry.score,
+});
+export const serializeMemoryInjection = (injection) => ({
+    context_type: injection.contextType,
+    dispatch_id: injection.dispatchId,
+    id: injection.id,
+    injected_at: injection.injectedAt,
+    memory: serializeMemoryEntry(injection.memory),
+    memory_id: injection.memoryId,
+    target_agent_id_snapshot: injection.targetAgentIdSnapshot,
+    workspace_id: injection.workspaceId,
+});

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

@@ -0,0 +1,31 @@
+import type { MemoryDigestPayload, WorkspaceMemoryDigestProvider } from './team-memory-digest.js';
+import type { LogMemoryInjectionsInput } from './team-memory-store.js';
+export interface TeamMemoryInjectionService {
+    buildDigest: WorkspaceMemoryDigestProvider['buildDigest'];
+    buildDispatchDigest: WorkspaceMemoryDigestProvider['buildDispatchDigest'];
+    deleteInjections: (injectionIds: string[]) => void;
+    logInjections: (input: LogMemoryInjectionsInput) => string[];
+}
+export declare const buildMemoryDigestSafely: ({ contextType, memoryInjection, workspaceId, }: {
+    contextType: "recovery" | "startup";
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    workspaceId: string;
+}) => MemoryDigestPayload | null;
+export declare const buildDispatchMemoryDigestSafely: ({ memoryInjection, taskText, workerDescription, workspaceId, }: {
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    taskText: string;
+    workerDescription: string;
+    workspaceId: string;
+}) => MemoryDigestPayload | null;
+export declare const logMemoryDigestInjection: ({ agentId, contextType, dispatchId, memoryDigest, memoryInjection, workspaceId, }: {
+    agentId: string;
+    contextType: LogMemoryInjectionsInput["contextType"];
+    dispatchId?: string | null;
+    memoryDigest: MemoryDigestPayload | null | undefined;
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    workspaceId: string;
+}) => string[] | null;
+export declare const rollbackMemoryDigestInjection: ({ injectionIds, memoryInjection, }: {
+    injectionIds: string[] | null;
+    memoryInjection: TeamMemoryInjectionService | undefined;
+}) => void;

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

@@ -0,0 +1,49 @@
+export const buildMemoryDigestSafely = ({ contextType, memoryInjection, workspaceId, }) => {
+    if (!memoryInjection)
+        return null;
+    try {
+        return memoryInjection.buildDigest({ contextType, workspaceId });
+    }
+    catch (error) {
+        console.error('[hive] memory digest build failed', error);
+        return null;
+    }
+};
+export const buildDispatchMemoryDigestSafely = ({ memoryInjection, taskText, workerDescription, workspaceId, }) => {
+    if (!memoryInjection)
+        return null;
+    try {
+        return memoryInjection.buildDispatchDigest({ taskText, workerDescription, workspaceId });
+    }
+    catch (error) {
+        console.error('[hive] dispatch memory digest build failed', error);
+        return null;
+    }
+};
+export const logMemoryDigestInjection = ({ agentId, contextType, dispatchId, memoryDigest, memoryInjection, workspaceId, }) => {
+    if (!memoryDigest || memoryDigest.memoryIds.length === 0 || !memoryInjection)
+        return null;
+    try {
+        return memoryInjection.logInjections({
+            contextType,
+            dispatchId: dispatchId ?? null,
+            memoryIds: memoryDigest.memoryIds,
+            targetAgentIdSnapshot: agentId,
+            workspaceId,
+        });
+    }
+    catch (error) {
+        console.error('[hive] memory injection audit failed', error);
+        return null;
+    }
+};
+export const rollbackMemoryDigestInjection = ({ injectionIds, memoryInjection, }) => {
+    if (!injectionIds || injectionIds.length === 0 || !memoryInjection)
+        return;
+    try {
+        memoryInjection.deleteInjections(injectionIds);
+    }
+    catch (error) {
+        console.error('[hive] memory injection audit rollback failed', error);
+    }
+};

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

@@ -0,0 +1,116 @@
+import type { Database } from 'better-sqlite3';
+import { type MemoryKind } from '../shared/team-memory.js';
+import type { AgentSummary } from '../shared/types.js';
+export type MemoryStatus = 'active' | 'candidate' | 'archived' | 'rejected';
+export type MemorySource = 'manual' | 'dream';
+export type MemorySourceType = 'manual' | 'message' | 'dispatch' | 'report' | 'dream';
+export type MemoryInjectionContext = 'startup' | 'dispatch' | 'recovery' | 'manual_search';
+export interface MemoryActorSnapshot {
+    id: string;
+    name: string;
+    role: AgentSummary['role'];
+}
+export interface MemoryEntryRecord {
+    archivedAt: number | null;
+    body: string;
+    confidence: number | null;
+    createdAt: number;
+    disabled: boolean;
+    id: string;
+    kind: MemoryKind;
+    lastInjectedAt: number | null;
+    pinned: boolean;
+    scope: 'workspace' | 'user';
+    source: MemorySource;
+    status: MemoryStatus;
+    tags: string[];
+    updatedAt: number;
+    workspaceId: string | null;
+}
+export interface MemorySourceRecord {
+    actorAgentIdSnapshot: string | null;
+    actorNameSnapshot: string | null;
+    actorRoleSnapshot: string | null;
+    createdAt: number;
+    excerpt: string | null;
+    id: string;
+    memoryId: string;
+    sourceId: string | null;
+    sourceSequence: number | null;
+    sourceType: MemorySourceType;
+    textHash: string | null;
+}
+export interface MemoryEntryWithSources extends MemoryEntryRecord {
+    sources: MemorySourceRecord[];
+}
+export interface MemorySearchResult extends MemoryEntryWithSources {
+    indexName: 'like' | 'trigram' | 'unicode';
+    score: number;
+}
+export interface AddMemoryEntryInput {
+    actor: MemoryActorSnapshot;
+    body: string;
+    confidence?: number | null;
+    kind: MemoryKind;
+    source?: MemorySource;
+    tags?: string[];
+    workspaceId: string;
+}
+export interface LogMemoryInjectionsInput {
+    contextType: MemoryInjectionContext;
+    dispatchId?: string | null;
+    memoryIds: string[];
+    targetAgentIdSnapshot?: string | null;
+    workspaceId: string;
+}
+export interface MemorySearchOptions {
+    includeDisabled?: boolean;
+    limit?: number;
+    statuses?: MemoryStatus[];
+}
+export interface MemoryListOptions {
+    limit?: number;
+    statuses?: MemoryStatus[];
+}
+export interface MemoryDigestOptions {
+    limit?: number;
+}
+export interface MemoryInjectionWithMemory {
+    contextType: MemoryInjectionContext;
+    dispatchId: string | null;
+    id: string;
+    injectedAt: number;
+    memory: MemoryEntryWithSources;
+    memoryId: string;
+    targetAgentIdSnapshot: string | null;
+    workspaceId: string | null;
+}
+export declare class MemoryEntryNotFoundError extends Error {
+    readonly memoryId: string;
+    readonly workspaceId: string;
+    constructor(memoryId: string, workspaceId: string);
+}
+export declare class MemoryEntryStatusError extends Error {
+    readonly actualStatus: MemoryStatus;
+    readonly memoryId: string;
+    readonly expectedStatus: MemoryStatus | MemoryStatus[];
+    constructor(memoryId: string, expectedStatus: MemoryStatus | MemoryStatus[], actualStatus: MemoryStatus);
+}
+export declare const createTeamMemoryStore: (db: Database) => {
+    addEntry: (input: AddMemoryEntryInput) => MemoryEntryWithSources;
+    approveCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    archiveEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    deleteWorkspaceMemories: (workspaceId: string) => void;
+    deleteInjections: (injectionIds: string[]) => void;
+    getEntryWithSources: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
+    listDigestEntries: (workspaceId: string, options?: MemoryDigestOptions) => MemoryEntryWithSources[];
+    listExportEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    listAllEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    listEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
+    listInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
+    logInjections: (input: LogMemoryInjectionsInput) => `${string}-${string}-${string}-${string}-${string}`[];
+    rejectCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    searchEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+    setDisabled: (workspaceId: string, memoryId: string, disabled: boolean) => MemoryEntryWithSources;
+    setPinned: (workspaceId: string, memoryId: string, pinned: boolean) => MemoryEntryWithSources;
+};