@exaudeus/workrail 3.7.1 → 3.7.3

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

@@ -7,15 +7,18 @@ const enumerate_sessions_js_1 = require("../../../usecases/enumerate-sessions.js
 const session_health_js_1 = require("../../../projections/session-health.js");
 const run_dag_js_1 = require("../../../projections/run-dag.js");
 const node_outputs_js_1 = require("../../../projections/node-outputs.js");
+const run_context_js_1 = require("../../../projections/run-context.js");
+const snapshot_state_js_1 = require("../../../durable-core/projections/snapshot-state.js");
 const index_js_1 = require("../../../durable-core/ids/index.js");
 const constants_js_1 = require("../../../durable-core/constants.js");
-const MAX_SESSIONS_TO_SCAN = 50;
+const MAX_SESSIONS_TO_SCAN = 200;
 const MAX_RECAP_ANCESTOR_DEPTH = 100;
 const EMPTY_OBSERVATIONS = {
     gitHeadSha: null,
     gitBranch: null,
     repoRootHash: null,
 };
+const TITLE_CONTEXT_KEYS = ['goal', 'taskDescription', 'mrTitle', 'prTitle', 'ticketTitle', 'problem'];
 class LocalSessionSummaryProviderV2 {
     constructor(ports) {
         this.ports = ports;
@@ -29,20 +32,48 @@ class LocalSessionSummaryProviderV2 {
             code: 'SESSION_SUMMARY_ENUMERATION_FAILED',
             message: `Failed to enumerate sessions: ${fsErr.message}`,
         }))
-            .andThen((sessionIds) => collectHealthySummaries(sessionIds.slice(0, MAX_SESSIONS_TO_SCAN), this.ports.sessionStore));
+            .andThen((entries) => collectHealthySummaries(entries.slice(0, MAX_SESSIONS_TO_SCAN), this.ports.sessionStore, this.ports.snapshotStore ?? null));
     }
 }
 exports.LocalSessionSummaryProviderV2 = LocalSessionSummaryProviderV2;
-function collectHealthySummaries(sessionIds, sessionStore) {
-    return sessionIds.reduce((acc, sessionId) => acc.andThen((summaries) => loadSessionSummary(sessionId, sessionStore).map((summary) => summary !== null ? [...summaries, summary] : summaries)), (0, neverthrow_1.okAsync)([]));
+function collectHealthySummaries(entries, sessionStore, snapshotStore) {
+    return entries.reduce((acc, entry) => acc.andThen((summaries) => loadSessionSummary(entry, sessionStore, snapshotStore).map((summary) => summary !== null ? [...summaries, summary] : summaries)), (0, neverthrow_1.okAsync)([]));
 }
-function loadSessionSummary(sessionId, sessionStore) {
+function loadSessionSummary(entry, sessionStore, snapshotStore) {
     return sessionStore
-        .load(sessionId)
-        .map((truth) => projectSessionSummary(sessionId, truth))
+        .load(entry.sessionId)
+        .andThen((truth) => {
+        const projected = projectSessionSummary(entry.sessionId, truth, entry.mtimeMs);
+        if (!projected)
+            return (0, neverthrow_1.okAsync)(null);
+        if (!snapshotStore)
+            return (0, neverthrow_1.okAsync)(projected.summary);
+        const ref = safeSnapshotRef(projected.tipSnapshotRef);
+        if (!ref)
+            return (0, neverthrow_1.okAsync)(projected.summary);
+        return snapshotStore.getExecutionSnapshotV1(ref)
+            .map((snapshot) => {
+            if (!snapshot)
+                return projected.summary;
+            const engineState = snapshot.enginePayload.engineState;
+            const pending = (0, snapshot_state_js_1.derivePendingStep)(engineState);
+            const isComplete = (0, snapshot_state_js_1.deriveIsComplete)(engineState);
+            return {
+                ...projected.summary,
+                pendingStepId: pending?.stepId ?? null,
+                isComplete,
+            };
+        })
+            .orElse(() => (0, neverthrow_1.okAsync)(projected.summary));
+    })
         .orElse(() => (0, neverthrow_1.okAsync)(null));
 }
-function projectSessionSummary(sessionId, truth) {
+function safeSnapshotRef(raw) {
+    if (!raw || !constants_js_1.SHA256_DIGEST_PATTERN.test(raw))
+        return null;
+    return (0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(raw));
+}
+function projectSessionSummary(sessionId, truth, mtimeMs) {
     const health = (0, session_health_js_1.projectSessionHealthV2)(truth);
     if (health.isErr() || health.value.kind !== 'healthy')
         return null;
@@ -60,15 +91,22 @@ function projectSessionSummary(sessionId, truth) {
         ? extractAggregateRecap(outputsRes.value, bestRun.run, bestRun.tipNodeId)
         : null;
     return {
-        sessionId,
-        runId: bestRun.run.runId,
-        preferredTip: {
-            nodeId: bestRun.tipNodeId,
-            lastActivityEventIndex: bestRun.lastActivityEventIndex,
+        summary: {
+            sessionId,
+            runId: bestRun.run.runId,
+            preferredTip: {
+                nodeId: bestRun.tipNodeId,
+                lastActivityEventIndex: bestRun.lastActivityEventIndex,
+            },
+            recapSnippet,
+            observations: extractObservations(truth.events),
+            workflow,
+            sessionTitle: deriveSessionTitle(truth.events, bestRun.run.runId),
+            lastModifiedMs: mtimeMs,
+            pendingStepId: null,
+            isComplete: false,
         },
-        recapSnippet,
-        observations: extractObservations(truth.events),
-        workflow,
+        tipSnapshotRef: bestRun.tipSnapshotRef,
     };
 }
 function selectBestRun(runs) {
@@ -77,7 +115,9 @@ function selectBestRun(runs) {
         if (!tipNodeId)
             return [];
         const tipNode = r.nodesById[tipNodeId];
-        return [{ run: r, tipNodeId, lastActivityEventIndex: tipNode?.createdAtEventIndex ?? 0 }];
+        if (!tipNode)
+            return [];
+        return [{ run: r, tipNodeId, tipSnapshotRef: tipNode.snapshotRef, lastActivityEventIndex: tipNode.createdAtEventIndex }];
     });
     if (runsWithTip.length === 0)
         return null;
@@ -108,6 +148,80 @@ function extractWorkflowIdentity(events, runId) {
         workflowHash: (0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(event.data.workflowHash)),
     };
 }
+function deriveSessionTitle(events, runId) {
+    const contextRes = (0, run_context_js_1.projectRunContextV2)(events);
+    if (contextRes.isOk()) {
+        const runCtx = contextRes.value.byRunId[runId];
+        if (runCtx) {
+            for (const key of TITLE_CONTEXT_KEYS) {
+                const val = runCtx.context[key];
+                if (typeof val === 'string' && val.trim().length > 0) {
+                    return truncateTitle(val.trim());
+                }
+            }
+        }
+    }
+    return extractTitleFromFirstRecap(events);
+}
+function extractTitleFromFirstRecap(events) {
+    const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(events);
+    if (outputsRes.isErr())
+        return null;
+    let rootNodeId = null;
+    let minIndex = Infinity;
+    for (const e of events) {
+        if (e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.eventIndex < minIndex) {
+            minIndex = e.eventIndex;
+            rootNodeId = e.scope.nodeId;
+        }
+    }
+    if (!rootNodeId)
+        return null;
+    const nodeOutputs = outputsRes.value.nodesById[rootNodeId];
+    if (!nodeOutputs)
+        return null;
+    const recaps = nodeOutputs.currentByChannel[constants_js_1.OUTPUT_CHANNEL.RECAP];
+    const first = recaps?.[0];
+    if (!first || first.payload.payloadKind !== constants_js_1.PAYLOAD_KIND.NOTES)
+        return null;
+    return extractDescriptiveText(first.payload.notesMarkdown);
+}
+function extractDescriptiveText(markdown) {
+    const lines = markdown
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (const line of lines) {
+        if (/^#{1,3}\s/.test(line))
+            continue;
+        if (/^[-_*]{3,}$/.test(line))
+            continue;
+        if (line.startsWith('|'))
+            continue;
+        const boldLabel = line.match(/^\*{2}[^*]+\*{2}:?\s*(.*)/);
+        if (boldLabel) {
+            const value = boldLabel[1]?.trim();
+            if (value && value.length > 10)
+                return truncateTitle(value);
+            continue;
+        }
+        const listBoldLabel = line.match(/^-\s+\*{2}[^*]+\*{2}:?\s*(.*)/);
+        if (listBoldLabel) {
+            const value = listBoldLabel[1]?.trim();
+            if (value && value.length > 10)
+                return truncateTitle(value);
+            continue;
+        }
+        if (line.length > 10)
+            return truncateTitle(line);
+    }
+    return null;
+}
+function truncateTitle(text, maxLen = 120) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + '…';
+}
 function collectAncestorNodeIds(nodesById, nodeId, remainingDepth) {
     if (remainingDepth === 0)
         return [nodeId];

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalWorkspaceAnchorV2 = void 0;
 const neverthrow_1 = require("neverthrow");
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const util_1 = require("util");
 const url_1 = require("url");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
@@ -32,6 +33,13 @@ class LocalWorkspaceAnchorV2 {
     }
     async runGitCommands(cwd) {
         const anchors = [];
+        const repoRoot = await this.gitCommand('git rev-parse --show-toplevel', cwd);
+        if (!repoRoot)
+            return anchors;
+        const repoRootHash = hashRepoRoot(repoRoot);
+        if (repoRootHash) {
+            anchors.push({ key: 'repo_root_hash', value: repoRootHash });
+        }
         const branch = await this.gitCommand('git rev-parse --abbrev-ref HEAD', cwd);
         if (branch && branch !== 'HEAD') {
             anchors.push({ key: 'git_branch', value: branch });
@@ -57,6 +65,21 @@ class LocalWorkspaceAnchorV2 {
     }
 }
 exports.LocalWorkspaceAnchorV2 = LocalWorkspaceAnchorV2;
+function hashRepoRoot(repoRoot) {
+    try {
+        const normalized = repoRoot.trim();
+        if (!normalized)
+            return null;
+        const digest = createSha256Hex(normalized);
+        return `sha256:${digest}`;
+    }
+    catch {
+        return null;
+    }
+}
+function createSha256Hex(input) {
+    return (0, crypto_1.createHash)('sha256').update(input).digest('hex');
+}
 function uriToFsPath(uri) {
     if (!uri.startsWith('file://'))
         return null;

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

@@ -28,32 +28,52 @@ export interface HealthySessionSummary {
     readonly recapSnippet: RecapSnippet | null;
     readonly observations: SessionObservations;
     readonly workflow: IdentifiedWorkflow;
+    readonly sessionTitle: string | null;
+    readonly lastModifiedMs: number | null;
+    readonly pendingStepId: string | null;
+    readonly isComplete: boolean;
 }
-export type WhyMatched = 'matched_head_sha' | 'matched_branch' | 'matched_notes' | 'matched_workflow_id' | 'recency_fallback';
+export type WhyMatched = 'matched_exact_id' | 'matched_head_sha' | 'matched_repo_root' | 'matched_branch' | 'matched_notes' | 'matched_notes_partial' | 'matched_workflow_id' | 'recency_fallback';
 export type TierAssignment = {
+    readonly tier: 0;
+    readonly kind: 'matched_exact_id';
+    readonly matchField: 'runId' | 'sessionId';
+} | {
     readonly tier: 1;
-    readonly kind: 'matched_head_sha';
+    readonly kind: 'matched_notes';
 } | {
     readonly tier: 2;
-    readonly kind: 'matched_branch';
-    readonly matchType: 'exact' | 'prefix';
+    readonly kind: 'matched_notes_partial';
+    readonly matchRatio: number;
 } | {
     readonly tier: 3;
-    readonly kind: 'matched_notes';
+    readonly kind: 'matched_workflow_id';
 } | {
     readonly tier: 4;
-    readonly kind: 'matched_workflow_id';
+    readonly kind: 'matched_head_sha';
 } | {
     readonly tier: 5;
+    readonly kind: 'matched_branch';
+    readonly matchType: 'exact' | 'prefix';
+} | {
+    readonly tier: 6;
     readonly kind: 'recency_fallback';
 };
 export declare function normalizeToTokens(text: string): ReadonlySet<string>;
 export declare function allQueryTokensMatch(queryTokens: ReadonlySet<string>, candidateTokens: ReadonlySet<string>): boolean;
+export declare function queryTokenMatchRatio(queryTokens: ReadonlySet<string>, candidateTokens: ReadonlySet<string>): number;
+export declare function fuzzyTokenMatch(queryToken: string, candidateTokens: ReadonlySet<string>): boolean;
+export declare function fuzzyQueryTokenMatchRatio(queryTokens: ReadonlySet<string>, candidateTokens: ReadonlySet<string>): number;
 export interface ResumeQuery {
     readonly gitHeadSha?: string;
     readonly gitBranch?: string;
+    readonly repoRootHash?: string;
+    readonly sameWorkspaceOnly?: boolean;
     readonly freeTextQuery?: string;
+    readonly runId?: string;
+    readonly sessionId?: string;
 }
+export declare function computeQueryRelevanceScore(summary: HealthySessionSummary, query: ResumeQuery): number;
 export declare function assignTier(summary: HealthySessionSummary, query: ResumeQuery): TierAssignment;
 export interface RankedResumeCandidate {
     readonly sessionId: SessionId;
@@ -65,6 +85,13 @@ export interface RankedResumeCandidate {
     readonly lastActivityEventIndex: number;
     readonly workflowHash: WorkflowHash;
     readonly workflowId: WorkflowId;
+    readonly sessionTitle: string | null;
+    readonly gitBranch: string | null;
+    readonly pendingStepId: string | null;
+    readonly isComplete: boolean;
+    readonly lastModifiedMs: number | null;
+    readonly confidence: 'strong' | 'medium' | 'weak';
+    readonly matchExplanation: string;
 }
 export declare const MAX_RESUME_CANDIDATES = 5;
 export declare function rankResumeCandidates(summaries: readonly HealthySessionSummary[], query: ResumeQuery): readonly RankedResumeCandidate[];

package/dist/v2/projections/resume-ranking.js

@@ -4,6 +4,10 @@ exports.MAX_RESUME_CANDIDATES = void 0;
 exports.asRecapSnippet = asRecapSnippet;
 exports.normalizeToTokens = normalizeToTokens;
 exports.allQueryTokensMatch = allQueryTokensMatch;
+exports.queryTokenMatchRatio = queryTokenMatchRatio;
+exports.fuzzyTokenMatch = fuzzyTokenMatch;
+exports.fuzzyQueryTokenMatchRatio = fuzzyQueryTokenMatchRatio;
+exports.computeQueryRelevanceScore = computeQueryRelevanceScore;
 exports.assignTier = assignTier;
 exports.rankResumeCandidates = rankResumeCandidates;
 const constants_js_1 = require("../durable-core/constants.js");
@@ -36,68 +40,295 @@ function allQueryTokensMatch(queryTokens, candidateTokens) {
     }
     return true;
 }
+function queryTokenMatchRatio(queryTokens, candidateTokens) {
+    if (queryTokens.size === 0 || candidateTokens.size === 0)
+        return 0;
+    let matched = 0;
+    for (const token of queryTokens) {
+        if (candidateTokens.has(token))
+            matched++;
+    }
+    return matched / queryTokens.size;
+}
+function fuzzyTokenMatch(queryToken, candidateTokens) {
+    if (queryToken.length < 3)
+        return false;
+    for (const ct of candidateTokens) {
+        if (ct.length < 3)
+            continue;
+        if (ct.includes(queryToken) || queryToken.includes(ct))
+            return true;
+    }
+    return false;
+}
+function fuzzyQueryTokenMatchRatio(queryTokens, candidateTokens) {
+    if (queryTokens.size === 0 || candidateTokens.size === 0)
+        return 0;
+    let matched = 0;
+    for (const qt of queryTokens) {
+        if (candidateTokens.has(qt) || fuzzyTokenMatch(qt, candidateTokens))
+            matched++;
+    }
+    return matched / queryTokens.size;
+}
+const MIN_PARTIAL_MATCH_RATIO = 0.4;
+const LOW_SIGNAL_QUERY_TOKENS = new Set([
+    'task',
+    'dev',
+    'work',
+    'workflow',
+    'coding',
+    'feature',
+    'phase',
+    'implement',
+    'implementation',
+    'review',
+    'fix',
+    'bug',
+]);
+function tokenSpecificityWeight(token) {
+    if (token.length <= 2)
+        return 0.2;
+    if (LOW_SIGNAL_QUERY_TOKENS.has(token))
+        return 0.35;
+    return Math.min(2.5, 1 + Math.max(0, token.length - 4) * 0.18);
+}
+function weightedFuzzyQueryTokenMatchRatio(queryTokens, candidateTokens) {
+    if (queryTokens.size === 0 || candidateTokens.size === 0)
+        return 0;
+    let matchedWeight = 0;
+    let totalWeight = 0;
+    for (const qt of queryTokens) {
+        const weight = tokenSpecificityWeight(qt);
+        totalWeight += weight;
+        if (candidateTokens.has(qt) || fuzzyTokenMatch(qt, candidateTokens)) {
+            matchedWeight += weight;
+        }
+    }
+    return totalWeight === 0 ? 0 : matchedWeight / totalWeight;
+}
+function repoScopeMatches(summary, query) {
+    return Boolean(query.repoRootHash &&
+        summary.observations.repoRootHash &&
+        query.repoRootHash === summary.observations.repoRootHash);
+}
+function shouldKeepSummary(summary, query) {
+    if (!query.sameWorkspaceOnly)
+        return true;
+    if (!query.repoRootHash)
+        return true;
+    return repoScopeMatches(summary, query);
+}
+function buildSearchableSessionText(summary) {
+    return [summary.sessionTitle, summary.recapSnippet]
+        .filter((part) => Boolean(part && part.trim().length > 0))
+        .join('\n\n');
+}
+function collectMatchReasons(summary, query, tier) {
+    const reasons = [tierToWhyMatched(tier)];
+    if (repoScopeMatches(summary, query) && !reasons.includes('matched_repo_root')) {
+        reasons.push('matched_repo_root');
+    }
+    if (query.gitHeadSha &&
+        summary.observations.gitHeadSha === query.gitHeadSha &&
+        !reasons.includes('matched_head_sha')) {
+        reasons.push('matched_head_sha');
+    }
+    if (query.gitBranch &&
+        summary.observations.gitBranch &&
+        (summary.observations.gitBranch === query.gitBranch ||
+            summary.observations.gitBranch.startsWith(query.gitBranch) ||
+            query.gitBranch.startsWith(summary.observations.gitBranch)) &&
+        !reasons.includes('matched_branch')) {
+        reasons.push('matched_branch');
+    }
+    return reasons;
+}
+function buildPreviewSnippet(summary, query) {
+    const previewSource = buildSearchableSessionText(summary);
+    if (!previewSource)
+        return '';
+    const queryTokens = query.freeTextQuery ? [...normalizeToTokens(query.freeTextQuery)] : [];
+    if (queryTokens.length === 0)
+        return summary.recapSnippet ?? previewSource;
+    const lower = previewSource.toLowerCase();
+    let bestIndex = -1;
+    for (const token of queryTokens) {
+        if (token.length < 3)
+            continue;
+        const idx = lower.indexOf(token);
+        if (idx !== -1 && (bestIndex === -1 || idx < bestIndex))
+            bestIndex = idx;
+    }
+    if (bestIndex === -1)
+        return summary.recapSnippet ?? previewSource;
+    const start = Math.max(0, bestIndex - 100);
+    const end = Math.min(previewSource.length, bestIndex + 180);
+    const slice = previewSource.slice(start, end).trim();
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < previewSource.length ? '...' : '';
+    return `${prefix}${slice}${suffix}`;
+}
+function deriveConfidence(tier, reasons) {
+    if (tier.kind === 'matched_exact_id' || tier.kind === 'matched_notes')
+        return 'strong';
+    if (tier.kind === 'matched_notes_partial' || tier.kind === 'matched_workflow_id')
+        return 'medium';
+    if (reasons.includes('matched_repo_root') || reasons.includes('matched_head_sha') || reasons.includes('matched_branch')) {
+        return 'medium';
+    }
+    return 'weak';
+}
+function buildMatchExplanation(tier, reasons, summary) {
+    const parts = [];
+    switch (tier.kind) {
+        case 'matched_exact_id':
+            parts.push(`Exact ${tier.matchField} match`);
+            break;
+        case 'matched_notes':
+            parts.push('Strong text match against session title/notes');
+            break;
+        case 'matched_notes_partial':
+            parts.push(`Partial text match (${Math.round(tier.matchRatio * 100)}%) against session title/notes`);
+            break;
+        case 'matched_workflow_id':
+            parts.push('Matched workflow type');
+            break;
+        case 'matched_head_sha':
+            parts.push('Matched current git commit');
+            break;
+        case 'matched_branch':
+            parts.push(tier.matchType === 'exact' ? 'Matched current git branch' : 'Partially matched current git branch');
+            break;
+        case 'recency_fallback':
+            parts.push('Recent session with no stronger explicit match');
+            break;
+    }
+    if (reasons.includes('matched_repo_root'))
+        parts.push('same workspace');
+    if (summary.isComplete)
+        parts.push('completed');
+    return parts.join('; ');
+}
+function computeQueryRelevanceScore(summary, query) {
+    const queryTokens = query.freeTextQuery ? normalizeToTokens(query.freeTextQuery) : null;
+    const repoBonus = repoScopeMatches(summary, query) ? 0.2 : 0;
+    if (!queryTokens || queryTokens.size === 0)
+        return repoBonus;
+    const sessionText = buildSearchableSessionText(summary);
+    const sessionTextRatio = sessionText
+        ? weightedFuzzyQueryTokenMatchRatio(queryTokens, normalizeToTokens(sessionText))
+        : 0;
+    const workflowRatio = weightedFuzzyQueryTokenMatchRatio(queryTokens, normalizeToTokens(String(summary.workflow.workflowId)));
+    const branchRatio = summary.observations.gitBranch
+        ? weightedFuzzyQueryTokenMatchRatio(queryTokens, normalizeToTokens(summary.observations.gitBranch))
+        : 0;
+    return Math.max(sessionTextRatio + repoBonus, workflowRatio * 0.75 + repoBonus, branchRatio * 0.5 + repoBonus);
+}
 function assignTier(summary, query) {
+    if (query.runId && summary.runId === query.runId) {
+        return { tier: 0, kind: 'matched_exact_id', matchField: 'runId' };
+    }
+    if (query.sessionId && String(summary.sessionId) === query.sessionId) {
+        return { tier: 0, kind: 'matched_exact_id', matchField: 'sessionId' };
+    }
+    const queryTokens = query.freeTextQuery ? normalizeToTokens(query.freeTextQuery) : null;
+    if (queryTokens && queryTokens.size > 0) {
+        const sessionText = buildSearchableSessionText(summary);
+        if (sessionText) {
+            const sessionTextTokens = normalizeToTokens(sessionText);
+            if (allQueryTokensMatch(queryTokens, sessionTextTokens)) {
+                return { tier: 1, kind: 'matched_notes' };
+            }
+            const ratio = weightedFuzzyQueryTokenMatchRatio(queryTokens, sessionTextTokens);
+            if (ratio >= MIN_PARTIAL_MATCH_RATIO) {
+                return { tier: 2, kind: 'matched_notes_partial', matchRatio: ratio };
+            }
+        }
+        const workflowTokens = normalizeToTokens(String(summary.workflow.workflowId));
+        if (allQueryTokensMatch(queryTokens, workflowTokens)) {
+            return { tier: 3, kind: 'matched_workflow_id' };
+        }
+        const workflowRatio = weightedFuzzyQueryTokenMatchRatio(queryTokens, workflowTokens);
+        if (workflowRatio >= MIN_PARTIAL_MATCH_RATIO) {
+            return { tier: 3, kind: 'matched_workflow_id' };
+        }
+    }
     if (query.gitHeadSha && summary.observations.gitHeadSha === query.gitHeadSha) {
-        return { tier: 1, kind: 'matched_head_sha' };
+        return { tier: 4, kind: 'matched_head_sha' };
     }
     if (query.gitBranch && summary.observations.gitBranch) {
         if (summary.observations.gitBranch === query.gitBranch) {
-            return { tier: 2, kind: 'matched_branch', matchType: 'exact' };
+            return { tier: 5, kind: 'matched_branch', matchType: 'exact' };
         }
         if (summary.observations.gitBranch.startsWith(query.gitBranch) ||
             query.gitBranch.startsWith(summary.observations.gitBranch)) {
-            return { tier: 2, kind: 'matched_branch', matchType: 'prefix' };
-        }
-    }
-    if (query.freeTextQuery && summary.recapSnippet) {
-        const queryTokens = normalizeToTokens(query.freeTextQuery);
-        const noteTokens = normalizeToTokens(summary.recapSnippet);
-        if (allQueryTokensMatch(queryTokens, noteTokens)) {
-            return { tier: 3, kind: 'matched_notes' };
+            return { tier: 5, kind: 'matched_branch', matchType: 'prefix' };
         }
     }
-    if (query.freeTextQuery && summary.workflow.kind === 'identified') {
-        const queryTokens = normalizeToTokens(query.freeTextQuery);
-        const workflowTokens = normalizeToTokens(String(summary.workflow.workflowId));
-        if (allQueryTokensMatch(queryTokens, workflowTokens)) {
-            return { tier: 4, kind: 'matched_workflow_id' };
-        }
-    }
-    return { tier: 5, kind: 'recency_fallback' };
+    return { tier: 6, kind: 'recency_fallback' };
 }
 function tierToWhyMatched(tier) {
     switch (tier.kind) {
+        case 'matched_exact_id': return 'matched_exact_id';
         case 'matched_head_sha': return 'matched_head_sha';
         case 'matched_branch': return 'matched_branch';
         case 'matched_notes': return 'matched_notes';
+        case 'matched_notes_partial': return 'matched_notes_partial';
         case 'matched_workflow_id': return 'matched_workflow_id';
         case 'recency_fallback': return 'recency_fallback';
     }
 }
 exports.MAX_RESUME_CANDIDATES = 5;
 function rankResumeCandidates(summaries, query) {
-    const withTier = summaries.map((summary) => ({
+    const withTier = summaries
+        .filter((summary) => shouldKeepSummary(summary, query))
+        .map((summary) => ({
         summary,
         tier: assignTier(summary, query),
+        queryScore: computeQueryRelevanceScore(summary, query),
     }));
     const sorted = [...withTier].sort((a, b) => {
         if (a.tier.tier !== b.tier.tier)
             return a.tier.tier - b.tier.tier;
+        const aSameRepo = repoScopeMatches(a.summary, query);
+        const bSameRepo = repoScopeMatches(b.summary, query);
+        if (aSameRepo !== bSameRepo)
+            return aSameRepo ? -1 : 1;
+        if (a.summary.isComplete !== b.summary.isComplete) {
+            return a.summary.isComplete ? 1 : -1;
+        }
+        if (a.queryScore !== b.queryScore)
+            return b.queryScore - a.queryScore;
+        if (a.tier.kind === 'matched_notes_partial' && b.tier.kind === 'matched_notes_partial') {
+            if (a.tier.matchRatio !== b.tier.matchRatio)
+                return b.tier.matchRatio - a.tier.matchRatio;
+        }
         const actA = a.summary.preferredTip.lastActivityEventIndex;
         const actB = b.summary.preferredTip.lastActivityEventIndex;
         if (actA !== actB)
             return actB - actA;
         return String(a.summary.sessionId).localeCompare(String(b.summary.sessionId));
     });
-    return sorted.slice(0, exports.MAX_RESUME_CANDIDATES).map(({ summary, tier }) => ({
-        sessionId: summary.sessionId,
-        runId: summary.runId,
-        preferredTipNodeId: summary.preferredTip.nodeId,
-        snippet: summary.recapSnippet ?? '',
-        whyMatched: [tierToWhyMatched(tier)],
-        tierAssignment: tier,
-        lastActivityEventIndex: summary.preferredTip.lastActivityEventIndex,
-        workflowHash: summary.workflow.workflowHash,
-        workflowId: summary.workflow.workflowId,
-    }));
+    return sorted.slice(0, exports.MAX_RESUME_CANDIDATES).map(({ summary, tier }) => {
+        const whyMatched = collectMatchReasons(summary, query, tier);
+        return {
+            sessionId: summary.sessionId,
+            runId: summary.runId,
+            preferredTipNodeId: summary.preferredTip.nodeId,
+            snippet: buildPreviewSnippet(summary, query),
+            whyMatched,
+            tierAssignment: tier,
+            lastActivityEventIndex: summary.preferredTip.lastActivityEventIndex,
+            workflowHash: summary.workflow.workflowHash,
+            workflowId: summary.workflow.workflowId,
+            sessionTitle: summary.sessionTitle,
+            gitBranch: summary.observations.gitBranch,
+            pendingStepId: summary.pendingStepId,
+            isComplete: summary.isComplete,
+            lastModifiedMs: summary.lastModifiedMs,
+            confidence: deriveConfidence(tier, whyMatched),
+            matchExplanation: buildMatchExplanation(tier, whyMatched, summary),
+        };
+    });
 }

package/dist/v2/usecases/enumerate-sessions.d.ts

@@ -7,7 +7,11 @@ export declare function enumerateSessions(ports: {
     readonly directoryListing: DirectoryListingPortV2;
     readonly dataDir: DataDirPortV2;
 }): ResultAsync<readonly SessionId[], FsError>;
+export interface SessionWithMtime {
+    readonly sessionId: SessionId;
+    readonly mtimeMs: number;
+}
 export declare function enumerateSessionsByRecency(ports: {
     readonly directoryListing: DirectoryListingPortV2;
     readonly dataDir: DataDirPortV2;
-}): ResultAsync<readonly SessionId[], FsError>;
+}): ResultAsync<readonly SessionWithMtime[], FsError>;

package/dist/v2/usecases/enumerate-sessions.js

@@ -22,5 +22,5 @@ function enumerateSessionsByRecency(ports) {
             return b.mtimeMs - a.mtimeMs;
         return a.name.localeCompare(b.name);
     })
-        .map((entry) => (0, index_js_1.asSessionId)(entry.name)));
+        .map((entry) => ({ sessionId: (0, index_js_1.asSessionId)(entry.name), mtimeMs: entry.mtimeMs })));
 }