@bbigbang/core 0.1.0

package/dist/services/libraryService.js

@@ -0,0 +1,2263 @@
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { buildDefaultLibraryIndexContent, ensureLocalLibraryScaffold } from './libraryScaffold.js';
+import { buildDefaultLibraryManifest, LIBRARY_MANIFEST_RELATIVE_PATH, parseLibraryManifest, } from './libraryManifest.js';
+import { getPlatformAgentConversationTitle, getPlatformAgentDisabledToolKinds, getPlatformAgentLegacyConversationTitles, } from './platformAgentPolicy.js';
+export const LIBRARY_CURATOR_AGENT_NAME = 'Library Curator';
+export const DEFAULT_LIBRARY_SCHEDULE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const LIBRARY_ROOT_DIRECTORY_NAME = '.library-curator';
+const PERSONAL_LIBRARY_DIRECTORY_NAME = 'personal';
+const SHARED_LIBRARY_DIRECTORY_NAME = 'shared';
+const CURATOR_WORKSPACE_DIRECTORY_NAME = 'workspaces';
+const SHARED_LIBRARY_KEY = 'global';
+const SHARED_LIBRARY_AGENT_NAME = 'Shared Library';
+const LIBRARY_DIRECTORY_PLACEHOLDER = '.keep';
+const RESERVED_LIBRARY_WORKSPACE_TOP_LEVEL_ENTRIES = ['MEMORY.md', 'notes', 'artifacts', 'projects'];
+const CURATOR_DISABLED_TOOL_KINDS_JSON = JSON.stringify(getPlatformAgentDisabledToolKinds('library_curator'));
+export function inferSavedItemSourceKind(contextUrl) {
+    if (contextUrl.includes('/thread/'))
+        return 'thread';
+    if (contextUrl.includes('/channel/'))
+        return 'channel';
+    return 'dm';
+}
+export function mapSavedItemRow(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        messageId: row.messageId,
+        senderName: row.senderName,
+        content: row.content,
+        contextUrl: row.contextUrl,
+        sourceKind: row.sourceKind,
+        processStatus: row.processStatus,
+        processedAt: row.processedAt,
+        processedRunId: row.processedRunId,
+        sourceDeletedAt: row.sourceDeletedAt,
+        sourceDeletedByName: row.sourceDeletedByName,
+        createdAt: row.createdAt,
+    };
+}
+function mapConfigRow(row) {
+    let categories = [];
+    try {
+        const parsed = JSON.parse(row.categoriesJson);
+        if (Array.isArray(parsed)) {
+            categories = parsed.filter((item) => typeof item === 'string' && item.trim().length > 0).map((item) => item.trim());
+        }
+    }
+    catch {
+        categories = [];
+    }
+    return {
+        userId: row.userId,
+        curatorAgentId: row.curatorAgentId,
+        nodeId: row.nodeId,
+        libraryRootPath: row.libraryRootPath,
+        scheduleIntervalMs: row.scheduleIntervalMs,
+        categories,
+        lastRunAt: row.lastRunAt,
+        nextRunAt: row.nextRunAt,
+        enabled: row.enabled === 1,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function mapSharedConfigRow(row) {
+    return {
+        sharedKey: row.sharedKey,
+        libraryRootPath: row.libraryRootPath,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function buildPersonalLibraryRootPath(workspaceRoot, username) {
+    const safeUsername = username.replace(/[^a-zA-Z0-9._-]+/g, '_').trim() || 'user';
+    return path.join(workspaceRoot, LIBRARY_ROOT_DIRECTORY_NAME, PERSONAL_LIBRARY_DIRECTORY_NAME, safeUsername);
+}
+function buildCuratorWorkspacePath(workspaceRoot, username) {
+    const safeUsername = username.replace(/[^a-zA-Z0-9._-]+/g, '_').trim() || 'user';
+    return path.join(workspaceRoot, LIBRARY_ROOT_DIRECTORY_NAME, CURATOR_WORKSPACE_DIRECTORY_NAME, safeUsername);
+}
+function buildSharedLibraryRootPath(workspaceRoot) {
+    return path.join(workspaceRoot, LIBRARY_ROOT_DIRECTORY_NAME, SHARED_LIBRARY_DIRECTORY_NAME, SHARED_LIBRARY_KEY);
+}
+function buildLegacyHomeLibraryRootPath(username) {
+    const safeUsername = username.replace(/[^a-zA-Z0-9._-]+/g, '_').trim() || 'user';
+    return path.join(os.homedir(), 'bigbang-library', safeUsername);
+}
+function buildLegacyWorkspaceLibraryRootPath(workspaceRoot, username) {
+    const safeUsername = username.replace(/[^a-zA-Z0-9._-]+/g, '_').trim() || 'user';
+    return path.join(workspaceRoot, LIBRARY_ROOT_DIRECTORY_NAME, safeUsername);
+}
+function isLegacyPersonalLibraryRootPath(workspaceRoot, libraryRootPath, username) {
+    const resolved = path.resolve(libraryRootPath);
+    return resolved === path.resolve(buildLegacyHomeLibraryRootPath(username))
+        || resolved === path.resolve(buildLegacyWorkspaceLibraryRootPath(workspaceRoot, username));
+}
+function migrateLocalLibraryRootIfNeeded(previousPath, nextPath) {
+    if (!previousPath.trim() || path.resolve(previousPath) === path.resolve(nextPath))
+        return;
+    try {
+        if (!fs.existsSync(previousPath) || fs.existsSync(nextPath))
+            return;
+        fs.mkdirSync(path.dirname(nextPath), { recursive: true });
+        fs.cpSync(previousPath, nextPath, { recursive: true });
+    }
+    catch {
+        // Best-effort local migration; keep going with a fresh scaffold if it fails.
+    }
+}
+function ensureLocalCuratorWorkspace(workspacePath) {
+    fs.mkdirSync(workspacePath, { recursive: true });
+}
+function migrateLocalCuratorWorkspaceArtifacts(libraryRootPath, workspacePath) {
+    ensureLocalCuratorWorkspace(workspacePath);
+    for (const entryName of RESERVED_LIBRARY_WORKSPACE_TOP_LEVEL_ENTRIES) {
+        const sourcePath = path.join(libraryRootPath, entryName);
+        const destinationPath = path.join(workspacePath, entryName);
+        try {
+            if (!fs.existsSync(sourcePath) || fs.existsSync(destinationPath))
+                continue;
+            moveLocalPathBestEffort(sourcePath, destinationPath);
+        }
+        catch {
+            // Best-effort cleanup; mirror filtering prevents future exposure if this fails.
+        }
+    }
+}
+function moveLocalPathBestEffort(sourcePath, destinationPath) {
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    try {
+        fs.renameSync(sourcePath, destinationPath);
+    }
+    catch (error) {
+        const maybeErr = error;
+        if (maybeErr?.code !== 'EXDEV')
+            throw error;
+        fs.cpSync(sourcePath, destinationPath, { recursive: true });
+        fs.rmSync(sourcePath, { recursive: true, force: true });
+    }
+}
+function buildCuratorEnvVars() {
+    const envVars = {};
+    const baseUrl = process.env.LIBRARY_CURATOR_ANTHROPIC_BASE_URL?.trim()
+        || process.env.ANTHROPIC_BASE_URL?.trim();
+    const model = process.env.LIBRARY_CURATOR_ANTHROPIC_MODEL?.trim()
+        || process.env.ANTHROPIC_MODEL?.trim()
+        || 'deepseek-v4-pro';
+    const authToken = process.env.LIBRARY_CURATOR_ANTHROPIC_AUTH_TOKEN?.trim()
+        || process.env.LIBRARY_CURATOR_ANTHROPIC_API_KEY?.trim()
+        || process.env.ANTHROPIC_AUTH_TOKEN?.trim()
+        || process.env.ANTHROPIC_API_KEY?.trim();
+    if (baseUrl)
+        envVars.ANTHROPIC_BASE_URL = baseUrl;
+    if (model)
+        envVars.ANTHROPIC_MODEL = model;
+    if (authToken)
+        envVars.ANTHROPIC_AUTH_TOKEN = authToken;
+    for (const key of [
+        'ANTHROPIC_DEFAULT_OPUS_MODEL',
+        'ANTHROPIC_DEFAULT_SONNET_MODEL',
+        'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+        'CLAUDE_CODE_SUBAGENT_MODEL',
+        'CLAUDE_CODE_EFFORT_LEVEL',
+    ]) {
+        const value = process.env[key]?.trim();
+        if (value)
+            envVars[key] = value;
+    }
+    return envVars;
+}
+function pickLibraryNodeId(nodeRegistry) {
+    for (const node of nodeRegistry.listNodes()) {
+        const agentTypes = Array.isArray(node.agentTypes) ? node.agentTypes : [];
+        if (agentTypes.includes('claude_sdk'))
+            return node.nodeId;
+    }
+    const fallback = nodeRegistry.listNodes()[0];
+    return fallback?.nodeId ?? null;
+}
+function slugifyLibraryAgentName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'library-curator';
+}
+function mapLibraryDocumentRow(row, scope) {
+    return {
+        id: String(row.id),
+        scope,
+        userId: row.userId ? String(row.userId) : null,
+        title: String(row.title),
+        category: String(row.category ?? ''),
+        topicPath: String(row.topicPath ?? ''),
+        relativePath: String(row.relativePath),
+        summary: String(row.summary ?? ''),
+        sourceSavedItemIds: parseStringArrayJson(String(row.sourceSavedItemIdsJson ?? '[]')),
+        createdAt: Number(row.createdAt),
+        updatedAt: Number(row.updatedAt),
+        lastRunId: row.lastRunId ? String(row.lastRunId) : null,
+        notionPageId: row.notionPageId ? String(row.notionPageId) : null,
+        notionPageUrl: row.notionPageUrl ? String(row.notionPageUrl) : null,
+    };
+}
+export function getLibraryCuratorTerminalError(stopReason, error) {
+    const explicitError = error?.trim();
+    if (explicitError)
+        return explicitError;
+    const normalized = stopReason?.trim().toLowerCase();
+    if (!normalized || normalized === 'end_turn' || normalized === 'stop_sequence')
+        return undefined;
+    if (normalized.includes('cancel') || normalized.includes('abort') || normalized === 'error') {
+        return `Library curator run ended before completion: ${stopReason}`;
+    }
+    return undefined;
+}
+export class LibraryService {
+    db;
+    conversationManager;
+    nodeRegistry;
+    workspaceBroker;
+    workspaceRoot;
+    writebackChains = new Map();
+    constructor(db, conversationManager, nodeRegistry, workspaceBroker, workspaceRoot) {
+        this.db = db;
+        this.conversationManager = conversationManager;
+        this.nodeRegistry = nodeRegistry;
+        this.workspaceBroker = workspaceBroker;
+        this.workspaceRoot = workspaceRoot;
+    }
+    purgeStaleRunLibraryMirrors() {
+        this.db.prepare(`DELETE FROM library_run_mirrors
+        WHERE run_id IN (
+          SELECT m.run_id
+            FROM library_run_mirrors m
+            LEFT JOIN runs r ON r.run_id = m.run_id
+           WHERE r.run_id IS NULL
+              OR r.ended_at IS NOT NULL
+        )`).run();
+    }
+    getConfig(userId) {
+        const row = this.db.prepare(`SELECT user_id as userId, curator_agent_id as curatorAgentId, node_id as nodeId,
+              library_root_path as libraryRootPath, schedule_interval_ms as scheduleIntervalMs,
+              categories_json as categoriesJson, last_run_at as lastRunAt, next_run_at as nextRunAt,
+              enabled, created_at as createdAt, updated_at as updatedAt
+       FROM library_curator_configs WHERE user_id = ?`).get(userId);
+        return row ? mapConfigRow(row) : null;
+    }
+    getSharedConfig() {
+        const row = this.db.prepare(`SELECT shared_key as sharedKey, library_root_path as libraryRootPath,
+              created_at as createdAt, updated_at as updatedAt
+       FROM shared_library_config
+       WHERE shared_key = ?`).get(SHARED_LIBRARY_KEY);
+        return row ? mapSharedConfigRow(row) : null;
+    }
+    ensureSharedConfig() {
+        const existing = this.getSharedConfig();
+        if (existing) {
+            ensureLocalLibraryScaffold(existing.libraryRootPath);
+            return existing;
+        }
+        const now = Date.now();
+        const libraryRootPath = buildSharedLibraryRootPath(this.workspaceRoot);
+        ensureLocalLibraryScaffold(libraryRootPath);
+        this.db.prepare(`INSERT INTO shared_library_config(shared_key, library_root_path, created_at, updated_at)
+       VALUES(?, ?, ?, ?)`).run(SHARED_LIBRARY_KEY, libraryRootPath, now, now);
+        return this.getSharedConfig();
+    }
+    isPersonalLibraryEnabledForConversation(conversationId) {
+        const row = this.db.prepare(`SELECT personal_library_enabled as personalLibraryEnabled
+         FROM conversations
+        WHERE id = ?`).get(conversationId);
+        return row?.personalLibraryEnabled === 1;
+    }
+    enablePersonalLibraryForConversation(conversationId) {
+        this.db.prepare(`UPDATE conversations
+          SET personal_library_enabled = 1,
+              updated_at = ?
+        WHERE id = ?`).run(Date.now(), conversationId);
+    }
+    async ensureConfigForUser(params) {
+        const existing = this.getConfig(params.userId);
+        if (existing) {
+            const synced = await this.syncExistingConfigForUser({
+                ...params,
+                existing,
+            });
+            return synced;
+        }
+        const now = Date.now();
+        const nodeId = pickLibraryNodeId(this.nodeRegistry);
+        const libraryRootPath = buildPersonalLibraryRootPath(this.workspaceRoot, params.username);
+        const workspacePath = buildCuratorWorkspacePath(this.workspaceRoot, params.username);
+        const curatorAgentId = randomUUID();
+        const agentType = 'claude_sdk';
+        const envVars = buildCuratorEnvVars();
+        const envVarsJson = Object.keys(envVars).length > 0 ? JSON.stringify(envVars) : null;
+        ensureLocalLibraryScaffold(libraryRootPath);
+        ensureLocalCuratorWorkspace(workspacePath);
+        this.db.prepare(`INSERT INTO agents(
+         agent_id, name, agent_type, agent_role, model, reasoning_effort, claude_permission_mode,
+         codex_mode, codex_service_tier, channel_id, system_prompt, description, memory,
+         env_vars, disabled_tool_kinds, node_id, workspace_path, project_path, skill_roots,
+         created_at, updated_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(curatorAgentId, LIBRARY_CURATOR_AGENT_NAME, agentType, 'platform_agent', envVars.ANTHROPIC_MODEL ?? 'deepseek-v4-pro', null, 'bypassPermissions', null, null, 'default', '', 'System workbench agent that organizes saved messages into structured library documents.', '', envVarsJson, CURATOR_DISABLED_TOOL_KINDS_JSON, nodeId, workspacePath, null, null, now, now);
+        this.db.prepare(`INSERT OR IGNORE INTO agent_channel_memberships(agent_id, channel_id, is_home, joined_at)
+       VALUES(?, 'default', 1, ?)`).run(curatorAgentId, now);
+        this.db.prepare(`INSERT OR IGNORE INTO user_agent_access(user_id, agent_id, granted_at) VALUES(?, ?, ?)`).run(params.userId, curatorAgentId, now);
+        const nextRunAt = now + DEFAULT_LIBRARY_SCHEDULE_INTERVAL_MS;
+        this.db.prepare(`INSERT INTO library_curator_configs(
+         user_id, curator_agent_id, node_id, library_root_path, schedule_interval_ms,
+         categories_json, last_run_at, next_run_at, enabled, created_at, updated_at
+       ) VALUES(?, ?, ?, ?, ?, '[]', NULL, ?, 1, ?, ?)`).run(params.userId, curatorAgentId, nodeId, libraryRootPath, DEFAULT_LIBRARY_SCHEDULE_INTERVAL_MS, nextRunAt, now, now);
+        await this.ensureRemoteLibraryScaffold(nodeId, libraryRootPath);
+        const created = this.getConfig(params.userId);
+        if (!created)
+            throw new Error('Failed to create library curator config');
+        this.syncPlatformAgentInstance(created);
+        return created;
+    }
+    async syncExistingConfigForUser(params) {
+        const resolvedNodeId = this.resolveCuratorNodeId(params.existing.nodeId);
+        let libraryRootPath = params.existing.libraryRootPath.trim();
+        const expectedLibraryRootPath = buildPersonalLibraryRootPath(this.workspaceRoot, params.username);
+        const expectedWorkspacePath = buildCuratorWorkspacePath(this.workspaceRoot, params.username);
+        if (!libraryRootPath) {
+            libraryRootPath = expectedLibraryRootPath;
+        }
+        else if (isLegacyPersonalLibraryRootPath(this.workspaceRoot, libraryRootPath, params.username)) {
+            libraryRootPath = expectedLibraryRootPath;
+        }
+        if (path.resolve(libraryRootPath) !== path.resolve(params.existing.libraryRootPath)) {
+            migrateLocalLibraryRootIfNeeded(params.existing.libraryRootPath, libraryRootPath);
+        }
+        ensureLocalLibraryScaffold(libraryRootPath);
+        ensureLocalCuratorWorkspace(expectedWorkspacePath);
+        migrateLocalCuratorWorkspaceArtifacts(libraryRootPath, expectedWorkspacePath);
+        const assignmentChanged = resolvedNodeId !== params.existing.nodeId
+            || path.resolve(libraryRootPath) !== path.resolve(params.existing.libraryRootPath);
+        const agentRow = this.db.prepare(`SELECT system_prompt as systemPrompt, workspace_path as workspacePath, disabled_tool_kinds as disabledToolKindsJson
+         FROM agents
+        WHERE agent_id = ?`).get(params.existing.curatorAgentId);
+        const hasPersistedSystemPrompt = Boolean(agentRow?.systemPrompt?.trim());
+        const workspacePathChanged = path.resolve(agentRow?.workspacePath?.trim() || '')
+            !== path.resolve(expectedWorkspacePath);
+        const disabledToolKindsChanged = agentRow?.disabledToolKindsJson !== CURATOR_DISABLED_TOOL_KINDS_JSON;
+        const conversationWorkspacePathNeedsRepair = this.db.prepare(`SELECT COUNT(*) as count
+           FROM conversations
+          WHERE agent_id = ?
+            AND COALESCE(workspace_path, '') != ?`).get(params.existing.curatorAgentId, expectedWorkspacePath).count > 0;
+        if ((hasPersistedSystemPrompt || disabledToolKindsChanged) && !assignmentChanged && !workspacePathChanged) {
+            this.db.prepare(`UPDATE agents
+            SET system_prompt = '',
+                disabled_tool_kinds = ?,
+                updated_at = ?
+          WHERE agent_id = ?`).run(CURATOR_DISABLED_TOOL_KINDS_JSON, Date.now(), params.existing.curatorAgentId);
+        }
+        if (assignmentChanged || workspacePathChanged || conversationWorkspacePathNeedsRepair || disabledToolKindsChanged) {
+            const now = Date.now();
+            this.db.prepare(`UPDATE library_curator_configs
+            SET node_id = ?,
+                library_root_path = ?,
+                updated_at = ?
+          WHERE user_id = ?`).run(resolvedNodeId, libraryRootPath, now, params.userId);
+            this.db.prepare(`UPDATE agents
+            SET node_id = ?,
+                workspace_path = ?,
+                system_prompt = '',
+                disabled_tool_kinds = ?,
+                updated_at = ?
+          WHERE agent_id = ?`).run(resolvedNodeId, expectedWorkspacePath, CURATOR_DISABLED_TOOL_KINDS_JSON, now, params.existing.curatorAgentId);
+            this.db.prepare(`UPDATE conversations
+            SET node_id = ?,
+                workspace_path = ?,
+                updated_at = ?
+          WHERE agent_id = ?`).run(resolvedNodeId, expectedWorkspacePath, now, params.existing.curatorAgentId);
+            await this.ensureRemoteLibraryScaffold(resolvedNodeId, libraryRootPath);
+        }
+        const synced = this.getConfig(params.userId) ?? params.existing;
+        this.syncPlatformAgentInstance(synced);
+        return synced;
+    }
+    resolveCuratorNodeId(currentNodeId) {
+        const normalizedCurrentNodeId = currentNodeId?.trim() || null;
+        if (normalizedCurrentNodeId) {
+            const currentNode = this.nodeRegistry.getNode(normalizedCurrentNodeId);
+            if (currentNode?.agentTypes.includes('claude_sdk'))
+                return normalizedCurrentNodeId;
+        }
+        return pickLibraryNodeId(this.nodeRegistry) ?? normalizedCurrentNodeId;
+    }
+    async ensureRemoteLibraryScaffold(nodeId, libraryRootPath, agentName = LIBRARY_CURATOR_AGENT_NAME) {
+        if (!nodeId)
+            return;
+        ensureLocalLibraryScaffold(libraryRootPath);
+        const files = [
+            { relativePath: 'INDEX.md', absolutePath: path.join(libraryRootPath, 'INDEX.md') },
+            { relativePath: LIBRARY_MANIFEST_RELATIVE_PATH, absolutePath: path.join(libraryRootPath, LIBRARY_MANIFEST_RELATIVE_PATH) },
+        ];
+        for (const file of files) {
+            let alreadyPresent = false;
+            try {
+                await this.workspaceBroker.readFile(nodeId, libraryRootPath, file.relativePath, {
+                    scaffold: false,
+                    agentName,
+                });
+                alreadyPresent = true;
+            }
+            catch {
+                alreadyPresent = false;
+            }
+            if (alreadyPresent)
+                continue;
+            try {
+                const content = fs.readFileSync(file.absolutePath, 'utf8');
+                await this.workspaceBroker.writeFile(nodeId, libraryRootPath, file.relativePath, content, 'overwrite', { scaffold: false, agentName });
+            }
+            catch {
+                // Best-effort remote scaffold; local workspace remains authoritative.
+            }
+        }
+    }
+    updateConfig(userId, patch) {
+        const existing = this.getConfig(userId);
+        if (!existing)
+            throw new Error('Library config not found');
+        const now = Date.now();
+        const scheduleIntervalMs = patch.scheduleIntervalMs ?? existing.scheduleIntervalMs;
+        const categories = patch.categories ?? existing.categories;
+        const enabled = patch.enabled ?? existing.enabled;
+        const nextRunAt = enabled ? existing.nextRunAt ?? (now + scheduleIntervalMs) : null;
+        this.db.prepare(`UPDATE library_curator_configs
+          SET schedule_interval_ms = ?,
+              categories_json = ?,
+              enabled = ?,
+              next_run_at = ?,
+              updated_at = ?
+        WHERE user_id = ?`).run(Math.max(60_000, scheduleIntervalMs), JSON.stringify(categories), enabled ? 1 : 0, nextRunAt, now, userId);
+        const updated = this.getConfig(userId);
+        if (!updated)
+            throw new Error('Library config not found after update');
+        this.syncPlatformAgentInstance(updated, { overwriteCanonical: true });
+        return updated;
+    }
+    syncPlatformAgentInstance(config, options) {
+        const agent = this.getCuratorAgent(config.userId);
+        try {
+            const conflictUpdate = options?.overwriteCanonical
+                ? `agent_id = excluded.agent_id,
+           enabled = excluded.enabled,
+           schedule_interval_ms = excluded.schedule_interval_ms,
+           workflow_config_json = excluded.workflow_config_json,
+           runtime_config_json = excluded.runtime_config_json,
+           last_run_at = excluded.last_run_at,
+           next_run_at = excluded.next_run_at,
+           updated_at = excluded.updated_at`
+                : `agent_id = excluded.agent_id,
+           last_run_at = COALESCE(platform_agent_instances.last_run_at, excluded.last_run_at),
+           updated_at = excluded.updated_at`;
+            this.db.prepare(`INSERT INTO platform_agent_instances(
+           user_id, definition_id, agent_id, enabled, schedule_interval_ms,
+           workflow_config_json, runtime_config_json, last_run_at, next_run_at,
+           created_at, updated_at
+         ) VALUES(?, 'library_curator', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(user_id, definition_id) DO UPDATE SET
+           ${conflictUpdate}`).run(config.userId, config.curatorAgentId, config.enabled ? 1 : 0, Math.max(60_000, config.scheduleIntervalMs), JSON.stringify({
+                categories: config.categories,
+                libraryRootPath: config.libraryRootPath,
+            }), JSON.stringify({
+                model: agent?.model ?? null,
+                reasoningEffort: agent?.reasoningEffort ?? null,
+                envVars: agent?.envVars ?? {},
+            }), config.lastRunAt, config.nextRunAt, config.createdAt, Date.now());
+        }
+        catch {
+            // Older tests and pre-v124 schemas may not have the generic platform-agent tables yet.
+        }
+    }
+    listInboxSavedItems(userId) {
+        const rows = this.db.prepare(`SELECT id, user_id as userId, message_id as messageId, sender_name as senderName,
+              content, context_url as contextUrl, source_kind as sourceKind,
+              process_status as processStatus, processed_at as processedAt,
+              processed_run_id as processedRunId,
+              source_deleted_at as sourceDeletedAt,
+              source_deleted_by_name as sourceDeletedByName,
+              created_at as createdAt
+       FROM saved_items
+       WHERE user_id = ? AND process_status = 'inbox' AND source_deleted_at IS NULL
+       ORDER BY created_at ASC`).all(userId);
+        return rows.map(mapSavedItemRow);
+    }
+    async searchDocuments(userId, query, scope = 'personal') {
+        const normalized = query.trim().toLowerCase();
+        if (!normalized || normalized.length < 2)
+            return [];
+        const docs = await this.listDocuments(userId, undefined, scope);
+        return docs.filter((doc) => {
+            const haystack = `${doc.title} ${doc.summary} ${doc.relativePath}`.toLowerCase();
+            return haystack.includes(normalized);
+        });
+    }
+    async listDocuments(userId, category, scope = 'personal') {
+        if (scope === 'all') {
+            const [personalDocs, sharedDocs] = await Promise.all([
+                this.listDocuments(userId, category, 'personal'),
+                this.listDocuments(userId, category, 'shared'),
+            ]);
+            return [...sharedDocs, ...personalDocs];
+        }
+        const location = this.getLibraryLocation(userId, scope);
+        if (!location)
+            return [];
+        await this.reconcileIndexedDocumentsForLocation(location);
+        return this.queryIndexedDocumentsForLocation(location, category);
+    }
+    async buildDocumentTree(userId, scope = 'personal') {
+        if (scope === 'all') {
+            const [personalTree, sharedTree] = await Promise.all([
+                this.buildDocumentTree(userId, 'personal'),
+                this.buildDocumentTree(userId, 'shared'),
+            ]);
+            const nodes = [];
+            if (personalTree.length > 0) {
+                nodes.push({
+                    scope: 'personal',
+                    name: 'personal',
+                    path: 'personal',
+                    kind: 'directory',
+                    children: personalTree,
+                });
+            }
+            if (sharedTree.length > 0) {
+                nodes.push({
+                    scope: 'shared',
+                    name: 'shared',
+                    path: 'shared',
+                    kind: 'directory',
+                    children: sharedTree,
+                });
+            }
+            return nodes;
+        }
+        const location = this.getLibraryLocation(userId, scope);
+        if (!location)
+            return [];
+        return this.buildDocumentTreeForLocation(location);
+    }
+    async readLibraryFile(userId, relativePath, scope = 'personal') {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        return this.readLibraryFileFromLocation(location, relativePath);
+    }
+    async getDocumentNotionMetadata(userId, relativePath, scope = 'personal') {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const manifest = await this.readLibraryManifest(location);
+        const doc = manifest.documents.find((d) => d.relativePath === relativePath);
+        return {
+            notionPageId: doc?.notionPageId ?? null,
+            notionPageUrl: doc?.notionPageUrl ?? null,
+        };
+    }
+    async setDocumentNotionMetadata(userId, relativePath, scope, notionPageId, notionPageUrl) {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const manifest = await this.readLibraryManifest(location);
+        const existing = manifest.documents.find((d) => d.relativePath === relativePath);
+        if (!existing) {
+            throw new Error('Document not found in manifest');
+        }
+        const nextManifest = {
+            version: manifest.version || 1,
+            processedSavedItemIds: manifest.processedSavedItemIds ?? [],
+            documents: manifest.documents.map((doc) => doc.relativePath === relativePath
+                ? { ...doc, notionPageId, notionPageUrl }
+                : doc),
+        };
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.reconcileIndexedDocumentsForLocation(location);
+    }
+    async createDirectory(userId, relativePath, scope = 'personal') {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const { normalizedPath, absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        if (normalizedPath.toLowerCase().endsWith('.md')) {
+            throw new Error('Directory path cannot end with .md');
+        }
+        assertLibraryWritePathAllowed(normalizedPath);
+        if (location.nodeId) {
+            await this.workspaceBroker.writeFile(location.nodeId, location.libraryRootPath, `${normalizedPath}/${LIBRARY_DIRECTORY_PLACEHOLDER}`, '', 'overwrite', { scaffold: false, agentName: location.agentName });
+        }
+        const fsPromises = await import('node:fs/promises');
+        await fsPromises.mkdir(absolutePath, { recursive: true });
+        await this.reconcileIndexedDocumentsForLocation(location);
+    }
+    async writeDocumentFile(userId, relativePath, content, scope = 'personal') {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const { normalizedPath, absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        assertLibraryWritePathAllowed(normalizedPath);
+        if (!normalizedPath.toLowerCase().endsWith('.md')) {
+            throw new Error('Library documents must be markdown files');
+        }
+        const nextContent = content.replace(/\r\n/g, '\n');
+        if (location.nodeId) {
+            await this.workspaceBroker.writeFile(location.nodeId, location.libraryRootPath, normalizedPath, nextContent, 'overwrite', { scaffold: false, agentName: location.agentName });
+        }
+        const fsPromises = await import('node:fs/promises');
+        await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fsPromises.writeFile(absolutePath, nextContent, 'utf8');
+        const existingManifest = await this.readLibraryManifest(location);
+        const nextManifest = upsertLibraryManifestDocument(existingManifest, normalizedPath, nextContent);
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.reconcileIndexedDocumentsForLocation(location);
+    }
+    async applyStructuredCuratorPlan(params) {
+        const location = this.getRequiredLibraryLocation(params.userId, 'personal');
+        const allowedSavedItemIds = new Set(params.savedItems.map((item) => item.id));
+        const processedSavedItemIds = [...new Set(params.plan.processedSavedItemIds.filter((id) => allowedSavedItemIds.has(id)))];
+        if (processedSavedItemIds.length !== params.plan.processedSavedItemIds.length) {
+            throw new Error('Library curator plan referenced saved item ids outside the current inbox snapshot.');
+        }
+        const manifest = await this.readLibraryManifest(location);
+        const nextManifestDocuments = new Map(manifest.documents.map((doc) => [doc.relativePath, { ...doc }]));
+        const touchedPaths = new Set();
+        for (const operation of params.plan.operations) {
+            const { normalizedPath, absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, operation.relativePath);
+            assertLibraryWritePathAllowed(normalizedPath);
+            if (!normalizedPath.toLowerCase().endsWith('.md')) {
+                throw new Error('Library curator may only target markdown documents.');
+            }
+            if (touchedPaths.has(normalizedPath)) {
+                throw new Error(`Library curator plan targeted ${normalizedPath} multiple times.`);
+            }
+            touchedPaths.add(normalizedPath);
+            if (operation.sourceSavedItemIds.some((id) => !allowedSavedItemIds.has(id))) {
+                throw new Error(`Library curator plan referenced unknown sourceSavedItemIds for ${normalizedPath}.`);
+            }
+            const existingKind = await this.getAuthorityEntryKind(location, normalizedPath);
+            if (operation.kind === 'create' && existingKind) {
+                throw new Error(`Library curator create target already exists: ${normalizedPath}`);
+            }
+            if (operation.kind === 'update' && existingKind !== 'file') {
+                throw new Error(`Library curator update target does not exist as a file: ${normalizedPath}`);
+            }
+            const nextContent = operation.content.replace(/\r\n/g, '\n');
+            if (location.nodeId) {
+                await this.workspaceBroker.writeFile(location.nodeId, location.libraryRootPath, normalizedPath, nextContent, 'overwrite', { scaffold: false, agentName: location.agentName });
+            }
+            const fsPromises = await import('node:fs/promises');
+            await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fsPromises.writeFile(absolutePath, nextContent, 'utf8');
+            const extractedTitle = extractLibraryDocumentTitle(nextContent);
+            nextManifestDocuments.set(normalizedPath, {
+                title: extractedTitle || operation.title.trim() || path.posix.basename(normalizedPath, '.md'),
+                category: inferLibraryCategory(normalizedPath),
+                topicPath: inferLibraryTopicPath(normalizedPath),
+                relativePath: normalizedPath,
+                summary: operation.summary.trim(),
+                sourceSavedItemIds: [...new Set(operation.sourceSavedItemIds)],
+            });
+        }
+        const nextManifest = {
+            version: manifest.version || 1,
+            processedSavedItemIds,
+            documents: [...nextManifestDocuments.values()].sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
+        };
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.reconcileIndexedDocumentsForLocation(location, params.runId);
+        if (processedSavedItemIds.length > 0) {
+            const now = Date.now();
+            const markProcessed = this.db.prepare(`UPDATE saved_items
+            SET process_status = 'processed', processed_at = ?, processed_run_id = ?
+          WHERE user_id = ? AND id = ?`);
+            for (const savedItemId of processedSavedItemIds) {
+                markProcessed.run(now, params.runId, params.userId, savedItemId);
+            }
+        }
+        return {
+            writtenDocuments: touchedPaths.size,
+            processedSavedItemIds,
+        };
+    }
+    async renameEntry(userId, relativePath, kind, nextName, scope) {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const { normalizedPath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        assertLibraryWritePathAllowed(normalizedPath);
+        const entryKind = await this.getAuthorityEntryKind(location, normalizedPath);
+        if (!entryKind) {
+            throw new Error('Path not found');
+        }
+        if (entryKind !== kind) {
+            throw new Error(kind === 'file' ? 'Path is not a file' : 'Path is not a directory');
+        }
+        if (kind === 'file' && !normalizedPath.toLowerCase().endsWith('.md')) {
+            throw new Error('Only markdown files can be renamed in the library');
+        }
+        const nextRelativePath = buildRenamedLibraryPath(normalizedPath, nextName, kind);
+        assertLibraryWritePathAllowed(nextRelativePath);
+        if (nextRelativePath === normalizedPath) {
+            throw new Error('Source and destination paths are the same');
+        }
+        if (location.nodeId) {
+            try {
+                await this.workspaceBroker.renameLibraryPath(location.nodeId, location.libraryRootPath, normalizedPath, nextRelativePath, { agentName: location.agentName });
+            }
+            catch (error) {
+                const committed = await this.didRemoteAuthorityRenameCommit(location, normalizedPath, nextRelativePath, kind);
+                if (!committed)
+                    throw error;
+                try {
+                    await this.recoverCommittedRemoteAuthorityRename(location, normalizedPath, nextRelativePath, kind);
+                }
+                catch (recoveryError) {
+                    throw new Error(`Remote library rename appears to have succeeded after a transport failure, but recovery failed: ${String(recoveryError?.message ?? recoveryError)}`);
+                }
+                return;
+            }
+            try {
+                await this.syncRemoteAuthorityRenameToLocalCache(location, normalizedPath, nextRelativePath, kind);
+                await this.finalizeAuthorityRename(location, normalizedPath, nextRelativePath, kind);
+            }
+            catch (error) {
+                try {
+                    await this.recoverCommittedRemoteAuthorityRename(location, normalizedPath, nextRelativePath, kind);
+                }
+                catch (recoveryError) {
+                    throw new Error(`Remote library rename succeeded, but post-rename synchronization failed: ${String(recoveryError?.message ?? recoveryError)}`);
+                }
+            }
+            return;
+        }
+        await renameAuthorityLibraryPath(location.libraryRootPath, normalizedPath, nextRelativePath);
+        await this.finalizeAuthorityRename(location, normalizedPath, nextRelativePath, kind);
+    }
+    async deleteEntry(userId, relativePath, kind, scope) {
+        const location = this.getRequiredLibraryLocation(userId, scope);
+        const { normalizedPath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        assertLibraryWritePathAllowed(normalizedPath);
+        const entryKind = await this.getAuthorityEntryKind(location, normalizedPath);
+        if (!entryKind) {
+            throw new Error('Path not found');
+        }
+        if (entryKind !== kind) {
+            throw new Error(kind === 'file' ? 'Path is not a file' : 'Path is not a directory');
+        }
+        if (kind === 'file' && !normalizedPath.toLowerCase().endsWith('.md')) {
+            throw new Error('Only markdown files can be deleted from the library');
+        }
+        if (location.nodeId) {
+            await this.workspaceBroker.deleteLibraryPath(location.nodeId, location.libraryRootPath, normalizedPath, { recursive: kind === 'directory', agentName: location.agentName });
+        }
+        await deleteAuthorityLibraryPath(location.libraryRootPath, normalizedPath);
+        const existingManifest = await this.readLibraryManifest(location);
+        const nextManifest = {
+            ...existingManifest,
+            documents: existingManifest.documents.filter((doc) => doc.relativePath !== normalizedPath
+                && !doc.relativePath.startsWith(`${normalizedPath}/`)),
+        };
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.reconcileIndexedDocumentsForLocation(location);
+    }
+    async prepareRunLibraryMirror(params) {
+        this.deleteRunLibraryMirror(params.runId);
+        if (!params.workspacePath?.trim())
+            return;
+        const sharedLocation = this.getSharedMirrorLocation();
+        const personalLocation = params.personalEnabled && params.userId
+            ? await this.getOrCreatePersonalMirrorLocation(params.userId)
+            : null;
+        const sharedTree = sharedLocation ? await this.buildAuthorityMirrorTree(sharedLocation) : null;
+        const personalTree = personalLocation ? await this.buildAuthorityMirrorTree(personalLocation) : null;
+        await this.workspaceBroker.applyLibraryMirror(params.nodeId, params.workspacePath, {
+            shared: sharedTree,
+            personal: personalTree,
+        });
+        const now = Date.now();
+        this.db.prepare(`INSERT INTO library_run_mirrors(
+         run_id, conversation_id, user_id, node_id, workspace_path,
+         shared_baseline_json, personal_baseline_json, created_at, updated_at
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(run_id) DO UPDATE SET
+         conversation_id = excluded.conversation_id,
+         user_id = excluded.user_id,
+         node_id = excluded.node_id,
+         workspace_path = excluded.workspace_path,
+         shared_baseline_json = excluded.shared_baseline_json,
+         personal_baseline_json = excluded.personal_baseline_json,
+         updated_at = excluded.updated_at`).run(params.runId, params.conversationId, params.userId, params.nodeId, params.workspacePath, serializeLibraryMirrorBaseline(buildLibraryMirrorBaseline(sharedTree)), serializeLibraryMirrorBaseline(buildLibraryMirrorBaseline(personalTree)), now, now);
+    }
+    async finalizeRunLibraryMirror(params) {
+        const runMirror = this.db.prepare(`SELECT run_id as runId,
+              conversation_id as conversationId,
+              user_id as userId,
+              node_id as nodeId,
+              workspace_path as workspacePath,
+              shared_baseline_json as sharedBaselineJson,
+              personal_baseline_json as personalBaselineJson
+         FROM library_run_mirrors
+        WHERE run_id = ?`).get(params.runId);
+        if (!runMirror)
+            return { warnings: [] };
+        let snapshot;
+        try {
+            snapshot = await this.workspaceBroker.snapshotLibraryMirror(runMirror.nodeId, runMirror.workspacePath);
+        }
+        catch (error) {
+            this.deleteRunLibraryMirror(params.runId);
+            throw error;
+        }
+        const warnings = [];
+        const sharedLocation = this.getSharedMirrorLocation();
+        const personalLocation = runMirror.userId ? this.getLibraryLocation(runMirror.userId, 'personal') : null;
+        warnings.push(...await this.writeBackMirrorScope({
+            runId: params.runId,
+            scope: 'shared',
+            location: sharedLocation,
+            baseline: parseLibraryMirrorBaseline(runMirror.sharedBaselineJson),
+            current: snapshot.shared,
+        }));
+        warnings.push(...await this.writeBackMirrorScope({
+            runId: params.runId,
+            scope: 'personal',
+            location: personalLocation,
+            baseline: parseLibraryMirrorBaseline(runMirror.personalBaselineJson),
+            current: snapshot.personal,
+        }));
+        this.deleteRunLibraryMirror(params.runId);
+        return { warnings };
+    }
+    abortRunLibraryMirror(runId) {
+        this.deleteRunLibraryMirror(runId);
+    }
+    deleteRunLibraryMirror(runId) {
+        this.db.prepare('DELETE FROM library_run_mirrors WHERE run_id = ?').run(runId);
+    }
+    getSharedMirrorLocation() {
+        const config = this.getSharedConfig();
+        if (!config)
+            return null;
+        ensureLocalLibraryScaffold(config.libraryRootPath);
+        return {
+            scope: 'shared',
+            libraryRootPath: config.libraryRootPath,
+            nodeId: null,
+            agentName: SHARED_LIBRARY_AGENT_NAME,
+            sharedKey: config.sharedKey,
+        };
+    }
+    async getOrCreatePersonalMirrorLocation(userId) {
+        const existing = this.getLibraryLocation(userId, 'personal');
+        if (existing)
+            return existing;
+        const username = this.getUsernameForUserId(userId);
+        if (!username)
+            throw new Error(`Missing username for library mirror user ${userId}`);
+        const config = await this.ensureConfigForUser({ userId, username });
+        return {
+            scope: 'personal',
+            libraryRootPath: config.libraryRootPath,
+            nodeId: config.nodeId,
+            agentName: LIBRARY_CURATOR_AGENT_NAME,
+            userId,
+        };
+    }
+    async buildAuthorityMirrorTree(location) {
+        return {
+            files: await this.collectAuthorityMirrorFiles(location),
+        };
+    }
+    async writeBackMirrorScope(params) {
+        const baselineFiles = filterMirrorBaselineFiles(params.baseline);
+        const currentFiles = filterMirrorCurrentFiles(params.current);
+        if (baselineFiles.length === 0 && currentFiles.length === 0) {
+            return [];
+        }
+        if (!params.location) {
+            return [`Document sync warning: skipped ${params.scope} library writeback because the authority root is unavailable.`];
+        }
+        if (!params.current && baselineFiles.length > 0) {
+            return [
+                `Document sync warning: skipped ${params.scope} library writeback because the mirrored scope root disappeared during the run. Preserved the authority library unchanged.`,
+            ];
+        }
+        if (baselineFiles.length > 0 && currentFiles.length === 0) {
+            return [
+                `Document sync warning: skipped ${params.scope} library writeback because the run would remove every document in that scope. Preserved the authority library unchanged.`,
+            ];
+        }
+        const baselineMap = new Map(baselineFiles.map((file) => [file.path, file.sha256]));
+        const currentMap = new Map(currentFiles.map((file) => [file.path, file]));
+        const changedPaths = Array.from(new Set([
+            ...baselineMap.keys(),
+            ...currentMap.keys(),
+        ]))
+            .filter((relativePath) => baselineMap.get(relativePath) !== currentMap.get(relativePath)?.sha256)
+            .sort((left, right) => left.localeCompare(right));
+        const warnings = [];
+        for (const relativePath of changedPaths) {
+            const warning = await this.enqueueWriteback(buildWritebackKey(params.location, relativePath), async () => this.applyMirrorFileChange({
+                runId: params.runId,
+                location: params.location,
+                relativePath,
+                baselineSha: baselineMap.get(relativePath) ?? null,
+                currentFile: currentMap.get(relativePath) ?? null,
+            }));
+            if (warning)
+                warnings.push(warning);
+        }
+        await this.rebuildAuthoritySystemFiles(params.location);
+        await this.reconcileIndexedDocumentsForLocation(params.location);
+        return warnings;
+    }
+    async enqueueWriteback(key, work) {
+        const chained = (this.writebackChains.get(key) ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(work);
+        const barrier = chained.then(() => undefined, () => undefined);
+        this.writebackChains.set(key, barrier);
+        try {
+            return await chained;
+        }
+        finally {
+            if (this.writebackChains.get(key) === barrier) {
+                this.writebackChains.delete(key);
+            }
+        }
+    }
+    async applyMirrorFileChange(params) {
+        const authorityFile = await this.readAuthorityLibraryFile(params.location, params.relativePath);
+        const authoritySha = authorityFile ? sha256Text(authorityFile.content) : null;
+        if (authoritySha !== params.baselineSha) {
+            const conflictArtifactPath = await this.writeConflictArtifact({
+                runId: params.runId,
+                location: params.location,
+                relativePath: params.relativePath,
+                currentFile: params.currentFile,
+                baselineSha: params.baselineSha,
+                authoritySha,
+            });
+            return [
+                'Document sync warning:',
+                `skipped ${params.location.scope}/${params.relativePath} because the authority changed during the run.`,
+                conflictArtifactPath ? `Preserved the agent version at ${conflictArtifactPath}.` : 'Recorded the conflict metadata for manual review.',
+            ].join(' ');
+        }
+        if (!params.currentFile) {
+            await this.deleteAuthorityLibraryPath(params.location, params.relativePath);
+            return undefined;
+        }
+        if (sha256Text(params.currentFile.content.replace(/\r\n/g, '\n')) !== params.currentFile.sha256) {
+            throw new Error(`Invalid mirror snapshot checksum for ${params.location.scope}/${params.relativePath}`);
+        }
+        await this.writeAuthorityLibraryFile(params.location, params.relativePath, params.currentFile.content);
+        return undefined;
+    }
+    async writeAuthorityLibraryFile(location, relativePath, content) {
+        const { normalizedPath, absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        const nextContent = content.replace(/\r\n/g, '\n');
+        if (location.nodeId) {
+            await this.workspaceBroker.writeFile(location.nodeId, location.libraryRootPath, normalizedPath, nextContent, 'overwrite', { scaffold: false, agentName: location.agentName });
+        }
+        const fsPromises = await import('node:fs/promises');
+        await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fsPromises.writeFile(absolutePath, nextContent, 'utf8');
+    }
+    async rebuildAuthoritySystemFiles(location) {
+        ensureLocalLibraryScaffold(location.libraryRootPath);
+        const existingManifest = await this.readAuthorityLibraryManifestOrDefault(location);
+        const manifestByPath = new Map(existingManifest.documents.map((doc) => [normalizeLibraryRelativePath(doc.relativePath), doc]));
+        const markdownPaths = await this.collectAuthorityMirrorDocumentPaths(location);
+        const nextDocuments = [];
+        for (const relativePath of markdownPaths) {
+            const file = await this.readAuthorityLibraryFile(location, relativePath);
+            if (!file)
+                continue;
+            const existing = manifestByPath.get(relativePath);
+            nextDocuments.push({
+                title: extractLibraryDocumentTitle(file.content)
+                    ?? existing?.title?.trim()
+                    ?? path.posix.basename(relativePath, path.posix.extname(relativePath)),
+                category: (existing?.category ?? inferLibraryCategory(relativePath)).trim(),
+                topicPath: (existing?.topicPath ?? inferLibraryTopicPath(relativePath)).trim(),
+                relativePath,
+                summary: (existing?.summary ?? '').trim(),
+                sourceSavedItemIds: Array.isArray(existing?.sourceSavedItemIds)
+                    ? existing.sourceSavedItemIds.filter((id) => typeof id === 'string' && id.trim())
+                    : [],
+                notionPageId: existing?.notionPageId ?? null,
+                notionPageUrl: existing?.notionPageUrl ?? null,
+            });
+        }
+        const nextManifest = {
+            version: existingManifest.version || 1,
+            processedSavedItemIds: existingManifest.processedSavedItemIds ?? [],
+            documents: nextDocuments.sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
+        };
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.ensureAuthorityIndexFile(location);
+    }
+    async readAuthorityLibraryManifestOrDefault(location) {
+        const manifestFile = await this.readAuthorityLibraryFile(location, LIBRARY_MANIFEST_RELATIVE_PATH);
+        if (!manifestFile)
+            return buildDefaultLibraryManifest();
+        return parseLibraryManifest(manifestFile.content) ?? buildDefaultLibraryManifest();
+    }
+    async ensureAuthorityIndexFile(location) {
+        const indexFile = await this.readAuthorityLibraryFile(location, 'INDEX.md');
+        const nextContent = indexFile?.content?.trim()
+            ? indexFile.content.replace(/\r\n/g, '\n')
+            : buildDefaultLibraryIndexContent();
+        await this.writeAuthorityLibraryFile(location, 'INDEX.md', nextContent);
+    }
+    async collectAuthorityMirrorFiles(location) {
+        ensureLocalLibraryScaffold(location.libraryRootPath);
+        if (!location.nodeId) {
+            return collectLibraryMirrorFiles(location.libraryRootPath);
+        }
+        return this.collectRemoteLibraryMirrorFiles(location, '');
+    }
+    async collectRemoteLibraryMirrorFiles(location, relativePath) {
+        const entries = await this.listAllRemoteLibraryEntries(location, relativePath);
+        const files = [];
+        for (const entry of entries) {
+            if (entry.isSymlink)
+                continue;
+            if (shouldSkipLibraryMirrorEntry(entry.path, entry.kind))
+                continue;
+            if (entry.kind === 'directory') {
+                files.push(...await this.collectRemoteLibraryMirrorFiles(location, entry.path));
+                continue;
+            }
+            const file = await this.readAuthorityLibraryFile(location, entry.path);
+            if (!file)
+                continue;
+            files.push({
+                path: entry.path,
+                content: file.content,
+                sha256: sha256Text(file.content),
+            });
+        }
+        return files.sort((left, right) => left.path.localeCompare(right.path));
+    }
+    async listAllRemoteLibraryEntries(location, relativePath) {
+        const entries = [];
+        let cursor = null;
+        do {
+            const page = await this.workspaceBroker.listDirectory(location.nodeId, location.libraryRootPath, relativePath, {
+                scaffold: false,
+                agentName: location.agentName,
+                ...(cursor ? { cursor } : {}),
+                limit: 1000,
+            });
+            entries.push(...page.entries.map((entry) => ({
+                name: entry.name,
+                path: entry.path,
+                kind: entry.kind,
+                ...(entry.isSymlink ? { isSymlink: true } : {}),
+            })));
+            cursor = page.directoryPage?.nextCursor ?? null;
+            if (!page.directoryPage?.hasMore)
+                break;
+        } while (cursor);
+        entries.sort((left, right) => {
+            if (left.kind !== right.kind)
+                return left.kind === 'directory' ? -1 : 1;
+            return left.name.localeCompare(right.name);
+        });
+        return entries;
+    }
+    async collectAuthorityMirrorDocumentPaths(location) {
+        if (!location.nodeId) {
+            return collectAuthorityMirrorDocumentPaths(location.libraryRootPath);
+        }
+        return collectLibraryFilePaths(await this.buildDocumentTreeForLocation(location))
+            .filter((relativePath) => isMirrorWritableLibraryDocumentPath(relativePath))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    async readAuthorityLibraryFile(location, relativePath) {
+        if (!location.nodeId) {
+            return readAuthorityLibraryFile(location.libraryRootPath, relativePath);
+        }
+        try {
+            const file = await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, relativePath, {
+                scaffold: false,
+                agentName: location.agentName,
+            });
+            return {
+                content: file.content.replace(/\r\n/g, '\n'),
+            };
+        }
+        catch (error) {
+            if (isLibraryPathMissingError(error))
+                return null;
+            throw error;
+        }
+    }
+    async getAuthorityEntryKind(location, relativePath) {
+        const normalizedPath = normalizeLibraryRelativePath(relativePath);
+        if (!location.nodeId) {
+            return getAuthorityEntryKind(location.libraryRootPath, normalizedPath);
+        }
+        try {
+            await this.workspaceBroker.listDirectory(location.nodeId, location.libraryRootPath, normalizedPath, {
+                scaffold: false,
+                agentName: location.agentName,
+                limit: 1,
+            });
+            return 'directory';
+        }
+        catch (error) {
+            if (!isLibraryPathMissingError(error) && !isLibraryPathNotDirectoryError(error)) {
+                throw error;
+            }
+        }
+        try {
+            await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, normalizedPath, {
+                scaffold: false,
+                agentName: location.agentName,
+            });
+            return 'file';
+        }
+        catch (error) {
+            if (isLibraryPathMissingError(error))
+                return null;
+            if (isLibraryPathDirectoryReadError(error))
+                return 'directory';
+            throw error;
+        }
+    }
+    async deleteAuthorityLibraryPath(location, relativePath) {
+        if (location.nodeId) {
+            await this.workspaceBroker.deleteLibraryPath(location.nodeId, location.libraryRootPath, relativePath, { recursive: false, agentName: location.agentName });
+        }
+        await deleteAuthorityLibraryPath(location.libraryRootPath, relativePath);
+    }
+    async syncRemoteAuthorityRenameToLocalCache(location, previousRelativePath, nextRelativePath, kind) {
+        if (!location.nodeId)
+            return;
+        if (kind === 'file') {
+            const content = await this.captureRemoteAuthorityFileSnapshot(location, nextRelativePath);
+            await deleteAuthorityLibraryPath(location.libraryRootPath, previousRelativePath);
+            await this.writeRemoteAuthorityFileSnapshotToLocalCache(location.libraryRootPath, nextRelativePath, content);
+            return;
+        }
+        const snapshot = await this.captureRemoteAuthorityDirectorySnapshot(location, nextRelativePath);
+        await deleteAuthorityLibraryPath(location.libraryRootPath, previousRelativePath);
+        await this.writeRemoteAuthorityDirectorySnapshotToLocalCache(location.libraryRootPath, nextRelativePath, snapshot);
+    }
+    async recoverCommittedRemoteAuthorityRename(location, previousRelativePath, nextRelativePath, kind) {
+        await this.syncRemoteAuthorityRenameToLocalCache(location, previousRelativePath, nextRelativePath, kind);
+        await this.finalizeAuthorityRename(location, previousRelativePath, nextRelativePath, kind);
+    }
+    async didRemoteAuthorityRenameCommit(location, previousRelativePath, nextRelativePath, kind) {
+        try {
+            const [previousKind, nextKind] = await Promise.all([
+                this.getAuthorityEntryKind(location, previousRelativePath),
+                this.getAuthorityEntryKind(location, nextRelativePath),
+            ]);
+            return previousKind === null && nextKind === kind;
+        }
+        catch {
+            return false;
+        }
+    }
+    async captureRemoteAuthorityFileSnapshot(location, relativePath) {
+        if (!location.nodeId)
+            throw new Error('Missing node-backed authority');
+        const normalizedPath = normalizeLibraryRelativePath(relativePath);
+        const file = await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, normalizedPath, {
+            scaffold: false,
+            agentName: location.agentName,
+        });
+        return file.content.replace(/\r\n/g, '\n');
+    }
+    async captureRemoteAuthorityDirectorySnapshot(location, relativePath) {
+        if (!location.nodeId)
+            throw new Error('Missing node-backed authority');
+        const normalizedPath = normalizeLibraryRelativePath(relativePath);
+        const directories = [normalizedPath];
+        const files = [];
+        const walk = async (directoryPath) => {
+            const entries = await this.listAllRemoteLibraryEntries(location, directoryPath);
+            for (const entry of entries) {
+                if (entry.isSymlink)
+                    continue;
+                const entryPath = normalizeLibraryRelativePath(entry.path);
+                if (entry.kind === 'directory') {
+                    directories.push(entryPath);
+                    await walk(entryPath);
+                    continue;
+                }
+                const file = await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, entryPath, {
+                    scaffold: false,
+                    agentName: location.agentName,
+                });
+                files.push({
+                    path: entryPath,
+                    content: file.content.replace(/\r\n/g, '\n'),
+                });
+            }
+        };
+        await walk(normalizedPath);
+        directories.sort((left, right) => left.localeCompare(right));
+        files.sort((left, right) => left.path.localeCompare(right.path));
+        return { directories, files };
+    }
+    async writeRemoteAuthorityFileSnapshotToLocalCache(libraryRootPath, relativePath, content) {
+        const normalizedPath = normalizeLibraryRelativePath(relativePath);
+        const existingKind = await getAuthorityEntryKind(libraryRootPath, normalizedPath);
+        if (existingKind === 'directory') {
+            await deleteAuthorityLibraryPath(libraryRootPath, normalizedPath);
+        }
+        const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, normalizedPath);
+        const fsPromises = await import('node:fs/promises');
+        await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fsPromises.writeFile(absolutePath, content, 'utf8');
+    }
+    async writeRemoteAuthorityDirectorySnapshotToLocalCache(libraryRootPath, relativePath, snapshot) {
+        const normalizedRoot = normalizeLibraryRelativePath(relativePath);
+        const existingRootKind = await getAuthorityEntryKind(libraryRootPath, normalizedRoot);
+        if (existingRootKind === 'file') {
+            await deleteAuthorityLibraryPath(libraryRootPath, normalizedRoot);
+        }
+        const existingEntries = await collectAuthoritySubtreeEntries(libraryRootPath, normalizedRoot);
+        const remoteDirectorySet = new Set(snapshot.directories);
+        const remoteFileSet = new Set(snapshot.files.map((file) => file.path));
+        for (const existingFile of existingEntries.files) {
+            if (!remoteFileSet.has(existingFile)) {
+                await deleteAuthorityLibraryPath(libraryRootPath, existingFile);
+            }
+        }
+        for (const existingDirectory of existingEntries.directories.sort((left, right) => right.length - left.length)) {
+            if (existingDirectory === normalizedRoot)
+                continue;
+            if (!remoteDirectorySet.has(existingDirectory)) {
+                await deleteAuthorityLibraryPath(libraryRootPath, existingDirectory);
+            }
+        }
+        const fsPromises = await import('node:fs/promises');
+        for (const directoryPath of snapshot.directories.sort((left, right) => left.length - right.length)) {
+            const directoryKind = await getAuthorityEntryKind(libraryRootPath, directoryPath);
+            if (directoryKind === 'file') {
+                await deleteAuthorityLibraryPath(libraryRootPath, directoryPath);
+            }
+            const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, directoryPath);
+            await fsPromises.mkdir(absolutePath, { recursive: true });
+        }
+        for (const file of snapshot.files) {
+            const existingKind = await getAuthorityEntryKind(libraryRootPath, file.path);
+            if (existingKind === 'directory') {
+                await deleteAuthorityLibraryPath(libraryRootPath, file.path);
+            }
+            const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, file.path);
+            await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fsPromises.writeFile(absolutePath, file.content, 'utf8');
+        }
+    }
+    async finalizeAuthorityRename(location, previousRelativePath, nextRelativePath, kind) {
+        const existingManifest = await this.readLibraryManifest(location);
+        const nextManifest = renameLibraryManifestPaths(existingManifest, previousRelativePath, nextRelativePath, kind);
+        await this.writeLibraryManifest(location, nextManifest);
+        await this.reconcileIndexedDocumentsForLocation(location);
+    }
+    async writeConflictArtifact(params) {
+        const scopeDirectory = params.location.scope;
+        const ownerSegment = params.location.scope === 'shared'
+            ? (params.location.sharedKey ?? SHARED_LIBRARY_KEY)
+            : (this.getUsernameForUserId(params.location.userId ?? '') ?? params.location.userId ?? 'user');
+        const baseDirectory = path.join(this.workspaceRoot, '.library-curator-conflicts', scopeDirectory, sanitizeConflictPathSegment(ownerSegment), params.runId);
+        const targetRelativePath = params.currentFile
+            ? params.relativePath
+            : `${params.relativePath}.delete-conflict.json`;
+        const targetPath = path.join(baseDirectory, targetRelativePath);
+        const fsPromises = await import('node:fs/promises');
+        await fsPromises.mkdir(path.dirname(targetPath), { recursive: true });
+        const content = params.currentFile
+            ? params.currentFile.content.replace(/\r\n/g, '\n')
+            : JSON.stringify({
+                kind: 'delete_conflict',
+                relativePath: params.relativePath,
+                baselineSha256: params.baselineSha,
+                authoritySha256: params.authoritySha,
+                runId: params.runId,
+            }, null, 2) + '\n';
+        await fsPromises.writeFile(targetPath, content, 'utf8');
+        return targetPath;
+    }
+    getLibraryLocation(userId, scope) {
+        if (scope === 'shared') {
+            const config = this.getSharedConfig();
+            if (!config)
+                return null;
+            return {
+                scope,
+                libraryRootPath: config.libraryRootPath,
+                nodeId: null,
+                agentName: SHARED_LIBRARY_AGENT_NAME,
+                sharedKey: config.sharedKey,
+            };
+        }
+        const config = this.getConfig(userId);
+        if (!config)
+            return null;
+        return {
+            scope,
+            libraryRootPath: config.libraryRootPath,
+            nodeId: config.nodeId,
+            agentName: LIBRARY_CURATOR_AGENT_NAME,
+            userId,
+        };
+    }
+    getRequiredLibraryLocation(userId, scope) {
+        const location = this.getLibraryLocation(userId, scope);
+        if (location)
+            return location;
+        throw new Error(scope === 'shared' ? 'Shared library not configured' : 'Library config not found');
+    }
+    async buildDocumentTreeForLocation(location) {
+        if (location.nodeId) {
+            return this.listRemoteTree(location, '');
+        }
+        return this.listLocalTree(location, '');
+    }
+    async readLibraryFileFromLocation(location, relativePath) {
+        const { normalizedPath, absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, relativePath);
+        if (location.nodeId) {
+            const result = await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, normalizedPath, {
+                scaffold: false,
+                agentName: location.agentName,
+            });
+            return {
+                content: result.content,
+                mimeType: normalizedPath.endsWith('.md') ? 'text/markdown' : 'text/plain',
+            };
+        }
+        const fsPromises = await import('node:fs/promises');
+        const content = await fsPromises.readFile(absolutePath, 'utf8');
+        return {
+            content,
+            mimeType: normalizedPath.endsWith('.md') ? 'text/markdown' : 'text/plain',
+        };
+    }
+    async listRemoteTree(location, relativePath) {
+        const result = await this.workspaceBroker.listDirectory(location.nodeId, location.libraryRootPath, relativePath, {
+            scaffold: false,
+            agentName: location.agentName,
+        });
+        const nodes = [];
+        for (const entry of result.entries) {
+            if (shouldIgnoreLibraryEntry(relativePath, entry.name, entry.kind))
+                continue;
+            if (entry.kind === 'directory') {
+                const childPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                const children = await this.listRemoteTree(location, childPath);
+                nodes.push({ scope: location.scope, name: entry.name, path: childPath, kind: 'directory', children });
+                continue;
+            }
+            nodes.push({
+                scope: location.scope,
+                name: entry.name,
+                path: relativePath ? `${relativePath}/${entry.name}` : entry.name,
+                kind: 'file',
+            });
+        }
+        return sortLibraryTreeNodes(nodes);
+    }
+    async listLocalTree(location, relativePath) {
+        const fsPromises = await import('node:fs/promises');
+        const absolutePath = relativePath ? path.join(location.libraryRootPath, relativePath) : location.libraryRootPath;
+        const entries = await fsPromises.readdir(absolutePath, { withFileTypes: true });
+        const nodes = [];
+        for (const entry of entries) {
+            const kind = entry.isDirectory() ? 'directory' : 'file';
+            if (shouldIgnoreLibraryEntry(relativePath, entry.name, kind))
+                continue;
+            if (entry.isDirectory()) {
+                const childPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                const children = await this.listLocalTree(location, childPath);
+                nodes.push({ scope: location.scope, name: entry.name, path: childPath, kind: 'directory', children });
+                continue;
+            }
+            nodes.push({
+                scope: location.scope,
+                name: entry.name,
+                path: relativePath ? `${relativePath}/${entry.name}` : entry.name,
+                kind: 'file',
+            });
+        }
+        return sortLibraryTreeNodes(nodes);
+    }
+    async readLibraryManifest(location) {
+        let manifestRaw = '';
+        if (location.nodeId) {
+            try {
+                manifestRaw = (await this.workspaceBroker.readFile(location.nodeId, location.libraryRootPath, LIBRARY_MANIFEST_RELATIVE_PATH, {
+                    scaffold: false,
+                    agentName: location.agentName,
+                })).content;
+            }
+            catch (error) {
+                if (isLibraryPathMissingError(error))
+                    return buildDefaultLibraryManifest();
+                throw new Error(`Failed to read library manifest: ${String(error?.message ?? error)}`);
+            }
+        }
+        else {
+            const fsPromises = await import('node:fs/promises');
+            const { absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, LIBRARY_MANIFEST_RELATIVE_PATH);
+            try {
+                manifestRaw = await fsPromises.readFile(absolutePath, 'utf8');
+            }
+            catch (error) {
+                if (isLibraryPathMissingError(error))
+                    return buildDefaultLibraryManifest();
+                throw new Error(`Failed to read library manifest: ${String(error?.message ?? error)}`);
+            }
+        }
+        const manifest = parseLibraryManifest(manifestRaw);
+        if (!manifest)
+            throw new Error('Invalid library manifest');
+        return manifest;
+    }
+    async writeLibraryManifest(location, manifest) {
+        const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+        if (location.nodeId) {
+            await this.workspaceBroker.writeFile(location.nodeId, location.libraryRootPath, LIBRARY_MANIFEST_RELATIVE_PATH, serialized, 'overwrite', { scaffold: false, agentName: location.agentName });
+        }
+        const fsPromises = await import('node:fs/promises');
+        const { absolutePath } = resolveLibraryAbsolutePath(location.libraryRootPath, LIBRARY_MANIFEST_RELATIVE_PATH);
+        await fsPromises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fsPromises.writeFile(absolutePath, serialized, 'utf8');
+    }
+    queryIndexedDocumentsForLocation(location, category) {
+        const normalizedCategory = category?.trim();
+        const tableName = location.scope === 'shared' ? 'shared_library_documents' : 'library_documents';
+        const ownerColumn = location.scope === 'shared' ? 'shared_key' : 'user_id';
+        const ownerValue = location.scope === 'shared' ? location.sharedKey : location.userId;
+        const rows = normalizedCategory
+            ? this.db.prepare(`SELECT id, ${location.scope === 'shared' ? 'NULL' : 'user_id'} as userId, title, category, topic_path as topicPath,
+                relative_path as relativePath, summary, source_saved_item_ids as sourceSavedItemIdsJson,
+                created_at as createdAt, updated_at as updatedAt, last_run_id as lastRunId,
+                notion_page_id as notionPageId, notion_page_url as notionPageUrl
+         FROM ${tableName}
+         WHERE ${ownerColumn} = ? AND category = ?
+         ORDER BY updated_at DESC`).all(ownerValue, normalizedCategory)
+            : this.db.prepare(`SELECT id, ${location.scope === 'shared' ? 'NULL' : 'user_id'} as userId, title, category, topic_path as topicPath,
+                relative_path as relativePath, summary, source_saved_item_ids as sourceSavedItemIdsJson,
+                created_at as createdAt, updated_at as updatedAt, last_run_id as lastRunId,
+                notion_page_id as notionPageId, notion_page_url as notionPageUrl
+         FROM ${tableName}
+         WHERE ${ownerColumn} = ?
+         ORDER BY category COLLATE NOCASE ASC, topic_path COLLATE NOCASE ASC, updated_at DESC`).all(ownerValue);
+        return rows.map((row) => mapLibraryDocumentRow(row, location.scope));
+    }
+    async reconcileIndexedDocumentsForLocation(location, lastRunId) {
+        ensureLocalLibraryScaffold(location.libraryRootPath);
+        const tree = await this.buildDocumentTreeForLocation(location);
+        const markdownPaths = collectLibraryFilePaths(tree);
+        const manifest = await this.readLibraryManifest(location);
+        const manifestByPath = new Map(manifest.documents.map((doc) => [doc.relativePath.trim().replace(/^\/+/, ''), doc]));
+        const existingDocs = this.queryIndexedDocumentsForLocation(location);
+        const existingByPath = new Map(existingDocs.map((doc) => [doc.relativePath, doc]));
+        const now = Date.now();
+        const tableName = location.scope === 'shared' ? 'shared_library_documents' : 'library_documents';
+        const ownerColumn = location.scope === 'shared' ? 'shared_key' : 'user_id';
+        const ownerValue = location.scope === 'shared' ? location.sharedKey : location.userId;
+        const upsert = this.db.prepare(`INSERT INTO ${tableName}(
+         id, ${ownerColumn}, title, category, topic_path, relative_path, summary,
+         source_saved_item_ids, created_at, updated_at, last_run_id,
+         notion_page_id, notion_page_url
+       ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(${ownerColumn}, relative_path) DO UPDATE SET
+         title = excluded.title,
+         category = excluded.category,
+         topic_path = excluded.topic_path,
+         summary = excluded.summary,
+         source_saved_item_ids = excluded.source_saved_item_ids,
+         updated_at = excluded.updated_at,
+         last_run_id = excluded.last_run_id,
+         notion_page_id = excluded.notion_page_id,
+         notion_page_url = excluded.notion_page_url`);
+        const deleteStale = markdownPaths.length > 0
+            ? this.db.prepare(`DELETE FROM ${tableName}
+         WHERE ${ownerColumn} = ?
+           AND relative_path NOT IN (${markdownPaths.map(() => '?').join(', ')})`)
+            : this.db.prepare(`DELETE FROM ${tableName} WHERE ${ownerColumn} = ?`);
+        for (const relativePath of markdownPaths) {
+            const file = await this.readLibraryFileFromLocation(location, relativePath);
+            const existing = existingByPath.get(relativePath);
+            const manifestDoc = manifestByPath.get(relativePath);
+            const title = extractLibraryDocumentTitle(file.content)
+                ?? manifestDoc?.title?.trim()
+                ?? existing?.title
+                ?? path.posix.basename(relativePath, path.posix.extname(relativePath));
+            const categoryValue = (manifestDoc?.category ?? existing?.category ?? inferLibraryCategory(relativePath)).trim();
+            const topicPathValue = (manifestDoc?.topicPath ?? existing?.topicPath ?? inferLibraryTopicPath(relativePath)).trim();
+            const summaryValue = (manifestDoc?.summary ?? existing?.summary ?? '').trim();
+            const sourceSavedItemIds = Array.isArray(manifestDoc?.sourceSavedItemIds)
+                ? manifestDoc?.sourceSavedItemIds.filter((id) => typeof id === 'string' && id.trim())
+                : (existing?.sourceSavedItemIds ?? []);
+            const notionPageId = manifestDoc?.notionPageId ?? existing?.notionPageId ?? null;
+            const notionPageUrl = manifestDoc?.notionPageUrl ?? existing?.notionPageUrl ?? null;
+            const metadataChanged = !existing
+                || existing.title !== title
+                || existing.category !== categoryValue
+                || existing.topicPath !== topicPathValue
+                || existing.summary !== summaryValue
+                || JSON.stringify(existing.sourceSavedItemIds) !== JSON.stringify(sourceSavedItemIds)
+                || existing.notionPageId !== notionPageId
+                || existing.notionPageUrl !== notionPageUrl;
+            upsert.run(existing?.id ?? randomUUID(), ownerValue, title, categoryValue, topicPathValue, relativePath, summaryValue, JSON.stringify(sourceSavedItemIds), existing?.createdAt ?? now, metadataChanged ? now : existing.updatedAt, typeof lastRunId === 'string' ? lastRunId : (existing?.lastRunId ?? null), notionPageId, notionPageUrl);
+        }
+        if (markdownPaths.length > 0) {
+            deleteStale.run(ownerValue, ...markdownPaths);
+        }
+        else {
+            deleteStale.run(ownerValue);
+        }
+    }
+    getCuratorAgent(userId) {
+        const config = this.getConfig(userId);
+        if (!config || typeof this.conversationManager.getAgent !== 'function')
+            return null;
+        return this.conversationManager.getAgent(config.curatorAgentId);
+    }
+    updateCuratorAgentRuntime(userId, patch) {
+        const config = this.getConfig(userId);
+        if (!config)
+            return null;
+        const existing = this.conversationManager.getAgent(config.curatorAgentId);
+        if (!existing)
+            return null;
+        const nextModel = Object.prototype.hasOwnProperty.call(patch, 'model')
+            ? patch.model?.trim() || null
+            : existing.model ?? null;
+        const nextReasoning = Object.prototype.hasOwnProperty.call(patch, 'reasoningEffort')
+            ? patch.reasoningEffort?.trim() || null
+            : existing.reasoningEffort ?? null;
+        const nextEnvVars = Object.prototype.hasOwnProperty.call(patch, 'envVars')
+            ? patch.envVars ?? {}
+            : existing.envVars ?? {};
+        const envVarsJson = Object.keys(nextEnvVars).length > 0 ? JSON.stringify(nextEnvVars) : null;
+        const now = Date.now();
+        this.db.prepare(`UPDATE agents
+          SET model = ?,
+              reasoning_effort = ?,
+              env_vars = ?,
+              disabled_tool_kinds = ?,
+              updated_at = ?
+        WHERE agent_id = ?`).run(nextModel, nextReasoning, envVarsJson, CURATOR_DISABLED_TOOL_KINDS_JSON, now, config.curatorAgentId);
+        this.db.prepare(`UPDATE conversations
+          SET env_vars = ?,
+              updated_at = ?
+        WHERE agent_id = ?`).run(envVarsJson, now, config.curatorAgentId);
+        const updatedAgent = this.conversationManager.getAgent(config.curatorAgentId);
+        this.syncPlatformAgentInstance(this.getConfig(userId) ?? config);
+        return updatedAgent;
+    }
+    openCuratorConversation(userId, mode = 'debug') {
+        const config = this.getConfig(userId);
+        if (!config)
+            return null;
+        const title = getPlatformAgentConversationTitle({
+            definitionId: 'library_curator',
+            mode,
+        });
+        return this.conversationManager.openNamedAgentPrimaryThread?.({
+            agentId: config.curatorAgentId,
+            title,
+            userId,
+            legacyTitles: mode === 'debug'
+                ? getPlatformAgentLegacyConversationTitles('library_curator')
+                : undefined,
+        }) ?? this.conversationManager.openAgentThread(config.curatorAgentId, userId);
+    }
+    buildOrganizePrompt(params) {
+        const categoriesLine = params.config.categories.length > 0
+            ? params.config.categories.join(', ')
+            : '(none — infer sensible categories and record them in the manifest)';
+        const itemsBlock = params.savedItems.map((item, index) => [
+            `### Saved Item ${index + 1}`,
+            `- id: ${item.id}`,
+            `- sender: ${item.senderName || 'Unknown'}`,
+            `- source: ${item.sourceKind ?? inferSavedItemSourceKind(item.contextUrl)}`,
+            `- savedAt: ${new Date(item.createdAt).toISOString()}`,
+            `- contextUrl: ${item.contextUrl || '(none)'}`,
+            '',
+            item.content.trim(),
+        ].join('\n')).join('\n\n');
+        return [
+            '# Library organize run',
+            '',
+            'Organize the saved inbox items below into structured markdown documents under this workspace.',
+            '',
+            '## User categories',
+            categoriesLine,
+            '',
+            '## Rules',
+            '- Write or update markdown files under `{category}/{topic}/...` paths.',
+            '- Prefer updating existing markdown files when they already fit the saved items.',
+            '- Prefer following the user\'s existing folder and file structure before creating new documents.',
+            '- Only create a new markdown document when no suitable existing document fits.',
+            '- Do not rename or move existing user-created documents unless the user explicitly asks.',
+            '- Merge related items into cohesive documents; update existing docs when appropriate.',
+            '- Update `.meta/manifest.json` with all documents (title, category, topicPath, relativePath, summary, sourceSavedItemIds).',
+            '- Include every processed saved item id in `processedSavedItemIds`.',
+            '- Do not delete DB records; only write files and manifest.',
+            '',
+            '## Saved inbox items',
+            itemsBlock,
+        ].join('\n');
+    }
+    async dispatchOrganizeRun(params) {
+        const config = await this.ensureConfigForUser({ userId: params.userId, username: params.username });
+        const runtimeBlockReason = this.getCuratorRuntimeBlockReason(config);
+        if (runtimeBlockReason) {
+            return { ok: true, skipped: true, reason: runtimeBlockReason };
+        }
+        if (!config.enabled) {
+            return { ok: true, skipped: true, reason: 'Library curator is disabled' };
+        }
+        const runningRun = this.db.prepare(`SELECT run_id as runId FROM library_curator_runs
+       WHERE user_id = ? AND status = 'running'
+       ORDER BY created_at DESC LIMIT 1`).get(params.userId);
+        if (runningRun) {
+            return { ok: true, skipped: true, queued: true, runId: runningRun.runId, reason: 'Library curator run already in progress' };
+        }
+        const inboxItems = this.listInboxSavedItems(params.userId);
+        if (inboxItems.length === 0) {
+            const now = Date.now();
+            this.db.prepare(`UPDATE library_curator_configs SET next_run_at = ?, updated_at = ? WHERE user_id = ?`).run(now + config.scheduleIntervalMs, now, params.userId);
+            this.syncPlatformAgentInstance(this.getConfig(params.userId) ?? config, { overwriteCanonical: true });
+            return { ok: true, skipped: true, reason: 'No inbox items to organize' };
+        }
+        const conversation = this.openCuratorConversation(params.userId, 'workflow');
+        if (!conversation)
+            return { ok: false, error: 'Failed to open curator conversation' };
+        const savedItemIds = inboxItems.map((item) => item.id);
+        const prompt = this.buildOrganizePrompt({ config, savedItems: inboxItems });
+        const activationMetadata = {
+            platformRun: {
+                definitionId: 'library_curator',
+                workflowType: 'library_curate',
+                mode: 'workflow',
+            },
+            suppressReplyContract: true,
+        };
+        const result = await this.conversationManager.submitPrompt(conversation.id, prompt, {
+            recordAsUserMessage: false,
+            activationMetadata,
+            suppressReplyContract: true,
+        });
+        if (!result.runId) {
+            return { ok: false, error: 'Failed to start library organize run', queued: result.queued };
+        }
+        const now = Date.now();
+        this.db.prepare(`INSERT INTO library_curator_runs(run_id, user_id, saved_item_ids_json, status, created_at)
+       VALUES(?, ?, ?, 'running', ?)`).run(result.runId, params.userId, JSON.stringify(savedItemIds), now);
+        this.db.prepare(`UPDATE library_curator_configs SET last_run_at = ?, updated_at = ? WHERE user_id = ?`).run(now, now, params.userId);
+        this.syncPlatformAgentInstance(this.getConfig(params.userId) ?? config, { overwriteCanonical: true });
+        await this.reconcileRunStateAfterInsert(result.runId, params.userId);
+        return { ok: true, runId: result.runId, queued: result.queued };
+    }
+    async reconcileRunStateAfterInsert(runId, userId) {
+        const runRow = this.db.prepare(`SELECT ended_at as endedAt, stop_reason as stopReason, error
+       FROM runs
+       WHERE run_id = ?`).get(runId);
+        if (!runRow?.endedAt)
+            return;
+        await this.finalizeOrganizeRun({
+            runId,
+            userId,
+            error: getLibraryCuratorTerminalError(runRow.stopReason, runRow.error),
+        });
+    }
+    async finalizeOrganizeRun(params) {
+        const runRow = this.db.prepare(`SELECT run_id as runId, user_id as userId, saved_item_ids_json as savedItemIdsJson, status
+       FROM library_curator_runs WHERE run_id = ?`).get(params.runId);
+        if (!runRow || runRow.status !== 'running')
+            return;
+        const now = Date.now();
+        if (params.error) {
+            this.db.prepare(`UPDATE library_curator_runs SET status = 'failed', completed_at = ?, error = ? WHERE run_id = ?`).run(now, params.error, params.runId);
+            this.scheduleNextRun(params.userId, now);
+            return;
+        }
+        try {
+            const manifestProcessedIds = await this.indexManifestForUser({ userId: params.userId, runId: params.runId });
+            const runSavedItemIds = new Set(parseStringArrayJson(runRow.savedItemIdsJson));
+            const processedSavedItemIds = manifestProcessedIds.filter((id) => runSavedItemIds.has(id));
+            if (processedSavedItemIds.length > 0) {
+                const markProcessed = this.db.prepare(`UPDATE saved_items
+              SET process_status = 'processed', processed_at = ?, processed_run_id = ?
+            WHERE user_id = ? AND id = ?`);
+                for (const savedItemId of processedSavedItemIds) {
+                    markProcessed.run(now, params.runId, params.userId, savedItemId);
+                }
+            }
+            this.db.prepare(`UPDATE library_curator_runs SET status = 'completed', completed_at = ? WHERE run_id = ?`).run(now, params.runId);
+        }
+        catch (error) {
+            this.db.prepare(`UPDATE library_curator_runs SET status = 'failed', completed_at = ?, error = ? WHERE run_id = ?`).run(now, String(error?.message ?? error), params.runId);
+        }
+        this.scheduleNextRun(params.userId, now);
+    }
+    async indexManifestForUser(params) {
+        const location = this.getRequiredLibraryLocation(params.userId, 'personal');
+        const manifest = await this.readLibraryManifest(location);
+        await this.reconcileIndexedDocumentsForLocation(location, params.runId);
+        return manifest.processedSavedItemIds ?? [];
+    }
+    listDueConfigs(now) {
+        const rows = this.db.prepare(`SELECT user_id as userId, curator_agent_id as curatorAgentId, node_id as nodeId,
+              library_root_path as libraryRootPath, schedule_interval_ms as scheduleIntervalMs,
+              categories_json as categoriesJson, last_run_at as lastRunAt, next_run_at as nextRunAt,
+              enabled, created_at as createdAt, updated_at as updatedAt
+       FROM library_curator_configs
+       WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?`).all(now);
+        return rows.map(mapConfigRow);
+    }
+    getUsernameForUserId(userId) {
+        const row = this.db.prepare(`SELECT username FROM users WHERE id = ?`).get(userId);
+        return row?.username?.trim() || null;
+    }
+    scheduleNextRun(userId, now) {
+        const config = this.getConfig(userId);
+        if (!config)
+            return;
+        this.db.prepare(`UPDATE library_curator_configs SET next_run_at = ?, updated_at = ? WHERE user_id = ?`).run(now + config.scheduleIntervalMs, now, userId);
+        this.syncPlatformAgentInstance(this.getConfig(userId) ?? config, { overwriteCanonical: true });
+    }
+    getCuratorRuntimeBlockReason(config) {
+        try {
+            const row = this.db.prepare(`SELECT pai.enabled as instanceEnabled,
+                pai.deleted_at as deletedAt,
+                pad.enabled as definitionEnabled
+           FROM platform_agent_instances pai
+           JOIN platform_agent_definitions pad ON pad.definition_id = pai.definition_id
+          WHERE pai.user_id = ?
+            AND pai.definition_id = 'library_curator'
+            AND pai.agent_id = ?
+          LIMIT 1`).get(config.userId, config.curatorAgentId);
+            if (!row)
+                return null;
+            if (row.deletedAt != null)
+                return 'Library curator has been deleted';
+            if (row.definitionEnabled !== 1)
+                return 'Library curator definition is disabled';
+            if (row.instanceEnabled !== 1)
+                return 'Library curator is disabled';
+        }
+        catch {
+            // Older schemas only have the legacy curator config.
+        }
+        return null;
+    }
+}
+function parseStringArrayJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((item) => typeof item === 'string' && item.trim().length > 0).map((item) => item.trim());
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeLibraryRelativePath(rawPath) {
+    const trimmed = rawPath.trim().replace(/\\/g, '/');
+    const normalized = path.posix.normalize(trimmed).replace(/^\/+/, '').replace(/\/+$/, '');
+    if (!normalized
+        || normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || normalized.includes('/../')) {
+        throw new Error('Invalid library path');
+    }
+    return normalized;
+}
+function resolveLibraryAbsolutePath(libraryRootPath, relativePath) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const libraryRoot = path.resolve(libraryRootPath);
+    const absolutePath = path.resolve(libraryRoot, normalizedPath);
+    if (absolutePath !== libraryRoot && !absolutePath.startsWith(`${libraryRoot}${path.sep}`)) {
+        throw new Error('Invalid library path');
+    }
+    return { normalizedPath, libraryRoot, absolutePath };
+}
+function assertLibraryWritePathAllowed(relativePath) {
+    if (relativePath === '.meta' || relativePath.startsWith('.meta/')) {
+        throw new Error('Cannot modify reserved library metadata paths');
+    }
+    if (relativePath === 'INDEX.md') {
+        throw new Error('Cannot modify reserved library index file');
+    }
+    if (isReservedLibraryWorkspacePath(relativePath)) {
+        throw new Error('Cannot modify reserved library workspace paths');
+    }
+    if (relativePath.split('/').some((segment) => segment.startsWith('.'))) {
+        throw new Error('Hidden library paths are not allowed');
+    }
+}
+function isReservedLibraryWorkspaceTopLevelEntry(entryName) {
+    return RESERVED_LIBRARY_WORKSPACE_TOP_LEVEL_ENTRIES.includes(entryName);
+}
+function isReservedLibraryWorkspacePath(relativePath) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const [firstSegment] = normalizedPath.split('/');
+    return Boolean(firstSegment && isReservedLibraryWorkspaceTopLevelEntry(firstSegment));
+}
+function shouldIgnoreLibraryEntry(parentPath, entryName, kind) {
+    if (entryName === '.meta')
+        return true;
+    if (entryName === LIBRARY_DIRECTORY_PLACEHOLDER)
+        return true;
+    if (entryName.startsWith('.'))
+        return true;
+    if (!parentPath && entryName === 'INDEX.md')
+        return true;
+    if (!parentPath && isReservedLibraryWorkspaceTopLevelEntry(entryName))
+        return true;
+    if (kind === 'file' && !entryName.toLowerCase().endsWith('.md'))
+        return true;
+    return false;
+}
+function isMirrorReadableLibraryFilePath(relativePath) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    if (normalizedPath === 'INDEX.md' || normalizedPath === LIBRARY_MANIFEST_RELATIVE_PATH)
+        return true;
+    return isMirrorWritableLibraryDocumentPath(normalizedPath);
+}
+function shouldSkipLibraryMirrorEntry(relativePath, kind) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const segments = normalizedPath.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return false;
+    const [firstSegment] = segments;
+    if (!firstSegment)
+        return false;
+    if (segments.length === 1 && firstSegment === LIBRARY_DIRECTORY_PLACEHOLDER)
+        return true;
+    if (firstSegment === '.meta') {
+        if (kind === 'directory')
+            return false;
+        return normalizedPath !== LIBRARY_MANIFEST_RELATIVE_PATH;
+    }
+    if (segments.some((segment) => segment.startsWith('.')))
+        return true;
+    if (isReservedLibraryWorkspaceTopLevelEntry(firstSegment))
+        return true;
+    if (kind === 'directory')
+        return false;
+    return !isMirrorReadableLibraryFilePath(normalizedPath);
+}
+function isLibraryPathMissingError(error) {
+    const maybeErr = error;
+    if (maybeErr?.code === 'ENOENT')
+        return true;
+    const message = String(maybeErr?.message ?? error).toLowerCase();
+    return message.includes('not_found')
+        || message.includes('path not found')
+        || message.includes('enoent')
+        || message.includes('no such file');
+}
+function isLibraryPathNotDirectoryError(error) {
+    const maybeErr = error;
+    if (maybeErr?.code === 'ENOTDIR')
+        return true;
+    const message = String(maybeErr?.message ?? error).toLowerCase();
+    return message.includes('enotdir') || message.includes('not a directory');
+}
+function isLibraryPathDirectoryReadError(error) {
+    const maybeErr = error;
+    if (maybeErr?.code === 'EISDIR')
+        return true;
+    const message = String(maybeErr?.message ?? error).toLowerCase();
+    return message.includes('eisdir')
+        || message.includes('is a directory')
+        || message.includes('illegal operation on a directory');
+}
+function sortLibraryTreeNodes(nodes) {
+    return nodes
+        .map((node) => ({
+        ...node,
+        ...(node.children ? { children: sortLibraryTreeNodes(node.children) } : {}),
+    }))
+        .sort((left, right) => {
+        if (left.kind !== right.kind)
+            return left.kind === 'directory' ? -1 : 1;
+        return left.name.localeCompare(right.name);
+    });
+}
+function collectLibraryFilePaths(nodes) {
+    const paths = [];
+    for (const node of nodes) {
+        if (node.kind === 'file') {
+            paths.push(node.path);
+            continue;
+        }
+        if (node.children?.length) {
+            paths.push(...collectLibraryFilePaths(node.children));
+        }
+    }
+    return paths;
+}
+function upsertLibraryManifestDocument(manifest, relativePath, content) {
+    const existing = manifest.documents.find((doc) => doc.relativePath === relativePath);
+    const nextDocument = {
+        title: extractLibraryDocumentTitle(content) ?? existing?.title ?? path.posix.basename(relativePath, path.posix.extname(relativePath)),
+        category: existing?.category ?? inferLibraryCategory(relativePath),
+        topicPath: inferLibraryTopicPath(relativePath),
+        relativePath,
+        summary: existing?.summary ?? '',
+        sourceSavedItemIds: existing?.sourceSavedItemIds ?? [],
+        notionPageId: existing?.notionPageId ?? null,
+        notionPageUrl: existing?.notionPageUrl ?? null,
+    };
+    return {
+        version: manifest.version || 1,
+        processedSavedItemIds: manifest.processedSavedItemIds ?? [],
+        documents: [
+            ...manifest.documents.filter((doc) => doc.relativePath !== relativePath),
+            nextDocument,
+        ].sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
+    };
+}
+function extractLibraryDocumentTitle(content) {
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.trim().match(/^#\s+(.+)$/);
+        if (match?.[1]?.trim())
+            return match[1].trim();
+    }
+    return null;
+}
+function inferLibraryCategory(relativePath) {
+    const parts = relativePath.split('/').filter(Boolean);
+    if (parts.length > 1)
+        return parts[0] ?? '';
+    return '';
+}
+function inferLibraryTopicPath(relativePath) {
+    const normalized = relativePath.replace(/\.md$/i, '');
+    const parts = normalized.split('/').filter(Boolean);
+    if (parts.length <= 1)
+        return normalized;
+    return parts.slice(1).join('/');
+}
+function buildLibraryMirrorBaseline(tree) {
+    if (!tree)
+        return null;
+    return {
+        files: tree.files
+            .map((file) => ({
+            path: normalizeLibraryRelativePath(file.path),
+            sha256: file.sha256,
+        }))
+            .sort((left, right) => left.path.localeCompare(right.path)),
+    };
+}
+function serializeLibraryMirrorBaseline(baseline) {
+    if (!baseline)
+        return null;
+    return JSON.stringify(baseline);
+}
+function parseLibraryMirrorBaseline(raw) {
+    if (!raw?.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        const files = Array.isArray(parsed.files)
+            ? parsed.files
+                .filter((file) => (typeof file?.path === 'string'
+                && file.path.trim().length > 0
+                && typeof file?.sha256 === 'string'
+                && file.sha256.trim().length > 0))
+                .map((file) => ({
+                path: normalizeLibraryRelativePath(file.path),
+                sha256: file.sha256.trim(),
+            }))
+            : [];
+        return { files };
+    }
+    catch {
+        return null;
+    }
+}
+function filterMirrorBaselineFiles(baseline) {
+    return (baseline?.files ?? []).filter((file) => isMirrorWritableLibraryDocumentPath(file.path));
+}
+function filterMirrorCurrentFiles(tree) {
+    return (tree?.files ?? []).filter((file) => isMirrorWritableLibraryDocumentPath(file.path));
+}
+function isMirrorWritableLibraryDocumentPath(relativePath) {
+    try {
+        const normalizedPath = normalizeLibraryRelativePath(relativePath);
+        if (!normalizedPath.toLowerCase().endsWith('.md'))
+            return false;
+        if (normalizedPath === 'INDEX.md' || normalizedPath === '.meta' || normalizedPath.startsWith('.meta/')) {
+            return false;
+        }
+        assertLibraryWritePathAllowed(normalizedPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function collectLibraryMirrorFiles(libraryRootPath) {
+    const fsPromises = await import('node:fs/promises');
+    const files = [];
+    const walk = async (relativePath) => {
+        const absolutePath = relativePath
+            ? path.join(libraryRootPath, relativePath)
+            : libraryRootPath;
+        const entries = await fsPromises.readdir(absolutePath, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const childRelativePath = relativePath ? path.posix.join(relativePath, entry.name) : entry.name;
+            const childAbsolutePath = path.join(libraryRootPath, childRelativePath);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                if (shouldSkipLibraryMirrorEntry(childRelativePath, 'directory'))
+                    continue;
+                await walk(childRelativePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (shouldSkipLibraryMirrorEntry(childRelativePath, 'file'))
+                continue;
+            const content = (await fsPromises.readFile(childAbsolutePath, 'utf8')).replace(/\r\n/g, '\n');
+            files.push({
+                path: childRelativePath.replace(/\\/g, '/'),
+                content,
+                sha256: sha256Text(content),
+            });
+        }
+    };
+    await walk('');
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    return files;
+}
+async function collectAuthorityMirrorDocumentPaths(libraryRootPath) {
+    const fsPromises = await import('node:fs/promises');
+    const paths = [];
+    const walk = async (relativePath) => {
+        const absolutePath = relativePath
+            ? path.join(libraryRootPath, relativePath)
+            : libraryRootPath;
+        const entries = await fsPromises.readdir(absolutePath, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const entryRelativePath = relativePath ? path.posix.join(relativePath, entry.name) : entry.name;
+            const kind = entry.isDirectory() ? 'directory' : 'file';
+            if (shouldIgnoreLibraryEntry(relativePath, entry.name, kind))
+                continue;
+            if (entry.isDirectory()) {
+                await walk(entryRelativePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!isMirrorWritableLibraryDocumentPath(entryRelativePath))
+                continue;
+            paths.push(entryRelativePath);
+        }
+    };
+    await walk('');
+    return paths.sort((left, right) => left.localeCompare(right));
+}
+async function collectAuthoritySubtreeEntries(libraryRootPath, relativePath) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const entryKind = await getAuthorityEntryKind(libraryRootPath, normalizedPath);
+    if (!entryKind) {
+        return { directories: [], files: [] };
+    }
+    if (entryKind === 'file') {
+        return { directories: [], files: [normalizedPath] };
+    }
+    const fsPromises = await import('node:fs/promises');
+    const directories = [normalizedPath];
+    const files = [];
+    const walk = async (currentPath) => {
+        const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, currentPath);
+        const entries = await fsPromises.readdir(absolutePath, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const entryPath = path.posix.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                directories.push(entryPath);
+                await walk(entryPath);
+                continue;
+            }
+            files.push(entryPath);
+        }
+    };
+    await walk(normalizedPath);
+    return {
+        directories: directories.sort((left, right) => left.localeCompare(right)),
+        files: files.sort((left, right) => left.localeCompare(right)),
+    };
+}
+async function readAuthorityLibraryFile(libraryRootPath, relativePath) {
+    const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, relativePath);
+    const fsPromises = await import('node:fs/promises');
+    try {
+        const content = await fsPromises.readFile(absolutePath, 'utf8');
+        return { content: content.replace(/\r\n/g, '\n') };
+    }
+    catch (error) {
+        if (isLibraryPathMissingError(error))
+            return null;
+        throw error;
+    }
+}
+async function getAuthorityEntryKind(libraryRootPath, relativePath) {
+    const { absolutePath } = resolveLibraryAbsolutePath(libraryRootPath, relativePath);
+    const fsPromises = await import('node:fs/promises');
+    try {
+        const stat = await fsPromises.lstat(absolutePath);
+        return stat.isDirectory() ? 'directory' : 'file';
+    }
+    catch (error) {
+        if (isLibraryPathMissingError(error))
+            return null;
+        throw error;
+    }
+}
+async function deleteAuthorityLibraryPath(libraryRootPath, relativePath) {
+    const { absolutePath, libraryRoot } = resolveLibraryAbsolutePath(libraryRootPath, relativePath);
+    const fsPromises = await import('node:fs/promises');
+    const sourceStat = await fsPromises.lstat(absolutePath).catch((error) => {
+        if (isLibraryPathMissingError(error))
+            return null;
+        throw error;
+    });
+    if (!sourceStat)
+        return;
+    await fsPromises.rm(absolutePath, { recursive: sourceStat.isDirectory(), force: true });
+    await pruneEmptyLibraryParents(libraryRoot, path.dirname(absolutePath));
+}
+async function pruneEmptyLibraryParents(libraryRoot, startDirectory) {
+    const fsPromises = await import('node:fs/promises');
+    let cursor = startDirectory;
+    while (cursor.startsWith(libraryRoot) && cursor !== libraryRoot) {
+        const remaining = await fsPromises.readdir(cursor).catch((error) => {
+            if (isLibraryPathMissingError(error))
+                return null;
+            throw error;
+        });
+        if (!remaining || remaining.length > 0)
+            break;
+        await fsPromises.rmdir(cursor).catch((error) => {
+            if (isLibraryPathMissingError(error))
+                return;
+            throw error;
+        });
+        cursor = path.dirname(cursor);
+    }
+}
+async function renameAuthorityLibraryPath(libraryRootPath, relativePath, nextRelativePath, options) {
+    const { absolutePath, libraryRoot } = resolveLibraryAbsolutePath(libraryRootPath, relativePath);
+    const { absolutePath: nextAbsolutePath } = resolveLibraryAbsolutePath(libraryRootPath, nextRelativePath);
+    const fsPromises = await import('node:fs/promises');
+    const sourceStat = await fsPromises.lstat(absolutePath).catch((error) => {
+        if (isLibraryPathMissingError(error))
+            return null;
+        throw error;
+    });
+    if (!sourceStat) {
+        if (options?.allowMissingSource)
+            return 'missing_source';
+        throw new Error('Path not found');
+    }
+    const targetStat = await fsPromises.lstat(nextAbsolutePath).catch((error) => {
+        if (isLibraryPathMissingError(error))
+            return null;
+        throw error;
+    });
+    if (targetStat) {
+        if (options?.allowExistingTarget)
+            return 'existing_target';
+        throw new Error('Destination already exists');
+    }
+    await fsPromises.mkdir(path.dirname(nextAbsolutePath), { recursive: true });
+    await fsPromises.rename(absolutePath, nextAbsolutePath);
+    await pruneEmptyLibraryParents(libraryRoot, path.dirname(absolutePath));
+    return 'renamed';
+}
+function buildRenamedLibraryPath(relativePath, nextName, kind) {
+    const parentPath = path.posix.dirname(relativePath);
+    const siblingName = normalizeLibraryRenameName(nextName, kind);
+    const nextRelativePath = parentPath === '.'
+        ? siblingName
+        : path.posix.join(parentPath, siblingName);
+    return normalizeLibraryRelativePath(nextRelativePath);
+}
+function normalizeLibraryRenameName(rawName, kind) {
+    const trimmed = rawName.trim().replace(/\\/g, '/');
+    if (!trimmed) {
+        throw new Error(kind === 'directory' ? 'Folder name required' : 'Document name required');
+    }
+    if (trimmed.includes('/')) {
+        throw new Error('Name cannot include path separators');
+    }
+    if (trimmed === '.' || trimmed === '..') {
+        throw new Error('Invalid library path');
+    }
+    if (kind === 'directory') {
+        if (trimmed.toLowerCase().endsWith('.md')) {
+            throw new Error('Folder name cannot end with .md');
+        }
+        return trimmed;
+    }
+    const stem = trimmed.replace(/\.md$/i, '').trim();
+    if (!stem) {
+        throw new Error('Document name required');
+    }
+    return `${stem}.md`;
+}
+function renameLibraryManifestPaths(manifest, relativePath, nextRelativePath, kind) {
+    const remapDocument = (doc, updatedRelativePath) => ({
+        ...doc,
+        relativePath: updatedRelativePath,
+        category: inferLibraryCategory(updatedRelativePath),
+        topicPath: inferLibraryTopicPath(updatedRelativePath),
+    });
+    const documents = manifest.documents.map((doc) => {
+        if (kind === 'file') {
+            return doc.relativePath === relativePath
+                ? remapDocument(doc, nextRelativePath)
+                : doc;
+        }
+        if (doc.relativePath === relativePath) {
+            return remapDocument(doc, nextRelativePath);
+        }
+        if (doc.relativePath.startsWith(`${relativePath}/`)) {
+            return remapDocument(doc, `${nextRelativePath}${doc.relativePath.slice(relativePath.length)}`);
+        }
+        return doc;
+    });
+    const deduped = new Map();
+    for (const doc of documents) {
+        deduped.set(doc.relativePath, doc);
+    }
+    return {
+        version: manifest.version || 1,
+        processedSavedItemIds: manifest.processedSavedItemIds ?? [],
+        documents: Array.from(deduped.values()).sort((left, right) => left.relativePath.localeCompare(right.relativePath)),
+    };
+}
+function buildWritebackKey(location, relativePath) {
+    const owner = location.scope === 'shared'
+        ? (location.sharedKey ?? SHARED_LIBRARY_KEY)
+        : (location.userId ?? 'user');
+    return `${location.scope}:${owner}:${relativePath}`;
+}
+function sanitizeConflictPathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_').trim() || 'scope';
+}
+function sha256Text(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+export function isLibraryCuratorAgent(agent) {
+    return agent?.agentRole === 'platform_agent' || agent?.agentRole === 'library_curator';
+}