@exaudeus/workrail 3.11.2 → 3.13.0

package/dist/v2/infra/local/managed-source-store/index.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalManagedSourceStoreV2 = void 0;
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const neverthrow_1 = require("neverthrow");
+const MANAGED_SOURCE_LOCK_RETRY_MS = 250;
+const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
+const ManagedSourceRecordSchema = zod_1.z.object({
+    path: zod_1.z.string(),
+    addedAtMs: zod_1.z.number().int().nonnegative(),
+});
+const ManagedSourcesFileSchema = zod_1.z.object({
+    v: zod_1.z.literal(1),
+    sources: zod_1.z.array(ManagedSourceRecordSchema),
+});
+function mapFsToManagedSourceError(e) {
+    if (e.code === 'FS_ALREADY_EXISTS') {
+        return {
+            code: 'MANAGED_SOURCE_BUSY',
+            message: 'Managed sources are being updated by another WorkRail process.',
+            retry: { kind: 'retryable_after_ms', afterMs: MANAGED_SOURCE_LOCK_RETRY_MS },
+            lockPath: 'managed-sources.lock',
+        };
+    }
+    return { code: 'MANAGED_SOURCE_IO_ERROR', message: e.message };
+}
+function normalizeRecords(sources) {
+    const seen = new Set();
+    const normalized = [];
+    for (const source of sources) {
+        const normalizedPath = path_1.default.resolve(source.path);
+        if (seen.has(normalizedPath))
+            continue;
+        seen.add(normalizedPath);
+        normalized.push({ path: normalizedPath, addedAtMs: source.addedAtMs });
+    }
+    return normalized;
+}
+class LocalManagedSourceStoreV2 {
+    constructor(dataDir, fs) {
+        this.dataDir = dataDir;
+        this.fs = fs;
+    }
+    list() {
+        return this.readSources();
+    }
+    attach(sourcePath) {
+        const normalizedPath = path_1.default.resolve(sourcePath);
+        const nowMs = Date.now();
+        return this.withLock(() => this.readSources().andThen((sources) => {
+            const alreadyPresent = sources.some((s) => s.path === normalizedPath);
+            if (alreadyPresent)
+                return (0, neverthrow_1.okAsync)(undefined);
+            const next = [...sources, { path: normalizedPath, addedAtMs: nowMs }];
+            return this.persist(next);
+        }));
+    }
+    detach(sourcePath) {
+        const normalizedPath = path_1.default.resolve(sourcePath);
+        return this.withLock(() => this.readSources().andThen((sources) => {
+            const next = sources.filter((s) => s.path !== normalizedPath);
+            if (next.length === sources.length)
+                return (0, neverthrow_1.okAsync)(undefined);
+            return this.persist(next);
+        }));
+    }
+    readSources() {
+        const filePath = this.dataDir.managedSourcesPath();
+        return this.fs.readFileUtf8(filePath)
+            .orElse((e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return (0, neverthrow_1.okAsync)('');
+            return (0, neverthrow_1.errAsync)(mapFsToManagedSourceError(e));
+        })
+            .andThen((raw) => {
+            if (raw === '')
+                return (0, neverthrow_1.okAsync)([]);
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'MANAGED_SOURCE_CORRUPTION',
+                    message: `Invalid JSON in managed sources file: ${filePath}`,
+                });
+            }
+            const validated = ManagedSourcesFileSchema.safeParse(parsed);
+            if (!validated.success) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'MANAGED_SOURCE_CORRUPTION',
+                    message: `Managed sources file has invalid shape: ${filePath}`,
+                });
+            }
+            return (0, neverthrow_1.okAsync)(normalizeRecords(validated.data.sources));
+        });
+    }
+    persist(sources) {
+        const filePath = this.dataDir.managedSourcesPath();
+        const dir = path_1.default.dirname(filePath);
+        const tmpPath = `${filePath}.tmp`;
+        const fileValue = {
+            v: 1,
+            sources: [...normalizeRecords(sources)],
+        };
+        const canonical = (0, jcs_js_1.toCanonicalBytes)(fileValue).mapErr((e) => ({
+            code: 'MANAGED_SOURCE_IO_ERROR',
+            message: `Failed to canonicalize managed sources state: ${e.message}`,
+        }));
+        if (canonical.isErr())
+            return (0, neverthrow_1.errAsync)(canonical.error);
+        const bytes = canonical.value;
+        return this.fs.mkdirp(dir)
+            .mapErr(mapFsToManagedSourceError)
+            .andThen(() => this.fs.openWriteTruncate(tmpPath).mapErr(mapFsToManagedSourceError))
+            .andThen(({ fd }) => this.fs.writeAll(fd, bytes)
+            .mapErr(mapFsToManagedSourceError)
+            .andThen(() => this.fs.fsyncFile(fd).mapErr(mapFsToManagedSourceError))
+            .andThen(() => this.fs.closeFile(fd).mapErr(mapFsToManagedSourceError))
+            .orElse((e) => this.fs.closeFile(fd)
+            .mapErr(() => e)
+            .andThen(() => (0, neverthrow_1.errAsync)(e))))
+            .andThen(() => this.fs.rename(tmpPath, filePath).mapErr(mapFsToManagedSourceError))
+            .andThen(() => this.fs.fsyncDir(dir).mapErr(mapFsToManagedSourceError));
+    }
+    withLock(run) {
+        const lockPath = this.dataDir.managedSourcesLockPath();
+        const dir = path_1.default.dirname(lockPath);
+        const lockBytes = new TextEncoder().encode(JSON.stringify({ v: 1, pid: process.pid }));
+        return this.fs.mkdirp(dir)
+            .mapErr(mapFsToManagedSourceError)
+            .andThen(() => this.fs.openExclusive(lockPath, lockBytes)
+            .mapErr((e) => {
+            const mapped = mapFsToManagedSourceError(e);
+            if (mapped.code === 'MANAGED_SOURCE_BUSY') {
+                return { ...mapped, lockPath };
+            }
+            return mapped;
+        }))
+            .andThen(({ fd }) => this.fs.fsyncFile(fd)
+            .mapErr(mapFsToManagedSourceError)
+            .andThen(() => this.fs.closeFile(fd).mapErr(mapFsToManagedSourceError))
+            .andThen(() => run())
+            .andThen((value) => this.fs.unlink(lockPath)
+            .orElse((e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return (0, neverthrow_1.okAsync)(undefined);
+            return (0, neverthrow_1.errAsync)(mapFsToManagedSourceError(e));
+        })
+            .map(() => value))
+            .orElse((error) => this.fs.unlink(lockPath)
+            .orElse((e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return (0, neverthrow_1.okAsync)(undefined);
+            return (0, neverthrow_1.errAsync)(mapFsToManagedSourceError(e));
+        })
+            .andThen(() => (0, neverthrow_1.errAsync)(error))));
+    }
+}
+exports.LocalManagedSourceStoreV2 = LocalManagedSourceStoreV2;

package/dist/v2/infra/local/session-summary-provider/index.js

@@ -17,6 +17,7 @@ const EMPTY_OBSERVATIONS = {
     gitHeadSha: null,
     gitBranch: null,
     repoRootHash: null,
+    repoRoot: null,
 };
 const TITLE_CONTEXT_KEYS = ['goal', 'taskDescription', 'mrTitle', 'prTitle', 'ticketTitle', 'problem'];
 class LocalSessionSummaryProviderV2 {
@@ -131,6 +132,7 @@ function extractObservations(events) {
             case 'git_head_sha': return { ...acc, gitHeadSha: e.data.value.value };
             case 'git_branch': return { ...acc, gitBranch: e.data.value.value };
             case 'repo_root_hash': return { ...acc, repoRootHash: e.data.value.value };
+            case 'repo_root': return { ...acc, repoRoot: e.data.value.value };
         }
     }, EMPTY_OBSERVATIONS);
 }

package/dist/v2/infra/local/workspace-anchor/index.js

@@ -40,6 +40,7 @@ class LocalWorkspaceAnchorV2 {
         if (repoRootHash) {
             anchors.push({ key: 'repo_root_hash', value: repoRootHash });
         }
+        anchors.push({ key: 'repo_root', value: repoRoot });
         const branch = await this.gitCommand('git rev-parse --abbrev-ref HEAD', cwd);
         if (branch && branch !== 'HEAD') {
             anchors.push({ key: 'git_branch', value: branch });

package/dist/v2/ports/data-dir.port.d.ts

@@ -14,4 +14,6 @@ export interface DataDirPortV2 {
     sessionManifestPath(sessionId: SessionId): string;
     sessionLockPath(sessionId: SessionId): string;
     tokenIndexPath(): string;
+    managedSourcesPath(): string;
+    managedSourcesLockPath(): string;
 }

package/dist/v2/ports/managed-source-store.port.d.ts

@@ -0,0 +1,25 @@
+import type { ResultAsync } from 'neverthrow';
+export type ManagedSourceStoreError = {
+    readonly code: 'MANAGED_SOURCE_BUSY';
+    readonly message: string;
+    readonly retry: {
+        readonly kind: 'retryable_after_ms';
+        readonly afterMs: number;
+    };
+    readonly lockPath: string;
+} | {
+    readonly code: 'MANAGED_SOURCE_IO_ERROR';
+    readonly message: string;
+} | {
+    readonly code: 'MANAGED_SOURCE_CORRUPTION';
+    readonly message: string;
+};
+export interface ManagedSourceRecordV2 {
+    readonly path: string;
+    readonly addedAtMs: number;
+}
+export interface ManagedSourceStorePortV2 {
+    list(): ResultAsync<readonly ManagedSourceRecordV2[], ManagedSourceStoreError>;
+    attach(path: string): ResultAsync<void, ManagedSourceStoreError>;
+    detach(path: string): ResultAsync<void, ManagedSourceStoreError>;
+}

package/dist/v2/ports/managed-source-store.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/workspace-anchor.port.d.ts

@@ -8,6 +8,9 @@ export type WorkspaceAnchor = {
 } | {
     readonly key: 'repo_root_hash';
     readonly value: string;
+} | {
+    readonly key: 'repo_root';
+    readonly value: string;
 };
 export type WorkspaceAnchorError = {
     readonly code: 'ANCHOR_RESOLVE_FAILED';

package/dist/v2/projections/resume-ranking.d.ts

@@ -8,6 +8,7 @@ export interface SessionObservations {
     readonly gitHeadSha: string | null;
     readonly gitBranch: string | null;
     readonly repoRootHash: string | null;
+    readonly repoRoot: string | null;
 }
 export type WorkflowIdentity = {
     readonly kind: 'unknown';

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

@@ -7,6 +7,7 @@ exports.mountConsoleRoutes = mountConsoleRoutes;
 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");
 function resolveConsoleDist() {
     const releasedDist = path_1.default.join(__dirname, '../../console');
     if (fs_1.default.existsSync(releasedDist))
@@ -24,6 +25,31 @@ function mountConsoleRoutes(app, consoleService) {
         const result = await consoleService.getSessionList();
         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;
+    let cachedRepoRoots = [];
+    let repoRootsExpiresAt = 0;
+    app.get('/api/v2/worktrees', async (_req, res) => {
+        try {
+            const sessionResult = await consoleService.getSessionList();
+            const sessions = sessionResult.isOk() ? sessionResult.value.sessions : [];
+            const activeSessions = (0, worktree_service_js_1.buildActiveSessionCounts)(sessions);
+            if (Date.now() > repoRootsExpiresAt) {
+                cwdRepoRootPromise ?? (cwdRepoRootPromise = (0, worktree_service_js_1.resolveRepoRoot)(process.cwd()));
+                const cwdRoot = await cwdRepoRootPromise;
+                const repoRootSet = new Set(sessions.map(s => s.repoRoot).filter((r) => r !== null));
+                if (cwdRoot !== null)
+                    repoRootSet.add(cwdRoot);
+                cachedRepoRoots = [...repoRootSet];
+                repoRootsExpiresAt = Date.now() + REPO_ROOTS_TTL_MS;
+            }
+            const data = await (0, worktree_service_js_1.getWorktreeList)(cachedRepoRoots, activeSessions);
+            res.json({ success: true, data });
+        }
+        catch (e) {
+            res.status(500).json({ success: false, error: e instanceof Error ? e.message : String(e) });
+        }
+    });
     app.get('/api/v2/sessions/:sessionId', async (req, res) => {
         const { sessionId } = req.params;
         const result = await consoleService.getSessionDetail(sessionId);

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

@@ -14,6 +14,7 @@ const run_context_js_1 = require("../projections/run-context.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;
 class ConsoleService {
     constructor(ports) {
         this.ports = ports;
@@ -91,13 +92,14 @@ class ConsoleService {
         });
     }
     collectSessionSummaries(sessionIds, mtimeBySessionId) {
-        const tasks = sessionIds.map((id) => this.loadSessionSummary(id, mtimeBySessionId.get(id) ?? 0));
+        const nowMs = Date.now();
+        const tasks = sessionIds.map((id) => this.loadSessionSummary(id, mtimeBySessionId.get(id) ?? 0, nowMs));
         return neverthrow_1.ResultAsync.combine(tasks).map((results) => {
             const sessions = results.filter((s) => s !== null);
             return { sessions, totalCount: sessions.length };
         });
     }
-    loadSessionSummary(sessionId, lastModifiedMs) {
+    loadSessionSummary(sessionId, lastModifiedMs, nowMs) {
         return this.ports.sessionStore
             .load(sessionId)
             .andThen((truth) => {
@@ -108,7 +110,7 @@ class ConsoleService {
             return neverthrow_1.ResultAsync.combine([
                 resolveRunCompletion(truth.events, this.ports.snapshotStore),
                 workflowNamesRA,
-            ]).map(([completionMap, workflowNames]) => projectSessionSummary(sessionId, truth, completionMap, workflowNames, lastModifiedMs));
+            ]).map(([completionMap, workflowNames]) => projectSessionSummary(sessionId, truth, completionMap, workflowNames, lastModifiedMs, nowMs));
         })
             .orElse(() => (0, neverthrow_2.okAsync)(null));
     }
@@ -313,12 +315,22 @@ 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;
     return text.slice(0, maxLen - 1) + '…';
 }
-function projectSessionSummary(sessionId, truth, completionByRunId, workflowNames, lastModifiedMs) {
+function projectSessionSummary(sessionId, truth, completionByRunId, workflowNames, lastModifiedMs, nowMs) {
     const { events } = truth;
     const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
     if (health.isErr())
@@ -332,9 +344,11 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
     const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
     const sessionTitle = deriveSessionTitle(events);
     const gitBranch = extractGitBranch(events);
+    const repoRoot = extractRepoRoot(events);
     const runs = Object.values(dag.runsById);
     const run = runs[0];
     if (!run) {
+        const noRunStatus = nowMs - lastModifiedMs > DORMANCY_THRESHOLD_MS ? 'dormant' : 'in_progress';
         return {
             sessionId,
             sessionTitle,
@@ -342,7 +356,7 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
             workflowName: null,
             workflowHash: null,
             runId: null,
-            status: 'in_progress',
+            status: noRunStatus,
             health: sessionHealth,
             nodeCount: 0,
             edgeCount: 0,
@@ -350,6 +364,7 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
             hasUnresolvedGaps: false,
             recapSnippet: null,
             gitBranch,
+            repoRoot,
             lastModifiedMs,
         };
     }
@@ -358,7 +373,10 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
     const workflowHash = workflow.kind === 'with_workflow' ? workflow.workflowHash : null;
     const workflowName = workflowHash ? (workflowNames[workflowHash] ?? null) : null;
     const statusSignals = statusRes.isOk() ? statusRes.value.byRunId[run.runId] : undefined;
-    const status = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false, completionByRunId[run.runId] ?? false);
+    const runStatus = deriveRunStatus(statusSignals?.isBlocked ?? false, statusSignals?.hasUnresolvedCriticalGaps ?? false, completionByRunId[run.runId] ?? false);
+    const status = runStatus === 'in_progress' && nowMs - lastModifiedMs > DORMANCY_THRESHOLD_MS
+        ? 'dormant'
+        : runStatus;
     const hasUnresolvedGaps = gapsRes.isOk()
         ? Object.keys(gapsRes.value.unresolvedCriticalByRunId).length > 0
         : false;
@@ -389,6 +407,7 @@ function projectSessionSummary(sessionId, truth, completionByRunId, workflowName
         hasUnresolvedGaps,
         recapSnippet,
         gitBranch,
+        repoRoot,
         lastModifiedMs,
     };
 }

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

@@ -1,4 +1,5 @@
 export type ConsoleRunStatus = 'in_progress' | 'complete' | 'complete_with_gaps' | 'blocked';
+export type ConsoleSessionStatus = ConsoleRunStatus | 'dormant';
 export type ConsoleSessionHealth = 'healthy' | 'corrupt';
 export interface ConsoleSessionSummary {
     readonly sessionId: string;
@@ -7,7 +8,7 @@ export interface ConsoleSessionSummary {
     readonly workflowName: string | null;
     readonly workflowHash: string | null;
     readonly runId: string | null;
-    readonly status: ConsoleRunStatus;
+    readonly status: ConsoleSessionStatus;
     readonly health: ConsoleSessionHealth;
     readonly nodeCount: number;
     readonly edgeCount: number;
@@ -15,6 +16,7 @@ export interface ConsoleSessionSummary {
     readonly hasUnresolvedGaps: boolean;
     readonly recapSnippet: string | null;
     readonly gitBranch: string | null;
+    readonly repoRoot: string | null;
     readonly lastModifiedMs: number;
 }
 export interface ConsoleSessionListResponse {
@@ -81,6 +83,25 @@ export interface ConsoleArtifact {
     readonly byteLength: number;
     readonly content: unknown;
 }
+export interface ConsoleWorktreeSummary {
+    readonly path: string;
+    readonly name: string;
+    readonly branch: string | null;
+    readonly headHash: string;
+    readonly headMessage: string;
+    readonly headTimestampMs: number;
+    readonly changedCount: number;
+    readonly aheadCount: number;
+    readonly activeSessionCount: number;
+}
+export interface ConsoleRepoWorktrees {
+    readonly repoName: string;
+    readonly repoRoot: string;
+    readonly worktrees: readonly ConsoleWorktreeSummary[];
+}
+export interface ConsoleWorktreeListResponse {
+    readonly repos: readonly ConsoleRepoWorktrees[];
+}
 export interface ConsoleNodeDetail {
     readonly nodeId: string;
     readonly nodeKind: 'step' | 'checkpoint' | 'blocked_attempt';

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

@@ -0,0 +1,10 @@
+import type { ConsoleWorktreeListResponse, ConsoleSessionStatus } from './console-types.js';
+export declare function resolveRepoRoot(path: string): Promise<string | null>;
+export interface ActiveSessionsByBranch {
+    readonly counts: ReadonlyMap<string, number>;
+}
+export declare function buildActiveSessionCounts(sessions: ReadonlyArray<{
+    gitBranch: string | null;
+    status: ConsoleSessionStatus;
+}>): ActiveSessionsByBranch;
+export declare function getWorktreeList(repoRoots: readonly string[], activeSessions: ActiveSessionsByBranch): Promise<ConsoleWorktreeListResponse>;

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRepoRoot = resolveRepoRoot;
+exports.buildActiveSessionCounts = buildActiveSessionCounts;
+exports.getWorktreeList = getWorktreeList;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+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;
+}
+async function git(cwd, args) {
+    try {
+        const { stdout } = await execFileAsync('git', [...args], {
+            cwd,
+            encoding: 'utf-8',
+            timeout: GIT_TIMEOUT_MS,
+        });
+        return stdout.trim();
+    }
+    catch (e) {
+        if (isExecError(e))
+            return null;
+        throw e;
+    }
+}
+function parseWorktreePorcelain(raw) {
+    const entries = [];
+    for (const block of raw.split(/\n\n+/)) {
+        const lines = block.trim().split('\n');
+        const pathLine = lines.find(l => l.startsWith('worktree '));
+        const headLine = lines.find(l => l.startsWith('HEAD '));
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        if (!pathLine || !headLine)
+            continue;
+        const path = pathLine.slice('worktree '.length).trim();
+        const head = headLine.slice('HEAD '.length).trim();
+        const branch = branchLine
+            ? branchLine.slice('branch refs/heads/'.length).trim()
+            : null;
+        entries.push({ path, head, branch });
+    }
+    return entries;
+}
+async function enrichWorktree(wt) {
+    const [logRaw, statusRaw, aheadRaw] = await Promise.all([
+        git(wt.path, ['log', '-1', '--format=%h%n%s%n%ct']),
+        git(wt.path, ['status', '--short']),
+        git(wt.path, ['rev-list', '--count', 'origin/main..HEAD']),
+    ]);
+    const [hashLine, messageLine, timestampLine] = logRaw?.split('\n') ?? [];
+    const headHash = hashLine?.trim() || wt.head.slice(0, 7);
+    const headMessage = messageLine?.trim() ?? '';
+    const headTimestampMs = timestampLine ? parseInt(timestampLine.trim(), 10) * 1000 : 0;
+    const changedCount = statusRaw !== null
+        ? statusRaw.split('\n').filter(l => l.trim()).length
+        : 0;
+    const parsedAhead = aheadRaw !== null ? parseInt(aheadRaw, 10) : NaN;
+    const aheadCount = isNaN(parsedAhead) ? 0 : parsedAhead;
+    return { headHash, headMessage, headTimestampMs, changedCount, aheadCount };
+}
+async function resolveRepoRoot(path) {
+    return git(path, ['rev-parse', '--show-toplevel']);
+}
+async function enrichRepo(repoRoot, activeSessions) {
+    const porcelain = await git(repoRoot, ['worktree', 'list', '--porcelain']);
+    if (porcelain === null)
+        return null;
+    const rawWorktrees = parseWorktreePorcelain(porcelain);
+    const results = await Promise.allSettled(rawWorktrees.map(wt => enrichWorktree(wt)));
+    const worktrees = rawWorktrees.flatMap((wt, i) => {
+        const result = results[i];
+        if (result.status === 'rejected') {
+            console.warn(`[WorktreeService] Failed to enrich worktree at ${wt.path}:`, result.reason);
+            return [];
+        }
+        const e = result.value;
+        return [{
+                path: wt.path,
+                name: (0, path_1.basename)(wt.path),
+                branch: wt.branch,
+                headHash: e.headHash,
+                headMessage: e.headMessage,
+                headTimestampMs: e.headTimestampMs,
+                changedCount: e.changedCount,
+                aheadCount: e.aheadCount,
+                activeSessionCount: wt.branch ? (activeSessions.counts.get(wt.branch) ?? 0) : 0,
+            }];
+    });
+    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;
+    });
+}
+function buildActiveSessionCounts(sessions) {
+    const counts = new Map();
+    for (const s of sessions) {
+        if (s.gitBranch && s.status === 'in_progress') {
+            counts.set(s.gitBranch, (counts.get(s.gitBranch) ?? 0) + 1);
+        }
+    }
+    return { counts };
+}
+async function getWorktreeList(repoRoots, activeSessions) {
+    const repoResults = await Promise.allSettled(repoRoots.map(async (repoRoot) => {
+        const worktrees = await enrichRepo(repoRoot, activeSessions);
+        return { repoRoot, worktrees };
+    }));
+    const repos = repoResults.flatMap((result) => {
+        if (result.status === 'rejected') {
+            console.warn(`[WorktreeService] Failed to enrich repo:`, result.reason);
+            return [];
+        }
+        const { repoRoot, worktrees } = result.value;
+        if (!worktrees || worktrees.length === 0)
+            return [];
+        return [{
+                repoName: (0, path_1.basename)(repoRoot),
+                repoRoot,
+                worktrees,
+            }];
+    });
+    const sortedRepos = [...repos].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)
+            return aActive - bActive;
+        return a.repoName.localeCompare(b.repoName);
+    });
+    return { repos: sortedRepos };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.11.2",
+  "version": "3.13.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {