@exaudeus/workrail 3.18.0 → 3.19.0

package/dist/v2/usecases/console-routes.js

@@ -8,6 +8,7 @@ const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const worktree_service_js_1 = require("./worktree-service.js");
+const workflow_js_1 = require("../../types/workflow.js");
 const dev_mode_js_1 = require("../../mcp/dev-mode.js");
 function watchSessionsDir(sessionsDir, onChanged) {
     try {
@@ -52,7 +53,7 @@ function loadWorkflowTags() {
         return { version: 0, tags: [], workflows: {} };
     }
 }
-function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuffer) {
+function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuffer, toolCallsPerfFile, serverVersion) {
     const sseClients = new Set();
     let sseDebounceTimer = null;
     function broadcastChange() {
@@ -71,6 +72,22 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
         }, 200);
     }
     const stopWatcher = watchSessionsDir(consoleService.getSessionsDir(), broadcastChange);
+    let enrichmentBroadcastTimer = null;
+    (0, worktree_service_js_1.setEnrichmentCompleteCallback)(() => {
+        if (enrichmentBroadcastTimer !== null)
+            clearTimeout(enrichmentBroadcastTimer);
+        enrichmentBroadcastTimer = setTimeout(() => {
+            enrichmentBroadcastTimer = null;
+            for (const client of sseClients) {
+                try {
+                    client.write('data: {"type":"worktrees-updated"}\n\n');
+                }
+                catch {
+                    sseClients.delete(client);
+                }
+            }
+        }, 2000);
+    });
     app.get('/api/v2/workspace/events', (req, res) => {
         res.setHeader('Content-Type', 'text/event-stream');
         res.setHeader('Cache-Control', 'no-cache');
@@ -82,14 +99,71 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
         req.on('close', () => { sseClients.delete(res); });
         res.on('close', () => { sseClients.delete(res); });
     });
+    const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+    const PERF_FILE_READ_LIMIT_BYTES = 5 * 1024 * 1024;
+    async function readDiskEntries(perfFile) {
+        try {
+            const stat = await fs_1.default.promises.stat(perfFile);
+            let raw;
+            if (stat.size > PERF_FILE_READ_LIMIT_BYTES) {
+                const fd = await fs_1.default.promises.open(perfFile, 'r');
+                const offset = stat.size - PERF_FILE_READ_LIMIT_BYTES;
+                const buf = Buffer.alloc(PERF_FILE_READ_LIMIT_BYTES);
+                await fd.read(buf, 0, PERF_FILE_READ_LIMIT_BYTES, offset);
+                await fd.close();
+                raw = buf.toString('utf8');
+            }
+            else {
+                raw = await fs_1.default.promises.readFile(perfFile, 'utf8');
+            }
+            const cutoff = Date.now() - THIRTY_DAYS_MS;
+            return raw
+                .split('\n')
+                .filter(Boolean)
+                .flatMap((line) => {
+                try {
+                    const entry = JSON.parse(line);
+                    if (typeof entry.toolName !== 'string' ||
+                        typeof entry.startedAtMs !== 'number' ||
+                        typeof entry.durationMs !== 'number' ||
+                        (entry.outcome !== 'success' && entry.outcome !== 'error' && entry.outcome !== 'unknown_tool'))
+                        return [];
+                    const safeEntry = typeof entry.serverVersion === 'string'
+                        ? entry
+                        : { ...entry, serverVersion: 'unknown' };
+                    if (safeEntry.startedAtMs < cutoff)
+                        return [];
+                    return [safeEntry];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
     const devMode = (0, dev_mode_js_1.isDevMode)();
     if (devMode) {
-        app.get('/api/v2/perf/tool-calls', (req, res) => {
+        app.get('/api/v2/perf/tool-calls', async (req, res) => {
             const rawLimit = req.query['limit'];
             const limit = typeof rawLimit === 'string' ? parseInt(rawLimit, 10) : undefined;
             const safeLimit = (limit !== undefined && Number.isFinite(limit) && limit > 0) ? limit : undefined;
-            const observations = timingRingBuffer ? timingRingBuffer.recent(safeLimit) : [];
-            res.json({ success: true, data: { observations, total: timingRingBuffer?.size ?? 0, devMode } });
+            const diskEntries = toolCallsPerfFile ? await readDiskEntries(toolCallsPerfFile) : [];
+            const ringEntries = timingRingBuffer ? timingRingBuffer.recent(safeLimit) : [];
+            const version = serverVersion ?? 'unknown';
+            const ringEntriesWithVersion = ringEntries.map((t) => ({
+                ...t,
+                serverVersion: version,
+            }));
+            const dedupeKey = (e) => `${e.toolName}:${e.startedAtMs}:${e.durationMs}`;
+            const inMemoryKeys = new Set(ringEntriesWithVersion.map(dedupeKey));
+            const diskOnlyEntries = diskEntries.filter((e) => !inMemoryKeys.has(dedupeKey(e)));
+            const allEntries = [...ringEntriesWithVersion, ...diskOnlyEntries]
+                .sort((a, b) => b.startedAtMs - a.startedAtMs)
+                .slice(0, safeLimit ?? undefined);
+            res.json({ success: true, data: { observations: allEntries, devMode } });
         });
     }
     app.get('/api/v2/sessions', async (_req, res) => {
@@ -97,35 +171,66 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
         result.match((data) => res.json({ success: true, data }), (error) => res.status(500).json({ success: false, error: error.message }));
     });
     let cwdRepoRootPromise = null;
-    const REPO_ROOTS_TTL_MS = 60000;
-    const REPO_ROOT_SESSION_STALENESS_MS = 30 * 24 * 60 * 60 * 1000;
     let cachedRepoRoots = [];
     let repoRootsExpiresAt = 0;
+    const REPO_ROOTS_TTL_MS = 60000;
+    async function discoverMainRepoRoots() {
+        const dataDir = process.env['WORKRAIL_DATA_DIR']
+            ?? path_1.default.join(process.env.HOME ?? '/tmp', '.workrail', 'data');
+        const rootsFile = path_1.default.join(dataDir, 'workflow-sources', 'remembered-roots.json');
+        let workspacePaths = [];
+        try {
+            const raw = await fs_1.default.promises.readFile(rootsFile, 'utf8');
+            const parsed = JSON.parse(raw);
+            workspacePaths = (parsed.roots ?? []).map((r) => r.path).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+        const resolved = await Promise.all(workspacePaths.map((p) => (0, worktree_service_js_1.resolveRepoRoot)(p)));
+        const roots = new Set(resolved.filter((r) => r !== null));
+        return [...roots];
+    }
+    const WORKTREES_REQUEST_TIMEOUT_MS = 12000;
     app.get('/api/v2/worktrees', async (_req, res) => {
+        let timeoutId = null;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error('worktrees scan timeout')), WORKTREES_REQUEST_TIMEOUT_MS);
+        });
         try {
             const sessionResult = await consoleService.getSessionList();
             const sessions = sessionResult.isOk() ? sessionResult.value.sessions : [];
             const activeSessions = (0, worktree_service_js_1.buildActiveSessionCounts)(sessions);
+            cwdRepoRootPromise ?? (cwdRepoRootPromise = (0, worktree_service_js_1.resolveRepoRoot)(process.cwd()));
             if (Date.now() > repoRootsExpiresAt) {
-                cwdRepoRootPromise ?? (cwdRepoRootPromise = (0, worktree_service_js_1.resolveRepoRoot)(process.cwd()));
-                const cwdRoot = await cwdRepoRootPromise;
-                const cutoffMs = Date.now() - REPO_ROOT_SESSION_STALENESS_MS;
-                const rawRoots = sessions
-                    .filter(s => s.lastModifiedMs >= cutoffMs)
-                    .map(s => s.repoRoot)
-                    .filter((r) => r !== null);
-                const resolvedRoots = await Promise.all(rawRoots.map(r => (0, worktree_service_js_1.resolveRepoRoot)(r)));
-                const repoRootSet = new Set(resolvedRoots.filter((r) => r !== null));
+                const [cwdRoot, discovered] = await Promise.all([
+                    cwdRepoRootPromise,
+                    discoverMainRepoRoots(),
+                ]);
+                const repoRootsSet = new Set(discovered);
                 if (cwdRoot !== null)
-                    repoRootSet.add(cwdRoot);
-                cachedRepoRoots = [...repoRootSet];
+                    repoRootsSet.add(cwdRoot);
+                cachedRepoRoots = [...repoRootsSet];
                 repoRootsExpiresAt = Date.now() + REPO_ROOTS_TTL_MS;
             }
-            const data = await (0, worktree_service_js_1.getWorktreeList)(cachedRepoRoots, activeSessions);
+            const repoRoots = cachedRepoRoots;
+            const data = await Promise.race([
+                (0, worktree_service_js_1.getWorktreeList)(repoRoots, activeSessions),
+                timeoutPromise,
+            ]);
+            if (timeoutId !== null)
+                clearTimeout(timeoutId);
             res.json({ success: true, data });
         }
         catch (e) {
-            res.status(500).json({ success: false, error: e instanceof Error ? e.message : String(e) });
+            if (timeoutId !== null)
+                clearTimeout(timeoutId);
+            if (e instanceof Error && e.message === 'worktrees scan timeout') {
+                res.json({ success: true, data: { repos: [] } });
+            }
+            else {
+                res.status(500).json({ success: false, error: e instanceof Error ? e.message : String(e) });
+            }
         }
     });
     app.get('/api/v2/sessions/:sessionId', async (req, res) => {
@@ -162,7 +267,7 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
                         description: definition.description,
                         version: definition.version,
                         tags: tagEntry?.tags ?? [],
-                        source,
+                        source: (0, workflow_js_1.toWorkflowSourceInfo)(source),
                         ...(definition.about !== undefined ? { about: definition.about } : {}),
                         ...(definition.examples?.length ? { examples: [...definition.examples] } : {}),
                     };
@@ -194,7 +299,7 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
                         description: definition.description,
                         version: definition.version,
                         tags: tagEntry?.tags ?? [],
-                        source,
+                        source: (0, workflow_js_1.toWorkflowSourceInfo)(source),
                         stepCount: definition.steps.length,
                         ...(definition.about !== undefined ? { about: definition.about } : {}),
                         ...(definition.examples?.length ? { examples: [...definition.examples] } : {}),

package/dist/v2/usecases/console-service.js

@@ -16,7 +16,10 @@ const run_execution_trace_js_1 = require("../projections/run-execution-trace.js"
 const constants_js_1 = require("../durable-core/constants.js");
 const index_js_1 = require("../durable-core/ids/index.js");
 const MAX_SESSIONS_TO_LOAD = 500;
-const DORMANCY_THRESHOLD_MS = 3 * 24 * 60 * 60 * 1000;
+const DORMANCY_THRESHOLD_MS = (() => {
+    const override = parseInt(process.env['WORKRAIL_DORMANCY_THRESHOLD_MS'] ?? '', 10);
+    return Number.isFinite(override) && override > 0 ? override : 60 * 60 * 1000;
+})();
 class ConsoleService {
     constructor(ports) {
         this.ports = ports;
@@ -337,16 +340,6 @@ function extractGitBranch(events) {
     }
     return null;
 }
-function extractRepoRoot(events) {
-    for (const e of events) {
-        if (e.kind !== constants_js_1.EVENT_KIND.OBSERVATION_RECORDED)
-            continue;
-        if (e.data.key === 'repo_root') {
-            return e.data.value.value;
-        }
-    }
-    return null;
-}
 function truncateTitle(text, maxLen = 120) {
     if (text.length <= maxLen)
         return text;
@@ -373,7 +366,6 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
     const gapsRes = sortedEventsRes.isOk() ? (0, gaps_js_1.projectGapsV2)(sortedEventsRes.value) : (0, neverthrow_2.err)(sortedEventsRes.error);
     const sessionTitle = sortedEventsRes.isOk() ? deriveSessionTitle(sortedEventsRes.value) : null;
     const gitBranch = extractGitBranch(events);
-    const repoRoot = extractRepoRoot(events);
     const runs = Object.values(dag.runsById);
     const run = runs[0];
     if (!run) {
@@ -393,7 +385,6 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
             hasUnresolvedGaps: false,
             recapSnippet: null,
             gitBranch,
-            repoRoot,
             lastModifiedMs,
         };
     }
@@ -436,7 +427,6 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
         hasUnresolvedGaps,
         recapSnippet,
         gitBranch,
-        repoRoot,
         lastModifiedMs,
     };
 }

package/dist/v2/usecases/console-types.d.ts

@@ -16,7 +16,6 @@ export interface ConsoleSessionSummary {
     readonly hasUnresolvedGaps: boolean;
     readonly recapSnippet: string | null;
     readonly gitBranch: string | null;
-    readonly repoRoot: string | null;
     readonly lastModifiedMs: number;
 }
 export interface ConsoleSessionListResponse {
@@ -112,6 +111,20 @@ export interface ChangedFile {
     readonly status: FileChangeStatus;
     readonly path: string;
 }
+export interface WorktreeEnrichment {
+    readonly headHash: string;
+    readonly headMessage: string;
+    readonly headTimestampMs: number;
+    readonly changedCount: number;
+    readonly changedFiles: readonly ChangedFile[];
+    readonly aheadCount: number;
+    readonly unpushedCommits: readonly {
+        readonly hash: string;
+        readonly message: string;
+    }[];
+    readonly isMerged: boolean;
+    readonly description: string;
+}
 export interface ConsoleWorktreeSummary {
     readonly path: string;
     readonly name: string;
@@ -129,6 +142,7 @@ export interface ConsoleWorktreeSummary {
     readonly isMerged: boolean;
     readonly activeSessionCount: number;
     readonly description?: string;
+    readonly enrichment: WorktreeEnrichment | null;
 }
 export interface ConsoleRepoWorktrees {
     readonly repoName: string;

package/dist/v2/usecases/worktree-service.d.ts

@@ -7,4 +7,5 @@ export declare function buildActiveSessionCounts(sessions: ReadonlyArray<{
     gitBranch: string | null;
     status: ConsoleSessionStatus;
 }>): ActiveSessionsByBranch;
+export declare function setEnrichmentCompleteCallback(cb: () => void): void;
 export declare function getWorktreeList(repoRoots: readonly string[], activeSessions: ActiveSessionsByBranch): Promise<ConsoleWorktreeListResponse>;

package/dist/v2/usecases/worktree-service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRepoRoot = resolveRepoRoot;
 exports.buildActiveSessionCounts = buildActiveSessionCounts;
+exports.setEnrichmentCompleteCallback = setEnrichmentCompleteCallback;
 exports.getWorktreeList = getWorktreeList;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
@@ -9,7 +10,12 @@ const path_1 = require("path");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const GIT_TIMEOUT_MS = 5000;
 function isExecError(e) {
-    return e instanceof Error && 'killed' in e;
+    if (!(e instanceof Error))
+        return false;
+    if ('killed' in e)
+        return true;
+    const sys = e.syscall ?? '';
+    return sys.startsWith('spawn');
 }
 async function git(cwd, args) {
     try {
@@ -54,7 +60,7 @@ function acquireEnrichmentSlot() {
             resolve();
         }
         else {
-            enrichmentQueue.push(() => { activeEnrichments++; resolve(); });
+            enrichmentQueue.push(resolve);
         }
     });
 }
@@ -67,6 +73,29 @@ function releaseEnrichmentSlot() {
         activeEnrichments--;
     }
 }
+const MAX_BACKGROUND_ENRICHMENTS = 16;
+let activeBackgroundEnrichments = 0;
+const backgroundEnrichmentQueue = [];
+function acquireBackgroundSlot() {
+    return new Promise((resolve) => {
+        if (activeBackgroundEnrichments < MAX_BACKGROUND_ENRICHMENTS) {
+            activeBackgroundEnrichments++;
+            resolve();
+        }
+        else {
+            backgroundEnrichmentQueue.push(resolve);
+        }
+    });
+}
+function releaseBackgroundSlot() {
+    const next = backgroundEnrichmentQueue.shift();
+    if (next) {
+        next();
+    }
+    else {
+        activeBackgroundEnrichments--;
+    }
+}
 function parseFileStatus(xy) {
     if (xy === '??')
         return 'untracked';
@@ -122,8 +151,8 @@ async function enrichWorktree(wt) {
         wt.branch !== 'main' &&
         mergedBranchesRaw !== null &&
         mergedBranchesRaw.split('\n').some(line => line.trim() === wt.branch);
-    const branchDescription = descriptionRaw?.trim() ?? '';
-    return { headHash, headMessage, headTimestampMs, changedCount, changedFiles, aheadCount, unpushedCommits, isMerged, branchDescription };
+    const description = descriptionRaw?.trim() ?? '';
+    return { headHash, headMessage, headTimestampMs, changedCount, changedFiles, aheadCount, unpushedCommits, isMerged, description };
 }
 async function resolveRepoRoot(path) {
     const commonDir = await git(path, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
@@ -131,18 +160,39 @@ async function resolveRepoRoot(path) {
         return null;
     return commonDir.replace(/\/\.git\/?$/, '') || null;
 }
-async function enrichRepo(repoRoot, activeSessions) {
+async function buildFastWorktrees(repoRoot) {
+    const porcelain = await git(repoRoot, ['worktree', 'list', '--porcelain']);
+    if (porcelain === null)
+        return null;
+    const rawWorktrees = parseWorktreePorcelain(porcelain);
+    return rawWorktrees.map((wt) => ({
+        path: wt.path,
+        name: (0, path_1.basename)(wt.path),
+        branch: wt.branch,
+        headHash: wt.head.slice(0, 7),
+        headMessage: '',
+        headTimestampMs: 0,
+        changedCount: 0,
+        changedFiles: [],
+        aheadCount: 0,
+        unpushedCommits: [],
+        isMerged: false,
+        activeSessionCount: 0,
+        enrichment: null,
+    }));
+}
+async function enrichRepo(repoRoot) {
     const porcelain = await git(repoRoot, ['worktree', 'list', '--porcelain']);
     if (porcelain === null)
         return null;
     const rawWorktrees = parseWorktreePorcelain(porcelain);
     const results = await Promise.allSettled(rawWorktrees.map(async (wt) => {
-        await acquireEnrichmentSlot();
+        await acquireBackgroundSlot();
         try {
             return await enrichWorktree(wt);
         }
         finally {
-            releaseEnrichmentSlot();
+            releaseBackgroundSlot();
         }
     }));
     const worktrees = rawWorktrees.flatMap((wt, i) => {
@@ -152,6 +202,17 @@ async function enrichRepo(repoRoot, activeSessions) {
             return [];
         }
         const e = result.value;
+        const enrichment = {
+            headHash: e.headHash,
+            headMessage: e.headMessage,
+            headTimestampMs: e.headTimestampMs,
+            changedCount: e.changedCount,
+            changedFiles: e.changedFiles,
+            aheadCount: e.aheadCount,
+            unpushedCommits: e.unpushedCommits,
+            isMerged: e.isMerged,
+            description: e.description,
+        };
         return [{
                 path: wt.path,
                 name: (0, path_1.basename)(wt.path),
@@ -164,13 +225,12 @@ async function enrichRepo(repoRoot, activeSessions) {
                 aheadCount: e.aheadCount,
                 unpushedCommits: e.unpushedCommits,
                 isMerged: e.isMerged,
-                activeSessionCount: wt.branch ? (activeSessions.counts.get(wt.branch) ?? 0) : 0,
-                ...(e.branchDescription ? { description: e.branchDescription } : {}),
+                activeSessionCount: 0,
+                ...(e.description ? { description: e.description } : {}),
+                enrichment,
             }];
     });
     return [...worktrees].sort((a, b) => {
-        if (b.activeSessionCount !== a.activeSessionCount)
-            return b.activeSessionCount - a.activeSessionCount;
         if (b.changedCount !== a.changedCount)
             return b.changedCount - a.changedCount;
         return b.headTimestampMs - a.headTimestampMs;
@@ -185,12 +245,20 @@ function buildActiveSessionCounts(sessions) {
     }
     return { counts };
 }
-async function getWorktreeList(repoRoots, activeSessions) {
+const WORKTREE_CACHE_TTL_MS = 45000;
+let worktreeCache = null;
+let backgroundEnrichmentInFlight = false;
+const BACKGROUND_ENRICHMENT_TIMEOUT_MS = 120000;
+let onEnrichmentComplete = null;
+function setEnrichmentCompleteCallback(cb) {
+    onEnrichmentComplete = cb;
+}
+async function scanRepos(repoRoots) {
     const repoResults = await Promise.allSettled(repoRoots.map(async (repoRoot) => {
-        const worktrees = await enrichRepo(repoRoot, activeSessions);
+        const worktrees = await enrichRepo(repoRoot);
         return { repoRoot, worktrees };
     }));
-    const repos = repoResults.flatMap((result) => {
+    return repoResults.flatMap((result) => {
         if (result.status === 'rejected') {
             console.warn(`[WorktreeService] Failed to enrich repo:`, result.reason);
             return [];
@@ -204,7 +272,33 @@ async function getWorktreeList(repoRoots, activeSessions) {
                 worktrees,
             }];
     });
-    const sortedRepos = [...repos].sort((a, b) => {
+}
+async function runBackgroundEnrichment(repoRoots, repoRootsKey) {
+    try {
+        const enriched = await Promise.race([
+            scanRepos(repoRoots),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('background enrichment timeout')), BACKGROUND_ENRICHMENT_TIMEOUT_MS)),
+        ]);
+        if (worktreeCache?.repoRootsKey === repoRootsKey) {
+            worktreeCache = { ...worktreeCache, enrichedRepos: enriched };
+            onEnrichmentComplete?.();
+        }
+    }
+    catch {
+    }
+    finally {
+        backgroundEnrichmentInFlight = false;
+    }
+}
+function applyActiveSessionsAndSort(repos, activeSessions) {
+    const reposWithActiveSessions = repos.map((repo) => ({
+        ...repo,
+        worktrees: repo.worktrees.map((wt) => ({
+            ...wt,
+            activeSessionCount: wt.branch ? (activeSessions.counts.get(wt.branch) ?? 0) : 0,
+        })),
+    }));
+    const sortedRepos = [...reposWithActiveSessions].sort((a, b) => {
         const aActive = a.worktrees.some(w => w.activeSessionCount > 0) ? 0 : 1;
         const bActive = b.worktrees.some(w => w.activeSessionCount > 0) ? 0 : 1;
         if (aActive !== bActive)
@@ -213,3 +307,37 @@ async function getWorktreeList(repoRoots, activeSessions) {
     });
     return { repos: sortedRepos };
 }
+async function getWorktreeList(repoRoots, activeSessions) {
+    const repoRootsKey = [...repoRoots].sort().join(',');
+    const nowMs = Date.now();
+    const isCacheValid = worktreeCache !== null &&
+        worktreeCache.repoRootsKey === repoRootsKey &&
+        nowMs - worktreeCache.cachedAtMs < WORKTREE_CACHE_TTL_MS;
+    if (!isCacheValid) {
+        const fastRepoResults = await Promise.allSettled(repoRoots.map(async (repoRoot) => {
+            const worktrees = await buildFastWorktrees(repoRoot);
+            return { repoRoot, worktrees };
+        }));
+        const fastRepos = fastRepoResults.flatMap((result) => {
+            if (result.status === 'rejected')
+                return [];
+            const { repoRoot, worktrees } = result.value;
+            if (!worktrees || worktrees.length === 0)
+                return [];
+            return [{ repoName: (0, path_1.basename)(repoRoot), repoRoot, worktrees }];
+        });
+        worktreeCache = {
+            unenrichedRepos: fastRepos,
+            enrichedRepos: null,
+            cachedAtMs: nowMs,
+            repoRootsKey,
+        };
+        if (!backgroundEnrichmentInFlight) {
+            backgroundEnrichmentInFlight = true;
+            void runBackgroundEnrichment(repoRoots, repoRootsKey);
+        }
+    }
+    const cache = worktreeCache;
+    const repos = cache.enrichedRepos ?? cache.unenrichedRepos;
+    return applyActiveSessionsAndSort(repos, activeSessions);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,8 @@
     "web"
   ],
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});\" && tsc -p tsconfig.build.json && npm run console:build",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});\" && tsc -p tsconfig.build.json && npm run console:build && node -e \"require('fs').chmodSync('dist/mcp-server.js',0o755)\"",
+    "prepack": "node -e \"require('fs').chmodSync('dist/mcp-server.js',0o755)\"",
     "console:build": "cd console && npm install && npm run build",
     "console:dev": "cd console && npm run dev",
     "build:all": "npm run build",