botmux 2.111.0 → 2.112.0

package/dist/dashboard.js

@@ -6,7 +6,7 @@ import { atomicWriteFileSync } from './utils/atomic-write.js';
 import { join, dirname, extname, resolve, relative, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { randomBytes, createHmac } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { logger } from './utils/logger.js';
 import { config } from './config.js';
 import { listenWithProbe } from './utils/listen-with-probe.js';
@@ -15,16 +15,16 @@ import { DaemonRegistry } from './dashboard/registry.js';
 import { Aggregator, subscribeDaemon } from './dashboard/aggregator.js';
 import { pickCreatorForGroup } from './dashboard/operator-selector.js';
 import { buildTeamGroupCreatePayload, planGroupCreator } from './dashboard/team-group.js';
-import { handleWorkflowApi, jsonRes } from './dashboard/workflow-api.js';
+import { jsonRes } from './dashboard/http.js';
 import { handleV3RunsApi } from './dashboard/v3-runs-api.js';
 import { defaultRunsDir as v3RunsDir } from './workflows/v3/ops-projection.js';
+import { verifyWorkflowDaemonIpcResponse, workflowDaemonIpcHeaders, WORKFLOW_DAEMON_IPC_ROUTE_PREFIX, } from './workflows/v3/daemon-ipc-auth.js';
 import { handleDashboardTriggerApi } from './dashboard/trigger-api.js';
 import { handleConnectorApi } from './dashboard/connector-api.js';
 import { redactGroupsForPublic, redactSchedulesForPublic } from './dashboard/public-redact.js';
 import { handleWebhookRoute } from './dashboard/webhook-routes.js';
 import { handleFederationApi } from './dashboard/federation-api.js';
 import { handleFederationSpokeApi, syncAllMemberships, autoBindOwnerIfUnambiguous } from './dashboard/federation-spoke-api.js';
-import { getRunsDir } from './workflows/runs-dir.js';
 import { BotOnboardingManager } from './dashboard/bot-onboarding.js';
 import { FeishuLoginManager } from './dashboard/feishu-login.js';
 import { CLI_SELECT_OPTIONS, resolveCliSelection, isTtadkWrapper, ttadkAcceptsModel, TTADK_DEFAULT_MODEL, TTADK_MODEL_SUGGESTIONS, } from './setup/cli-selection.js';
@@ -33,6 +33,8 @@ import { invalidWorkingDirs } from './utils/working-dir.js';
 import { invalidateGlobalConfigCache, mergeDashboardConfig, mergeGlobalConfig, readGlobalConfig } from './global-config.js';
 import { hostLocalTimeZone, scheduleTimeZone } from './utils/timezone.js';
 import { buildDashboardUrls } from './core/dashboard-url.js';
+import { resolveBotmuxDataDir } from './core/data-dir.js';
+import { dashboardSecretPath } from './core/dashboard-secret.js';
 import { deleteWhiteboard, listWhiteboards, readWhiteboard, whiteboardEnabled } from './services/whiteboard-store.js';
 import { isLocalDevInstall, botmuxVersionAt, botmuxCliEntry, botmuxInstallRoot } from './utils/install-info.js';
 import { checkNode, detectBotmuxInstalls, resolveCurrentVersion } from './utils/install-diagnostics.js';
@@ -46,20 +48,23 @@ import { withFileLock } from './utils/file-lock.js';
 import { spawn } from 'node:child_process';
 import { applySettingsWrite, defaultSettingsWriteApplierDeps, } from './dashboard/settings-write-applier.js';
 import { addBotsToGroup, bindOncall, disbandGroup, leaveGroup, unbindOncall, } from './dashboard/groups-action-helpers.js';
-import { defaultWorkflowsActionDeps } from './dashboard/workflows-action-helpers.js';
-import { listRuns as listRunsImpl, readRunSnapshot as readRunSnapshotImpl, scrubSnapshotForUnauthed as scrubSnapshotImpl, isValidRunId as isValidRunIdImpl, TERMINAL_RUN_STATUSES as TERMINAL_RUN_STATUSES_IMPL, } from './workflows/ops-projection.js';
 import { createDaemonInternalApi } from './dashboard/daemon-internal-api.js';
 import { listTeamReports, readTeamBoard, setTeamBoardEntry } from './services/team-board-store.js';
 import { createCliAdapterSync } from './adapters/cli/registry.js';
 import { hd2dAssetPath, hd2dStatus, startHd2dDownload } from './dashboard/hd2d-assets.js';
 import { installLocalSkillLinks, readSkillRegistry, removeInstalledSkill, removeInstalledSkills, updateInstalledSkillAsync, } from './services/skill-registry-store.js';
 import { redactGitUrlCredentials } from './core/skills/sources.js';
-import { getBot, loadBotConfigs } from './bot-registry.js';
+import { effectiveDefaultWorkingDir, getBot, loadBotConfigs, parseBotConfigsFromText } from './bot-registry.js';
 import { findEntryIndex, readRawConfig, requireConfigPath, writeRawConfigAtomic } from './services/config-store.js';
 import { discoverNativeCliSkillGroups } from './core/skills/discovery.js';
 import { analyzeSkillReferences } from './core/skills/references.js';
 import { discoverDashboardSkills, installDashboardSkill, parseDashboardSkillInstallRequest, parseInstallLocalLinksSources, MAX_LOCAL_LINK_SOURCES } from './dashboard/skill-install-request.js';
 import { botDefaultsPayload, botSummaryPayload } from './dashboard/bot-payload.js';
+import { handleVcMeetingConsumerProfilesGet, handleVcMeetingConsumerProfilesPut, } from './dashboard/vc-consumer-profiles-api.js';
+import { buildVcMeetingConsumerBootstrapAgents, seedVcMeetingDefaultConsumerProfile, } from './services/vc-meeting-consumer-profile-bootstrap.js';
+import { evaluateVcMeetingConsumerIsolation } from './services/vc-meeting-consumer-isolation.js';
+import { resolvePairedSpawnBackendType } from './core/persistent-backend.js';
+import { readVcMeetingConsumerProfiles, updateVcMeetingConsumerProfiles, } from './services/vc-meeting-consumer-profile-store.js';
 import { isValidRoleProfileId } from './services/role-profile-store.js';
 import { mergeSafeInsightOverviews } from './services/insight/report.js';
 import { readPlatformBinding } from './platform/binding.js';
@@ -82,13 +87,14 @@ import { materializePlugin } from './core/plugins/materializer.js';
 import { resolveEffectivePluginIds, updateBotPluginOverride } from './core/plugins/effective.js';
 import { assertPluginBindingTransition, describePluginDependencyError } from './core/plugins/dependencies.js';
 import { inspectGatewayEntry } from './core/plugins/mcp/gateway-installer.js';
-const SECRET_PATH = join(homedir(), '.botmux', '.dashboard-secret');
+import { fetchDaemonIpc } from './core/daemon-ipc-auth.js';
+const SECRET_PATH = dashboardSecretPath();
 const TOKEN_PATH = join(homedir(), '.botmux', '.dashboard-token');
 /** Per-daemon budget for the cross-daemon insight overview fan-out — bounds
  *  aggregate latency when one daemon's insight parse is slow or hung. */
 const INSIGHT_FANOUT_TIMEOUT_MS = 10_000;
 const BOTS_JSON_PATH = join(homedir(), '.botmux', 'bots.json');
-const REGISTRY_DIR = join(homedir(), '.botmux', 'data', 'dashboard-daemons');
+const REGISTRY_DIR = join(resolveBotmuxDataDir(), 'dashboard-daemons');
 // The dashboard probes upward if its configured port is busy (e.g. a second
 // botmux instance on this host). The actually-bound port is persisted here so
 // the `botmux dashboard` CLI can reach /__cli/rotate without guessing.
@@ -176,17 +182,6 @@ function verifyDashboardBinding(port) {
         req.on('error', () => resolve(false));
     });
 }
-/** Sign a loopback request to a daemon's write-link route. The daemon verifies
- *  with the same .dashboard-secret, so only a caller that can read the secret —
- *  the dashboard — can mint write tokens; a bare local process that only knows
- *  the ipcPort can't. Same scheme as the `botmux dashboard` → /__cli/rotate
- *  HMAC. */
-function signDaemonTokenHeaders() {
-    const ts = Math.floor(Date.now() / 1000).toString();
-    const nonce = randomBytes(8).toString('hex');
-    const sig = createHmac('sha256', SECRET).update(`${ts}:${nonce}`).digest('base64url');
-    return { 'X-Botmux-Cli-Ts': ts, 'X-Botmux-Cli-Nonce': nonce, 'X-Botmux-Cli-Auth': sig };
-}
 mkdirSync(REGISTRY_DIR, { recursive: true });
 const registry = new DaemonRegistry(REGISTRY_DIR);
 const aggregator = new Aggregator();
@@ -312,6 +307,32 @@ function refreshLocalVcMeetingAgentConfig(appId) {
         // This dashboard process may not host the target bot daemon.
     }
 }
+function vcMeetingConsumerProfilesApiDeps() {
+    return {
+        readSnapshot: readVcMeetingConsumerProfiles,
+        updateSnapshot: updateVcMeetingConsumerProfiles,
+        loadBotConfigs,
+        effectiveDefaultWorkingDir,
+        onlineBotName: appId => registry.getByAppId(appId)?.botName,
+        isOnline: appId => !!registry.getByAppId(appId),
+        adapterReliableTurnTerminal: (cliId, cliPathOverride) => {
+            if (!cliId)
+                return false;
+            try {
+                return createCliAdapterSync(cliId, cliPathOverride).reliableTurnTerminal === true;
+            }
+            catch {
+                return false;
+            }
+        },
+        managedSideEffectIsolation: bot => evaluateVcMeetingConsumerIsolation({
+            sandbox: bot.sandbox,
+            platform: process.platform,
+            backendType: resolvePairedSpawnBackendType(bot.cliId ?? config.daemon.cliId, undefined, bot.backendType, config.daemon.backendType),
+        }).ok,
+        reloadDaemons: reloadVcMeetingBotConfigOnDaemons,
+    };
+}
 async function reloadVcMeetingBotConfigOnDaemons(appIds) {
     const unique = [...new Set(appIds.filter(Boolean))];
     for (const appId of unique)
@@ -320,7 +341,7 @@ async function reloadVcMeetingBotConfigOnDaemons(appIds) {
         const d = registry.getByAppId(appId);
         if (!d)
             return;
-        await fetch(`http://127.0.0.1:${d.ipcPort}/api/bot-config/reload`, {
+        await fetchDaemonIpc(d.ipcPort, '/api/bot-config/reload', {
             method: 'POST',
             signal: AbortSignal.timeout(10_000),
         }).catch(() => undefined);
@@ -553,7 +574,8 @@ async function syncVcMeetingListenerBotConfig(listenerBotAppId, previousListener
                 const entry = raw[idx];
                 const next = normalizeVcMeetingAgentRecord(entry.vcMeetingAgent);
                 let entryChanged = false;
-                if (next.enabled !== true) {
+                const firstEnable = next.enabled !== true;
+                if (firstEnable) {
                     next.enabled = true;
                     next.dashboardManagedListener = true;
                     entryChanged = true;
@@ -563,18 +585,25 @@ async function syncVcMeetingListenerBotConfig(listenerBotAppId, previousListener
                     entryChanged = true;
                 }
                 const mc = next.meetingConsumer;
-                if (!mc || typeof mc !== 'object' || Array.isArray(mc)) {
-                    next.meetingConsumer = { enabled: true };
+                const mcRec = mc && typeof mc === 'object' && !Array.isArray(mc)
+                    ? { ...mc }
+                    : {};
+                // Selecting a global listener is the Dashboard's explicit opt-in to the
+                // complete meeting pipeline. It intentionally re-enables the listener's
+                // consumer surface; profile/default ownership is still preserved by the
+                // own-property gates in seedVcMeetingDefaultConsumerProfile below.
+                if (mcRec.enabled !== true) {
+                    mcRec.enabled = true;
                     entryChanged = true;
                 }
-                else {
-                    const mcRec = mc;
-                    if (mcRec.enabled !== true) {
-                        mcRec.enabled = true;
-                        next.meetingConsumer = mcRec;
-                        entryChanged = true;
-                    }
+                if (seedVcMeetingDefaultConsumerProfile(mcRec, nextAppId, 
+                // Resolve against the latest locked bots.json snapshot, not a stale
+                // pre-lock load. This also makes fallback selection independent of
+                // the order in which bot entries happen to be stored.
+                buildVcMeetingConsumerBootstrapAgents(parseBotConfigsFromText(JSON.stringify(raw))))) {
+                    entryChanged = true;
                 }
+                next.meetingConsumer = mcRec;
                 if (entryChanged) {
                     compactVcMeetingAgentEntry(entry, next);
                     changed = true;
@@ -596,8 +625,13 @@ async function syncVcMeetingListenerBotConfig(listenerBotAppId, previousListener
                     }
                 }
             }
-            if (changed)
+            if (changed) {
+                // Validate the complete post-mutation file before replacing bots.json.
+                // Keep this path symmetric with daemon bootstrap so a future generated
+                // default cannot make the Dashboard persist an invalid registry.
+                parseBotConfigsFromText(JSON.stringify(raw));
                 await writeRawConfigAtomic(path, raw);
+            }
         });
     }
     catch (err) {
@@ -647,7 +681,7 @@ function resolveDashboardSettings() {
 // `PUT /api/settings` route and (PR2 C6) the HMAC-gated `PUT /__daemon/settings-write`
 // route call through this so error codes / merge semantics stay identical.
 async function reloadLocaleOnAllDaemons() {
-    await Promise.all(registry.list().map(d => fetch(`http://127.0.0.1:${d.ipcPort}/api/locale/reload`, { method: 'POST' }).catch(() => undefined)));
+    await Promise.all(registry.list().map(d => fetchDaemonIpc(d.ipcPort, '/api/locale/reload', { method: 'POST' }).catch(() => undefined)));
 }
 const settingsWriteApplierDeps = defaultSettingsWriteApplierDeps(resolveDashboardSettings, reloadLocaleOnAllDaemons);
 settingsWriteApplierDeps.syncVcMeetingListenerBotConfig = syncVcMeetingListenerBotConfig;
@@ -667,6 +701,7 @@ const groupsActionDeps = {
     registryGetByAppId: (id) => registry.getByAppId(id),
     proxyToDaemon,
     closeSessionsMatching,
+    fetch: fetchDaemonUrl,
 };
 // ─── PR2 C8: Route B internal API (`/__daemon/*`) ───────────────────────────
 // HMAC + loopback + ts ±60s + nonce TTL, signed-request envelope = full
@@ -689,15 +724,6 @@ const daemonInternalApi = createDaemonInternalApi({
     buildGroupsMatrix,
     settingsApplierDeps: settingsWriteApplierDeps,
     groupsActionDeps,
-    workflowsActionDeps: defaultWorkflowsActionDeps({
-        runsDir: getRunsDir(),
-        proxyToDaemon,
-        listRuns: listRunsImpl,
-        readRunSnapshot: readRunSnapshotImpl,
-        scrubSnapshotForUnauthed: scrubSnapshotImpl,
-        TERMINAL_RUN_STATUSES: TERMINAL_RUN_STATUSES_IMPL,
-        isValidRunId: isValidRunIdImpl,
-    }),
     proxyToDaemon,
     ownerOf: (sid) => aggregator.ownerOf(sid),
     scheduleOwnerOf: (id) => aggregator.scheduleOwnerOf(id),
@@ -745,7 +771,7 @@ async function cachedChangelog(current, now = Date.now()) {
     return value;
 }
 /**
- * Run the ownership-aware npm/pnpm update for the manual-update flow WITHOUT blocking
+ * Run the ownership-aware npm/pnpm/Bun update for the manual-update flow WITHOUT blocking
  * the event loop (async spawn, not execSync — the dashboard must keep serving
  * during the ~10-30s install). Resolves on exit 0; rejects with the tail of
  * stdout/stderr on a non-zero exit, spawn error, or 3-minute timeout. Args are
@@ -755,9 +781,9 @@ function runGlobalInstallLatest(plan) {
     return new Promise((resolve, reject) => {
         const child = spawn(plan.command, plan.args, {
             cwd: globalInstallUpdateCwd(),
-            env: process.env,
+            env: { ...process.env, ...plan.env },
             stdio: ['ignore', 'pipe', 'pipe'],
-            shell: process.platform === 'win32', // resolve npm.cmd / pnpm.cmd
+            shell: process.platform === 'win32', // resolve npm.cmd / pnpm.cmd / bun.exe
         });
         let tail = '';
         const capture = (d) => { tail = (tail + d.toString()).slice(-2000); };
@@ -795,8 +821,8 @@ async function attachDaemon(d) {
         // 1. Hydrate snapshot (blocking — completes before we wire SSE)
         try {
             const [sRes, schRes] = await Promise.all([
-                fetch(`http://127.0.0.1:${d.ipcPort}/api/sessions`),
-                fetch(`http://127.0.0.1:${d.ipcPort}/api/schedules`),
+                fetchDaemonIpc(d.ipcPort, '/api/sessions'),
+                fetchDaemonIpc(d.ipcPort, '/api/schedules'),
             ]);
             const s = await sRes.json();
             const sch = await schRes.json();
@@ -808,7 +834,7 @@ async function attachDaemon(d) {
         }
         // 2. Open SSE subscription if not already (idempotent)
         if (!subs.has(d.larkAppId)) {
-            subs.set(d.larkAppId, subscribeDaemon(d, aggregator, e => logger.warn(`[aggregator] ${d.larkAppId}: ${e.message}`)));
+            subs.set(d.larkAppId, subscribeDaemon(d, aggregator, e => logger.warn(`[aggregator] ${d.larkAppId}: ${e.message}`), (_url, init) => fetchDaemonIpc(d.ipcPort, '/api/events', init)));
         }
     }
     finally {
@@ -1306,7 +1332,84 @@ async function proxyToDaemon(larkAppId, daemonPath, init) {
             headers: { 'content-type': 'application/json' },
         });
     }
-    return fetch(`http://127.0.0.1:${d.ipcPort}${daemonPath}`, init);
+    const method = String(init.method ?? 'GET').toUpperCase();
+    const workflowPathTail = daemonPath.startsWith(`${WORKFLOW_DAEMON_IPC_ROUTE_PREFIX}/`)
+        ? daemonPath.slice(WORKFLOW_DAEMON_IPC_ROUTE_PREFIX.length + 1)
+        : '';
+    const isWorkflowMutation = method === 'POST' &&
+        /^[^/]+\/(?:start|cancel|retry|grant)(?:\?.*)?$/.test(workflowPathTail);
+    if (!isWorkflowMutation) {
+        // Non-workflow routes ride the shared trusted-host wrapper (route-bound
+        // X-Botmux-Cli-* HMAC). Workflow mutations keep the domain-separated
+        // full-envelope protocol below; the daemon admits that prefix through its
+        // narrow capability aperture and the handler fail-closes on the envelope.
+        return fetchDaemonIpc(d.ipcPort, daemonPath, init);
+    }
+    if (d.workflowIpcProtocol !== 'v1' || !d.bootInstanceId) {
+        return new Response(JSON.stringify({
+            ok: false,
+            error: 'daemon_upgrade_required',
+            message: 'target daemon does not advertise Workflow IPC v1; upgrade and restart all botmux processes',
+        }), { status: 503, headers: { 'content-type': 'application/json' } });
+    }
+    const bodyRaw = init.body === undefined || init.body === null
+        ? ''
+        : typeof init.body === 'string'
+            ? init.body
+            : (() => { throw new Error('Workflow daemon mutation body must be a pre-serialized string'); })();
+    const target = {
+        larkAppId: d.larkAppId,
+        ipcPort: d.ipcPort,
+        bootInstanceId: d.bootInstanceId,
+    };
+    const authHeaders = workflowDaemonIpcHeaders({
+        secret: SECRET,
+        method,
+        pathWithQuery: daemonPath,
+        bodyRaw,
+        target,
+    });
+    const workflowResponseAuth = {
+        nonce: authHeaders['X-Botmux-Workflow-Ipc-Nonce'],
+        target,
+    };
+    const headers = new Headers(init.headers);
+    for (const [key, value] of Object.entries(authHeaders)) {
+        headers.set(key, value);
+    }
+    const upstream = await fetch(`http://127.0.0.1:${d.ipcPort}${daemonPath}`, { ...init, headers });
+    const responseBody = await upstream.text();
+    const authenticated = verifyWorkflowDaemonIpcResponse({
+        secret: SECRET,
+        requestNonce: workflowResponseAuth.nonce,
+        method,
+        pathWithQuery: daemonPath,
+        status: upstream.status,
+        body: responseBody,
+        target: workflowResponseAuth.target,
+        signature: upstream.headers.get('x-botmux-workflow-ipc-response-signature'),
+    });
+    if (!authenticated) {
+        return new Response(JSON.stringify({
+            ok: false,
+            error: 'daemon_response_unauthenticated',
+            message: 'target daemon response did not verify as Workflow IPC v1',
+        }), { status: 502, headers: { 'content-type': 'application/json' } });
+    }
+    return new Response(responseBody, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: upstream.headers,
+    });
+}
+/** Authenticated adapter for helpers that receive a discovered daemon URL. */
+function fetchDaemonUrl(input, init) {
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    const port = Number(url.port);
+    if (url.hostname !== '127.0.0.1' || !Number.isSafeInteger(port) || port <= 0) {
+        return Promise.reject(new Error('daemon helper attempted a non-loopback URL'));
+    }
+    return fetchDaemonIpc(port, `${url.pathname}${url.search}`, init);
 }
 /** Create a Feishu group from the team UI: pick a creator daemon among the
  *  selected bots, proxy to its /api/groups/create, invite the requesting user.
@@ -1461,7 +1564,7 @@ async function createLifecycleGroupForWebhook(connector, args) {
     const allowed = creator.resolvedAllowedUsers ?? [];
     const ownerUnionIds = allowed.filter(u => u.startsWith('on_'));
     const userOpenIds = allowed.filter(u => u.startsWith('ou_'));
-    const upstream = await fetch(`http://127.0.0.1:${creator.ipcPort}/api/groups/create`, {
+    const upstream = await fetchDaemonIpc(creator.ipcPort, '/api/groups/create', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({
@@ -1497,7 +1600,7 @@ async function buildGroupsMatrix() {
         .sort((a, b) => a.botIndex - b.botIndex);
     await Promise.all(onlineBots.map(async (d) => {
         try {
-            const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/groups`);
+            const r = await fetchDaemonIpc(d.ipcPort, '/api/groups');
             if (!r.ok)
                 return;
             const j = await r.json();
@@ -1732,7 +1835,7 @@ async function dashboardSkillReferencesMany(skillNames) {
     const onlineBots = [...registry.list()].sort((a, b) => a.botIndex - b.botIndex);
     const onlineConfigs = await Promise.all(onlineBots.map(async (d) => {
         try {
-            const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/bot-default-oncall`, {
+            const r = await fetchDaemonIpc(d.ipcPort, '/api/bot-default-oncall', {
                 signal: AbortSignal.timeout(1_500),
             });
             if (!r.ok)
@@ -1788,8 +1891,8 @@ const server = createServer(async (req, res) => {
         // proxy on proxyBasePort+idx), so we resolve the session's owning daemon's
         // proxy port from the aggregator rows and forward there, streaming the
         // response straight back. Mounted before the dashboard auth gate because the
-        // terminal proxy / worker enforces its own write gate (read-only without
-        // token / platform role).
+        // worker independently requires a view/write capability or authenticated
+        // dashboard cookie before serving either HTTP or WebSocket terminal data.
         if (url.pathname === '/s' || url.pathname.startsWith('/s/')) {
             const sessionId = parseTerminalSessionId(url.pathname);
             const tport = sessionId ? aggregator.terminalProxyPortOf(sessionId) : undefined;
@@ -1892,11 +1995,8 @@ const server = createServer(async (req, res) => {
             activeToken: activeToken ?? '',
             publicReadOnly: dashboardSettings.publicReadOnly,
         });
-        // `authed` is consumed by route handlers that need to distinguish
-        // "request got in via public-read carve-out" from "request has a
-        // valid cookie" — e.g. `/api/workflows/runs/<id>/snapshot` strips
-        // log bytes when unauth'd.  Mirror of the `authed` check in
-        // `decideDashboardAuth`.
+        // `authed` is consumed by route handlers that distinguish the public-read
+        // carve-out from a valid management cookie (notably v3 run details).
         const authed = !!presentedToken && presentedToken === activeToken && !!activeToken;
         if (decision.kind === 'deny401') {
             res.writeHead(401, { 'content-type': 'text/html; charset=utf-8' });
@@ -1911,6 +2011,13 @@ const server = createServer(async (req, res) => {
             res.end();
             return;
         }
+        if (url.pathname === '/api/workflows' || url.pathname.startsWith('/api/workflows/')) {
+            return jsonRes(res, 410, {
+                ok: false,
+                error: 'legacy_workflow_retired',
+                message: 'v2 workflow dashboard APIs are retired; use /api/v3/runs for v3 run visibility',
+            });
+        }
         if (req.method === 'GET' && url.pathname === '/__dev/reload') {
             if (!dashboardDevReloadEnabled())
                 return jsonRes(res, 404, { error: 'dev_reload_disabled' });
@@ -2744,7 +2851,7 @@ const server = createServer(async (req, res) => {
             const owner = aggregator.ownerOf(sid);
             if (!owner)
                 return jsonRes(res, 404, { ok: false, error: 'unknown_session' });
-            const upstream = await proxyToDaemon(owner, `/api/sessions/${sid}/write-link`, { method: 'GET', headers: signDaemonTokenHeaders() });
+            const upstream = await proxyToDaemon(owner, `/api/sessions/${sid}/write-link`, { method: 'GET' });
             res.writeHead(upstream.status, { 'content-type': 'application/json' });
             res.end(await upstream.text());
             return;
@@ -2782,25 +2889,15 @@ const server = createServer(async (req, res) => {
             res.end(await upstream.text());
             return;
         }
-        // ─── Workflows (D0 read-only + D1 cancel mutation) ───────────────────────
-        //
-        // Dashboard reads runsDir directly (single-process; cross-daemon ownership
-        // doesn't matter for read-only).  All readers in `ops-projection` are
-        // pure: no mkdir, no EventLog instantiation.  Unknown / corrupt run → 404.
-        // Mutations are intentionally proxied to the owner daemon from
-        // chat-binding.larkAppId so only the daemon with live workflow runtime
-        // context writes the event log.
-        if (await handleWorkflowApi(req, res, url, {
-            runsDir: getRunsDir(),
+        // v3 workflow runs. Reads project directly from disk; cancel resolves the
+        // immutable run owner and proxies to that daemon (the dashboard never
+        // writes the v3 journal itself).
+        if (await handleV3RunsApi(req, res, url, {
+            runsDir: v3RunsDir(),
             proxyToDaemon,
         }, authed)) {
             return;
         }
-        // v3 workflow runs (read-only DAG + per-node terminal projection).  Reads
-        // the v3 run dirs directly; no daemon proxy (v3 runs are plain files).
-        if (await handleV3RunsApi(req, res, url, { runsDir: v3RunsDir() }, authed)) {
-            return;
-        }
         // ─── Groups (Phase B) ────────────────────────────────────────────────────
         if (req.method === 'GET' && url.pathname === '/api/groups') {
             // Fan out via the shared `buildGroupsMatrix` helper so the browser
@@ -2864,11 +2961,30 @@ const server = createServer(async (req, res) => {
             }
         }
         // ─── Profiles (aggregate/proxy to daemon) ─────────────────────────────
+        // ─── 会议角色预设（私有 API：不在 PUBLIC_READ_PATHS，未认证已被 401） ───
+        if (url.pathname === '/api/vc-meeting/consumer-profiles') {
+            if (req.method === 'GET') {
+                const out = await handleVcMeetingConsumerProfilesGet(url.searchParams.get('listenerBotAppId') ?? '', vcMeetingConsumerProfilesApiDeps());
+                return jsonRes(res, out.status, out.body);
+            }
+            if (req.method === 'PUT') {
+                let parsed;
+                try {
+                    parsed = await readJsonBody(req);
+                }
+                catch {
+                    return jsonRes(res, 400, { ok: false, error: 'bad_json' });
+                }
+                const out = await handleVcMeetingConsumerProfilesPut(parsed, vcMeetingConsumerProfilesApiDeps());
+                return jsonRes(res, out.status, out.body);
+            }
+            return jsonRes(res, 405, { ok: false, error: 'method_not_allowed' });
+        }
         if (req.method === 'GET' && url.pathname === '/api/role-profiles') {
             const merged = new Map();
             await Promise.all(registry.list().map(async (d) => {
                 try {
-                    const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/role-profiles`);
+                    const r = await fetchDaemonIpc(d.ipcPort, '/api/role-profiles');
                     if (!r.ok)
                         return;
                     const j = await r.json();
@@ -2967,7 +3083,7 @@ const server = createServer(async (req, res) => {
             const byBot = new Map();
             await Promise.all(registry.list().map(async (d) => {
                 try {
-                    const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/role-profiles/${encodeURIComponent(profileId)}`);
+                    const r = await fetchDaemonIpc(d.ipcPort, `/api/role-profiles/${encodeURIComponent(profileId)}`);
                     if (!r.ok)
                         return;
                     const j = await r.json();
@@ -3068,7 +3184,7 @@ const server = createServer(async (req, res) => {
             const onlineBots = [...registry.list()].map(b => withConfiguredCliId(b, agentFields)).sort((a, b) => a.botIndex - b.botIndex);
             const out = await Promise.all(onlineBots.map(async (d) => {
                 try {
-                    const r = await fetch(`http://127.0.0.1:${d.ipcPort}/api/bot-default-oncall`);
+                    const r = await fetchDaemonIpc(d.ipcPort, '/api/bot-default-oncall');
                     if (!r.ok) {
                         return botDefaultsPayload(d, undefined, `http_${r.status}`);
                     }
@@ -3536,7 +3652,7 @@ const server = createServer(async (req, res) => {
                     : undefined,
                 roleProfileId: roleProfileId ?? undefined,
             };
-            const upstream = await fetch(`http://127.0.0.1:${creator.ipcPort}/api/groups/create`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(forwardBody) });
+            const upstream = await fetchDaemonIpc(creator.ipcPort, '/api/groups/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(forwardBody) });
             const upstreamText = await upstream.text();
             let upstreamJson = null;
             try {