dominds 0.1.0

package/dist/server/api-routes.js

@@ -0,0 +1,1031 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiRoute = handleApiRoute;
+/**
+ * Module: server/api-routes
+ *
+ * Common API route handlers for both production and development servers
+ */
+const promises_1 = __importDefault(require("fs/promises"));
+const path = __importStar(require("path"));
+const dialog_1 = require("../dialog");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const log_1 = require("../log");
+const persistence_1 = require("../persistence");
+const diligence_1 = require("../shared/diligence");
+const runtime_language_1 = require("../shared/runtime-language");
+const language_1 = require("../shared/types/language");
+const time_1 = require("../shared/utils/time");
+const team_1 = require("../team");
+const registry_snapshot_1 = require("../tools/registry-snapshot");
+const id_1 = require("../utils/id");
+const task_package_1 = require("../utils/task-package");
+const taskdoc_search_1 = require("../utils/taskdoc-search");
+const prompts_routes_1 = require("./prompts-routes");
+const setup_routes_1 = require("./setup-routes");
+// Dialog lookup is performed via file-backed persistence; no in-memory registry
+const log = (0, log_1.createLogger)('api-routes');
+function getErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const maybe = error.code;
+    return typeof maybe === 'string' ? maybe : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Handle API routes
+ */
+async function handleApiRoute(req, res, pathname, context) {
+    try {
+        // Health check endpoint
+        if (pathname === '/api/health' && req.method === 'GET') {
+            return await handleHealthCheck(res, context);
+        }
+        // Live reload endpoint for development
+        if (pathname === '/api/live-reload' && req.method === 'GET') {
+            return await handleLiveReload(res, context);
+        }
+        // Team configuration endpoint (renamed)
+        if (pathname === '/api/team/config' && req.method === 'GET') {
+            return await handleGetTeamConfig(res);
+        }
+        // Setup status endpoint (WebUI /setup)
+        if (pathname === '/api/setup/status' && req.method === 'GET') {
+            const payload = await (0, setup_routes_1.buildSetupStatusResponse)();
+            respondJson(res, 200, payload);
+            return true;
+        }
+        if (pathname === '/api/setup/defaults-yaml' && req.method === 'GET') {
+            const payload = await (0, setup_routes_1.buildSetupFileResponse)('defaults_yaml');
+            respondJson(res, payload.success ? 200 : 404, payload);
+            return true;
+        }
+        if (pathname === '/api/setup/workspace-llm-yaml' && req.method === 'GET') {
+            const payload = await (0, setup_routes_1.buildSetupFileResponse)('workspace_llm_yaml');
+            respondJson(res, payload.success ? 200 : 404, payload);
+            return true;
+        }
+        // Setup: create/overwrite .minds/llm.yaml with raw YAML
+        if (pathname === '/api/setup/write-workspace-llm-yaml' && req.method === 'POST') {
+            const rawBody = await readRequestBody(req);
+            const result = await (0, setup_routes_1.handleWriteWorkspaceLlmYaml)(rawBody);
+            if (result.kind === 'ok') {
+                respondJson(res, 200, result.response);
+                return true;
+            }
+            if (result.kind === 'conflict') {
+                respondJson(res, 409, { success: false, path: result.path, error: result.errorText });
+                return true;
+            }
+            if (result.kind === 'bad_request') {
+                respondJson(res, 400, { success: false, path: result.path, error: result.errorText });
+                return true;
+            }
+            respondJson(res, 500, { success: false, path: result.path, error: result.errorText });
+            return true;
+        }
+        // Setup: write env vars to shell rc files
+        if (pathname === '/api/setup/write-shell-env' && req.method === 'POST') {
+            const rawBody = await readRequestBody(req);
+            const result = await (0, setup_routes_1.handleWriteShellEnv)(rawBody);
+            if (result.kind === 'ok') {
+                respondJson(res, 200, result.response);
+                return true;
+            }
+            if (result.kind === 'bad_request') {
+                respondJson(res, 400, { success: false, error: result.errorText });
+                return true;
+            }
+            respondJson(res, 500, { success: false, error: result.errorText });
+            return true;
+        }
+        // Setup: create/overwrite .minds/team.yaml with minimal member_defaults
+        if (pathname === '/api/setup/write-team-yaml' && req.method === 'POST') {
+            const rawBody = await readRequestBody(req);
+            const result = await (0, setup_routes_1.handleWriteTeamYaml)(rawBody);
+            if (result.kind === 'ok') {
+                respondJson(res, 200, result.response);
+                return true;
+            }
+            if (result.kind === 'conflict') {
+                respondJson(res, 409, { success: false, path: result.path, error: result.errorText });
+                return true;
+            }
+            if (result.kind === 'bad_request') {
+                respondJson(res, 400, { success: false, path: result.path, error: result.errorText });
+                return true;
+            }
+            respondJson(res, 500, { success: false, path: result.path, error: result.errorText });
+            return true;
+        }
+        // Dialog list endpoint
+        if (pathname === '/api/dialogs' && req.method === 'GET') {
+            return await handleGetDialogs(res);
+        }
+        // Create dialog endpoint
+        if (pathname === '/api/dialogs' && req.method === 'POST') {
+            return await handleCreateDialog(req, res, context);
+        }
+        // Move dialogs between status directories (running/completed/archived)
+        if (pathname === '/api/dialogs/move' && req.method === 'POST') {
+            return await handleMoveDialogs(req, res, context);
+        }
+        // Delete a dialog (root dialogs only for now)
+        if (pathname.startsWith('/api/dialogs/') &&
+            !pathname.endsWith('/hierarchy') &&
+            req.method === 'DELETE') {
+            const parts = pathname.split('/');
+            const rawRoot = parts[3];
+            if (!rawRoot) {
+                respondJson(res, 400, { error: 'Missing root dialog id' });
+                return true;
+            }
+            const rawSelf = parts[4];
+            const rootId = rawRoot.replace(/%2F/g, '/');
+            const selfId = (rawSelf || rawRoot).replace(/%2F/g, '/');
+            return await handleDeleteDialog(res, { rootId, selfId }, context);
+        }
+        // Get full hierarchy for a single root dialog
+        if (pathname.startsWith('/api/dialogs/') &&
+            pathname.endsWith('/hierarchy') &&
+            req.method === 'GET') {
+            const parts = pathname.split('/');
+            const rootId = parts[3].replace(/%2F/g, '/');
+            return await handleGetDialogHierarchy(res, rootId);
+        }
+        // Get specific dialog
+        if (pathname.startsWith('/api/dialogs/') && req.method === 'GET') {
+            const parts = pathname.split('/');
+            const selfId = (parts[4] || parts[3]).replace(/%2F/g, '/');
+            const rootId = parts[3].replace(/%2F/g, '/');
+            const dialog = { selfId, rootId };
+            return await handleGetDialog(res, dialog);
+        }
+        // Task documents endpoint
+        if (pathname === '/api/task-documents' && req.method === 'GET') {
+            return await handleGetTaskDocuments(res);
+        }
+        // Tools registry endpoint (snapshot)
+        if (pathname === '/api/tools-registry' && req.method === 'GET') {
+            return await handleGetToolsRegistry(res);
+        }
+        // Read rtws diligence prompt (workspace file).
+        if (pathname === '/api/rtws/diligence' && req.method === 'GET') {
+            return await handleGetRtwsDiligence(req, res);
+        }
+        // Write rtws diligence prompt (workspace file).
+        if (pathname === '/api/rtws/diligence' && req.method === 'POST') {
+            return await handleWriteRtwsDiligence(req, res);
+        }
+        // Read Dominds docs markdown (from dominds install root, NOT rtws).
+        if (pathname === '/api/docs/read' && req.method === 'GET') {
+            return await handleReadDocsMarkdown(req, res);
+        }
+        if (pathname === '/api/prompts/builtin' && req.method === 'GET') {
+            const payload = await (0, prompts_routes_1.handleGetBuiltinPrompts)();
+            respondJson(res, payload.success ? 200 : 500, payload);
+            return true;
+        }
+        if (pathname === '/api/prompts/workspace' && req.method === 'GET') {
+            const payload = await (0, prompts_routes_1.handleGetWorkspacePrompts)();
+            respondJson(res, payload.success ? 200 : 500, payload);
+            return true;
+        }
+        if (pathname === '/api/prompts/catalog' && req.method === 'GET') {
+            const payload = await (0, prompts_routes_1.handleGetPromptCatalog)();
+            respondJson(res, payload.success ? 200 : 500, payload);
+            return true;
+        }
+        if (pathname === '/api/prompts/workspace' && req.method === 'POST') {
+            const rawBody = await readRequestBody(req);
+            const payload = await (0, prompts_routes_1.handleSaveWorkspacePrompt)(rawBody);
+            respondJson(res, payload.success ? 200 : 400, payload);
+            return true;
+        }
+        if (pathname === '/api/team-mgmt/manual' && req.method === 'POST') {
+            const rawBody = await readRequestBody(req);
+            const payload = await (0, prompts_routes_1.handleTeamMgmtManual)(rawBody);
+            respondJson(res, payload.success ? 200 : 400, payload);
+            return true;
+        }
+        return false; // Route not handled
+    }
+    catch (error) {
+        log.error('Error handling API route:', error);
+        respondJson(res, 500, { error: 'Internal server error' });
+        return true;
+    }
+}
+function resolveRtwsDiligencePath(lang) {
+    const parsed = typeof lang === 'string' ? (0, language_1.normalizeLanguageCode)(lang) : null;
+    if (parsed === 'zh')
+        return path.resolve(process.cwd(), '.minds', 'diligence.zh.md');
+    if (parsed === 'en')
+        return path.resolve(process.cwd(), '.minds', 'diligence.en.md');
+    return path.resolve(process.cwd(), '.minds', 'diligence.md');
+}
+async function handleGetRtwsDiligence(req, res) {
+    const urlObj = new URL(req.url ?? '', 'http://127.0.0.1');
+    const lang = urlObj.searchParams.get('lang');
+    const primaryPath = resolveRtwsDiligencePath(lang);
+    const genericPath = path.resolve(process.cwd(), '.minds', 'diligence.md');
+    const candidates = [primaryPath, genericPath];
+    for (const filePath of candidates) {
+        try {
+            const raw = await promises_1.default.readFile(filePath, 'utf-8');
+            respondJson(res, 200, { success: true, path: filePath, raw, source: 'workspace' });
+            return true;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                continue;
+            }
+            log.error('Failed to read diligence file', error);
+            respondJson(res, 500, { success: false, error: 'Failed to read diligence file' });
+            return true;
+        }
+    }
+    const fallbackLang = typeof lang === 'string' ? (0, language_1.normalizeLanguageCode)(lang) : null;
+    const wl = fallbackLang ?? (0, runtime_language_1.getWorkLanguage)();
+    respondJson(res, 200, {
+        success: true,
+        path: primaryPath,
+        raw: diligence_1.DILIGENCE_FALLBACK_TEXT[wl],
+        source: 'builtin',
+    });
+    return true;
+}
+async function handleWriteRtwsDiligence(req, res) {
+    const urlObj = new URL(req.url ?? '', 'http://127.0.0.1');
+    const lang = urlObj.searchParams.get('lang');
+    const overwrite = urlObj.searchParams.get('overwrite');
+    const overwriteBool = overwrite === '1' || overwrite === 'true';
+    const filePath = resolveRtwsDiligencePath(lang);
+    let parsed;
+    try {
+        const rawBody = await readRequestBody(req);
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        respondJson(res, 400, { success: false, error: 'Invalid JSON' });
+        return true;
+    }
+    if (!isRecord(parsed) || typeof parsed.raw !== 'string') {
+        respondJson(res, 400, { success: false, error: 'Body must be { raw: string }' });
+        return true;
+    }
+    try {
+        const existing = await promises_1.default.readFile(filePath, 'utf-8').then(() => true, (e) => (getErrorCode(e) === 'ENOENT' ? false : Promise.reject(e)));
+        if (existing && !overwriteBool) {
+            respondJson(res, 409, {
+                success: false,
+                path: filePath,
+                error: 'File exists; retry with overwrite=1 to confirm overwrite',
+            });
+            return true;
+        }
+        await promises_1.default.mkdir(path.dirname(filePath), { recursive: true });
+        await promises_1.default.writeFile(filePath, parsed.raw, 'utf-8');
+        respondJson(res, 200, { success: true, path: filePath });
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to write diligence file', error);
+        respondJson(res, 500, { success: false, error: 'Failed to write diligence file' });
+        return true;
+    }
+}
+const DOCS_WHITELIST = new Set([
+    'design',
+    'dialog-system',
+    'keep-going',
+    'auth',
+    'dominds-terminology',
+    'cli-usage',
+    'mottos',
+    'encapsulated-taskdoc',
+    'memory-system',
+    'mcp-support',
+    'context-health',
+    'OEC-philosophy',
+    'design.md',
+    'dialog-system.md',
+    'keep-going.md',
+    'auth.md',
+    'dominds-terminology.md',
+    'cli-usage.md',
+    'mottos.md',
+    'encapsulated-taskdoc.md',
+    'memory-system.md',
+    'mcp-support.md',
+    'context-health.md',
+    'OEC-philosophy.md',
+]);
+async function handleReadDocsMarkdown(req, res) {
+    const urlObj = new URL(req.url ?? '', 'http://127.0.0.1');
+    const name = urlObj.searchParams.get('name');
+    const lang = urlObj.searchParams.get('lang');
+    const parsedLang = typeof lang === 'string' ? (0, language_1.normalizeLanguageCode)(lang) : null;
+    if (typeof name !== 'string' || name.trim() === '') {
+        respondJson(res, 400, { success: false, error: 'Missing name' });
+        return true;
+    }
+    if (!DOCS_WHITELIST.has(name)) {
+        respondJson(res, 403, { success: false, error: `Unsupported doc name: ${name}` });
+        return true;
+    }
+    const serverRoot = path.resolve(__dirname, '..', '..');
+    const docsDir = path.resolve(serverRoot, 'docs');
+    const ext = '.md';
+    const stem = name.endsWith(ext) ? name.slice(0, -ext.length) : name;
+    const basePath = path.resolve(docsDir, `${stem}${ext}`);
+    const candidateLocalized = parsedLang === null ? null : path.resolve(docsDir, `${stem}.${parsedLang}${ext}`);
+    const candidates = candidateLocalized ? [candidateLocalized, basePath] : [basePath];
+    for (const filePath of candidates) {
+        try {
+            const raw = await promises_1.default.readFile(filePath, 'utf-8');
+            respondJson(res, 200, { success: true, name: stem, path: filePath, raw });
+            return true;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                continue;
+            }
+            log.error('Failed to read docs file', error);
+            respondJson(res, 500, { success: false, error: 'Failed to read docs file' });
+            return true;
+        }
+    }
+    respondJson(res, 404, { success: false, error: 'Doc not found' });
+    return true;
+}
+async function handleGetToolsRegistry(res) {
+    try {
+        const snapshot = (0, registry_snapshot_1.createToolsRegistrySnapshot)();
+        res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+        });
+        res.end(JSON.stringify({
+            success: true,
+            toolsets: snapshot.toolsets,
+            timestamp: snapshot.timestamp,
+        }));
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting tools registry snapshot:', error);
+        res.writeHead(500, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+        });
+        res.end(JSON.stringify({ success: false, error: 'Failed to get tools registry' }));
+        return true;
+    }
+}
+/**
+ * Health check endpoint
+ */
+async function handleHealthCheck(res, context) {
+    try {
+        const healthData = {
+            ok: true,
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            server: 'dominds',
+            version: '1.0.0',
+            workspace: process.cwd(),
+            mode: context.mode,
+        };
+        respondJson(res, 200, healthData);
+        return true;
+    }
+    catch (error) {
+        log.error('Health check failed:', error);
+        respondJson(res, 500, { ok: false, error: 'Health check failed' });
+        return true;
+    }
+}
+/**
+ * Live reload endpoint for development
+ */
+async function handleLiveReload(res, context) {
+    try {
+        respondJson(res, 200, {
+            success: true,
+            message: 'Live reload endpoint active',
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            mode: context.mode,
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Live reload failed:', error);
+        respondJson(res, 500, { success: false, error: 'Live reload failed' });
+        return true;
+    }
+}
+/**
+ * Team configuration endpoint
+ * Returns full team configuration with member defaults, default responder,
+ * and raw members record. Frontend will attach prototypes for defaults.
+ */
+async function handleGetTeamConfig(res) {
+    try {
+        const team = await team_1.Team.load();
+        // Convert Team.Member instances to plain frontend objects without prototypes
+        const toFrontendMember = (m) => ({
+            id: m.id,
+            name: m.name,
+            provider: m.provider,
+            model: m.model,
+            gofor: m.gofor,
+            toolsets: m.toolsets,
+            tools: m.tools,
+            icon: m.icon,
+            streaming: m.streaming,
+            hidden: m.hidden,
+        });
+        const memberDefaults = toFrontendMember(team.memberDefaults);
+        const members = {};
+        for (const [id, member] of Object.entries(team.members)) {
+            members[id] = toFrontendMember(member);
+        }
+        const def = team.getDefaultResponder();
+        respondJson(res, 200, {
+            configuration: {
+                memberDefaults,
+                defaultResponder: def ? def.id : undefined,
+                members,
+            },
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting team configuration:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get team configuration' });
+        return true;
+    }
+}
+/**
+ * Get dialog list - returns root dialogs with subdialogCount
+ */
+async function handleGetDialogs(res) {
+    try {
+        const statuses = ['running', 'completed', 'archived'];
+        const rootDialogs = [];
+        for (const status of statuses) {
+            const ids = await persistence_1.DialogPersistence.listDialogs(status);
+            for (const id of ids) {
+                const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(new dialog_1.DialogID(id), status);
+                if (!meta)
+                    continue;
+                // Load latest.yaml for currentRound and lastModified timestamp
+                const latest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(id), status);
+                // Count subdialogs for this root dialog
+                const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(id), status);
+                const subPath = path.join(rootPath, 'subdialogs');
+                const subdialogCount = await countSubdialogs(subPath);
+                rootDialogs.push({
+                    rootId: meta.id,
+                    agentId: meta.agentId,
+                    taskDocPath: meta.taskDocPath,
+                    status,
+                    currentRound: latest?.currentRound || 1,
+                    createdAt: meta.createdAt,
+                    lastModified: latest?.lastModified || meta.createdAt,
+                    runState: latest?.runState,
+                    subdialogCount,
+                });
+            }
+        }
+        respondJson(res, 200, { success: true, dialogs: rootDialogs });
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting root dialogs:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get root dialogs' });
+        return true;
+    }
+}
+/**
+ * Count subdialog directories recursively
+ */
+async function countSubdialogs(dirPath) {
+    try {
+        const entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+        let count = 0;
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const fullPath = path.join(dirPath, entry.name);
+                const dialogYamlPath = path.join(fullPath, 'dialog.yaml');
+                try {
+                    await promises_1.default.access(dialogYamlPath);
+                    // This directory contains dialog.yaml - it's a subdialog
+                    count++;
+                }
+                catch {
+                    // No dialog.yaml - recurse into this directory
+                    count += await countSubdialogs(fullPath);
+                }
+            }
+        }
+        return count;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return 0;
+        }
+        throw error;
+    }
+}
+/**
+ * Get full hierarchy (root + subdialogs) for a single root dialog
+ */
+async function handleGetDialogHierarchy(res, rootId) {
+    try {
+        const statuses = ['running', 'completed', 'archived'];
+        let foundStatus = null;
+        let rootMeta = null;
+        for (const status of statuses) {
+            const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(new dialog_1.DialogID(rootId), status);
+            if (meta) {
+                foundStatus = status;
+                rootMeta = meta;
+                break;
+            }
+        }
+        if (!foundStatus || !rootMeta) {
+            respondJson(res, 404, { success: false, error: `Root dialog ${rootId} not found` });
+            return true;
+        }
+        // Load latest.yaml for root dialog currentRound and lastModified timestamp
+        const rootLatest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(rootId), foundStatus);
+        const rootInfo = {
+            id: rootMeta.id,
+            agentId: rootMeta.agentId,
+            taskDocPath: rootMeta.taskDocPath,
+            status: foundStatus,
+            currentRound: rootLatest?.currentRound || 1,
+            createdAt: rootMeta.createdAt,
+            lastModified: rootLatest?.lastModified || rootMeta.createdAt,
+            runState: rootLatest?.runState,
+        };
+        // Enumerate subdialogs under this root
+        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(rootId), foundStatus);
+        const subPath = path.join(rootPath, 'subdialogs');
+        let subdialogs = [];
+        // Recursively find all subdialog directories (handles nested paths like c1/78/4c3d759a)
+        async function findSubdialogDirs(dir, baseRelative = '') {
+            const results = [];
+            try {
+                const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const fullPath = path.join(dir, entry.name);
+                        const dialogYamlPath = path.join(fullPath, 'dialog.yaml');
+                        const entryRelative = baseRelative ? path.join(baseRelative, entry.name) : entry.name;
+                        try {
+                            await promises_1.default.access(dialogYamlPath);
+                            // This directory contains dialog.yaml - it's a subdialog
+                            // Push the FULL relative path (e.g., "5a/e2/4c424f27" not just "5a")
+                            results.push(entryRelative);
+                        }
+                        catch {
+                            // No dialog.yaml - recurse into this directory
+                            const nested = await findSubdialogDirs(fullPath, entryRelative);
+                            results.push(...nested);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (typeof error === 'object' &&
+                    error !== null &&
+                    'code' in error &&
+                    error.code === 'ENOENT') {
+                    // No subdialogs directory - return empty
+                }
+                else {
+                    throw error;
+                }
+            }
+            return results;
+        }
+        try {
+            const subIds = await findSubdialogDirs(subPath);
+            for (const subId of subIds) {
+                const meta = await persistence_1.DialogPersistence.loadDialogMetadata(new dialog_1.DialogID(subId, rootId), foundStatus);
+                if (meta) {
+                    // Load latest.yaml for subdialog currentRound and lastModified timestamp
+                    const subLatest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(subId, rootId), foundStatus);
+                    subdialogs.push({
+                        selfId: meta.id,
+                        rootId: rootId, // For subdialogs, rootId is the supdialog's ID
+                        agentId: meta.agentId,
+                        taskDocPath: meta.taskDocPath,
+                        status: foundStatus,
+                        currentRound: subLatest?.currentRound || 1,
+                        createdAt: meta.createdAt,
+                        lastModified: subLatest?.lastModified || meta.createdAt,
+                        runState: subLatest?.runState,
+                        tellaskSession: meta.tellaskSession,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            if (typeof error === 'object' &&
+                error !== null &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                subdialogs = [];
+            }
+            else {
+                throw error;
+            }
+        }
+        respondJson(res, 200, {
+            success: true,
+            hierarchy: {
+                root: rootInfo,
+                subdialogs,
+            },
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting dialog hierarchy:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get dialog hierarchy' });
+        return true;
+    }
+}
+/**
+ * Create new dialog
+ */
+async function handleCreateDialog(req, res, context) {
+    try {
+        const body = await readRequestBody(req);
+        const { agentId, taskDocPath } = JSON.parse(body);
+        if (!agentId) {
+            respondJson(res, 400, { success: false, error: 'agentId is required' });
+            return true;
+        }
+        if (typeof taskDocPath !== 'string' || taskDocPath.trim() === '') {
+            respondJson(res, 400, { success: false, error: 'taskDocPath is required' });
+            return true;
+        }
+        if (!(0, task_package_1.isTaskPackagePath)(taskDocPath)) {
+            respondJson(res, 400, {
+                success: false,
+                error: `taskDocPath must be a Task Doc directory ending in '.tsk' (got: '${taskDocPath}')`,
+            });
+            return true;
+        }
+        // Generate dialog ID
+        const generatedId = (0, id_1.generateDialogID)();
+        const dialogId = new dialog_1.DialogID(generatedId);
+        // Create dialog UI based on context
+        // Always use DiskFileDialogStore for file-based persistence
+        const dialogUI = new persistence_1.DiskFileDialogStore(dialogId);
+        // Create RootDialog
+        const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, agentId);
+        dialog_global_registry_1.globalDialogRegistry.register(dialog);
+        // Persist dialog metadata and latest.yaml (write-once pattern)
+        const metadata = {
+            id: dialogId.selfId,
+            agentId: agentId,
+            taskDocPath: taskDocPath,
+            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        };
+        await persistence_1.DialogPersistence.saveDialogMetadata(new dialog_1.DialogID(dialogId.selfId), metadata);
+        // Initialize latest.yaml via the mutation API (write-back will flush).
+        await persistence_1.DialogPersistence.mutateDialogLatest(new dialog_1.DialogID(dialogId.selfId), () => ({
+            kind: 'replace',
+            next: {
+                currentRound: 1,
+                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                status: 'active',
+                messageCount: 0,
+                functionCallCount: 0,
+                subdialogCount: 0,
+                runState: { kind: 'idle_waiting_user' },
+                disableDiligencePush: false,
+            },
+        }));
+        // Dialog is registered with the global registry on creation
+        // No need to call registerDialog
+        respondJson(res, 201, { success: true, selfId: dialogId.selfId, rootId: dialogId.rootId });
+        broadcastDialogCreates(context.clients, {
+            type: 'dialogs_created',
+            scope: { kind: 'root', rootId: dialogId.selfId },
+            status: 'running',
+            createdRootIds: [dialogId.selfId],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error creating dialog:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to create dialog' });
+        return true;
+    }
+}
+async function handleMoveDialogs(req, res, context) {
+    try {
+        const body = await readRequestBody(req);
+        const parsed = JSON.parse(body);
+        if (typeof parsed !== 'object' || parsed === null) {
+            respondJson(res, 400, { success: false, error: 'Invalid JSON body' });
+            return true;
+        }
+        const kind = parsed.kind;
+        if (kind !== 'root' && kind !== 'task') {
+            respondJson(res, 400, { success: false, error: 'Invalid move request kind' });
+            return true;
+        }
+        const fromStatus = parsed.fromStatus;
+        const toStatus = parsed.toStatus;
+        const fromOk = fromStatus === 'running' || fromStatus === 'completed' || fromStatus === 'archived';
+        const toOk = toStatus === 'running' || toStatus === 'completed' || toStatus === 'archived';
+        if (!fromOk || !toOk) {
+            respondJson(res, 400, { success: false, error: 'Invalid fromStatus/toStatus' });
+            return true;
+        }
+        if (fromStatus === toStatus) {
+            respondJson(res, 400, { success: false, error: 'fromStatus and toStatus must differ' });
+            return true;
+        }
+        const request = parsed;
+        const movedRootIds = [];
+        const scope = request.kind === 'root'
+            ? { kind: 'root', rootId: request.rootId }
+            : { kind: 'task', taskDocPath: request.taskDocPath };
+        if (request.kind === 'root') {
+            const rootId = request.rootId;
+            if (typeof rootId !== 'string' || rootId.trim() === '') {
+                respondJson(res, 400, { success: false, error: 'rootId must be a non-empty string' });
+                return true;
+            }
+            const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(new dialog_1.DialogID(rootId), fromStatus);
+            if (!meta) {
+                respondJson(res, 404, {
+                    success: false,
+                    error: `Root dialog ${rootId} not found in ${fromStatus}`,
+                });
+                return true;
+            }
+            await persistence_1.DialogPersistence.moveDialogStatus(new dialog_1.DialogID(rootId), fromStatus, toStatus);
+            movedRootIds.push(rootId);
+            const live = dialog_global_registry_1.globalDialogRegistry.get(rootId);
+            if (live) {
+                live.setPersistenceStatus(toStatus);
+            }
+            respondJson(res, 200, { success: true, movedRootIds });
+            broadcastDialogMoves(context.clients, {
+                type: 'dialogs_moved',
+                scope,
+                fromStatus,
+                toStatus,
+                movedRootIds,
+                timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            });
+            return true;
+        }
+        const taskDocPath = request.taskDocPath;
+        if (typeof taskDocPath !== 'string' || taskDocPath.trim() === '') {
+            respondJson(res, 400, { success: false, error: 'taskDocPath must be a non-empty string' });
+            return true;
+        }
+        const ids = await persistence_1.DialogPersistence.listDialogs(fromStatus);
+        for (const id of ids) {
+            if (typeof id !== 'string' || id.trim() === '')
+                continue;
+            const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(new dialog_1.DialogID(id), fromStatus);
+            if (!meta)
+                continue;
+            if (meta.taskDocPath !== taskDocPath)
+                continue;
+            await persistence_1.DialogPersistence.moveDialogStatus(new dialog_1.DialogID(id), fromStatus, toStatus);
+            movedRootIds.push(id);
+        }
+        for (const rootId of movedRootIds) {
+            const live = dialog_global_registry_1.globalDialogRegistry.get(rootId);
+            if (live) {
+                live.setPersistenceStatus(toStatus);
+            }
+        }
+        respondJson(res, 200, { success: true, movedRootIds });
+        broadcastDialogMoves(context.clients, {
+            type: 'dialogs_moved',
+            scope,
+            fromStatus,
+            toStatus,
+            movedRootIds,
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error moving dialogs:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to move dialogs' });
+        return true;
+    }
+}
+function broadcastDialogMoves(clients, message) {
+    if (!clients)
+        return;
+    if (message.movedRootIds.length === 0)
+        return;
+    const data = JSON.stringify(message);
+    for (const ws of clients) {
+        if (ws.readyState === 1) {
+            ws.send(data);
+        }
+    }
+}
+function broadcastDialogDeletes(clients, message) {
+    if (!clients)
+        return;
+    if (message.deletedRootIds.length === 0)
+        return;
+    const data = JSON.stringify(message);
+    for (const ws of clients) {
+        if (ws.readyState === 1) {
+            ws.send(data);
+        }
+    }
+}
+function broadcastDialogCreates(clients, message) {
+    if (!clients)
+        return;
+    if (message.createdRootIds.length === 0)
+        return;
+    const data = JSON.stringify(message);
+    for (const ws of clients) {
+        if (ws.readyState === 1) {
+            ws.send(data);
+        }
+    }
+}
+async function handleDeleteDialog(res, dialog, context) {
+    try {
+        const { rootId, selfId } = dialog;
+        if (typeof rootId !== 'string' || rootId.trim() === '') {
+            respondJson(res, 400, { error: 'Invalid root dialog id' });
+            return true;
+        }
+        if (typeof selfId !== 'string' || selfId.trim() === '') {
+            respondJson(res, 400, { error: 'Invalid dialog id' });
+            return true;
+        }
+        if (selfId !== rootId) {
+            respondJson(res, 400, {
+                error: 'Only root dialog deletion is supported (use /api/dialogs/:root)',
+            });
+            return true;
+        }
+        const fromStatus = await persistence_1.DialogPersistence.deleteRootDialog(new dialog_1.DialogID(rootId));
+        if (!fromStatus) {
+            respondJson(res, 404, { error: 'Dialog not found' });
+            return true;
+        }
+        log.debug('Deleted dialog via API', undefined, { rootId, fromStatus });
+        dialog_global_registry_1.globalDialogRegistry.unregister(rootId);
+        respondJson(res, 200, { deleted: true, fromStatus });
+        broadcastDialogDeletes(context.clients, {
+            type: 'dialogs_deleted',
+            scope: { kind: 'root', rootId },
+            fromStatus,
+            deletedRootIds: [rootId],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error deleting dialog:', error);
+        respondJson(res, 500, { error: 'Failed to delete dialog' });
+        return true;
+    }
+}
+/**
+ * Get specific dialog
+ */
+async function handleGetDialog(res, dialog) {
+    try {
+        const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(new dialog_1.DialogID(dialog.selfId, dialog.rootId), 'running');
+        if (!metadata) {
+            respondJson(res, 404, { success: false, error: 'Dialog not found' });
+            return true;
+        }
+        // Enforce structured identification for subdialogs
+        if (metadata.supdialogId && dialog.selfId === dialog.rootId) {
+            respondJson(res, 400, {
+                success: false,
+                error: 'Subdialog requires /api/dialogs/:root/:self',
+            });
+            return true;
+        }
+        const currentRound = await persistence_1.DialogPersistence.getCurrentRoundNumber(new dialog_1.DialogID(dialog.selfId, dialog.rootId), 'running');
+        const dialogData = {
+            id: metadata.id,
+            agentId: metadata.agentId,
+            status: 'running',
+            createdAt: metadata.createdAt,
+            currentRound,
+        };
+        respondJson(res, 200, { success: true, dialog: dialogData });
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting dialog:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get dialog' });
+        return true;
+    }
+}
+/**
+ * Get task documents
+ */
+async function handleGetTaskDocuments(res) {
+    try {
+        const taskDocuments = await listTaskDocuments();
+        respondJson(res, 200, taskDocuments);
+        return true;
+    }
+    catch (error) {
+        log.error('Error getting task documents:', error);
+        respondJson(res, 500, { success: false, error: 'Failed to get task documents' });
+        return true;
+    }
+}
+/**
+ * Helper function to read request body
+ */
+function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            resolve(body);
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Helper function to send JSON response
+ */
+function respondJson(res, statusCode, data) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+/**
+ * List task documents (recursive search; Task Docs are encapsulated `*.tsk/` directories)
+ */
+async function listTaskDocuments() {
+    const result = await (0, taskdoc_search_1.listTaskDocumentsInWorkspace)({ rootDir: '.' });
+    if (result.kind === 'ok')
+        return { success: true, taskDocuments: result.taskDocuments };
+    return { success: false, error: result.errorText };
+}