@exaudeus/workrail 3.7.2 → 3.7.4

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

@@ -7,6 +7,7 @@ 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");
@@ -17,6 +18,7 @@ const EMPTY_OBSERVATIONS = {
     gitBranch: null,
     repoRootHash: null,
 };
+const TITLE_CONTEXT_KEYS = ['goal', 'taskDescription', 'mrTitle', 'prTitle', 'ticketTitle', 'problem'];
 class LocalSessionSummaryProviderV2 {
     constructor(ports) {
         this.ports = ports;
@@ -99,6 +101,7 @@ function projectSessionSummary(sessionId, truth, mtimeMs) {
             recapSnippet,
             observations: extractObservations(truth.events),
             workflow,
+            sessionTitle: deriveSessionTitle(truth.events, bestRun.run.runId),
             lastModifiedMs: mtimeMs,
             pendingStepId: null,
             isComplete: false,
@@ -145,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,33 @@ 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_exact_id' | 'matched_head_sha' | 'matched_branch' | 'matched_notes' | 'matched_notes_partial' | '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_notes_partial';
-    readonly matchRatio: number;
+    readonly kind: 'matched_head_sha';
 } | {
     readonly tier: 5;
-    readonly kind: 'matched_workflow_id';
+    readonly kind: 'matched_branch';
+    readonly matchType: 'exact' | 'prefix';
 } | {
     readonly tier: 6;
     readonly kind: 'recency_fallback';
@@ -66,10 +67,13 @@ export declare function fuzzyQueryTokenMatchRatio(queryTokens: ReadonlySet<strin
 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;
@@ -81,9 +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

@@ -7,6 +7,7 @@ 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");
@@ -71,6 +72,159 @@ function fuzzyQueryTokenMatchRatio(queryTokens, candidateTokens) {
     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' };
@@ -78,37 +232,38 @@ function assignTier(summary, query) {
     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' };
-        }
-    }
-    const queryTokens = query.freeTextQuery ? normalizeToTokens(query.freeTextQuery) : null;
-    if (queryTokens && queryTokens.size > 0 && summary.recapSnippet) {
-        const noteTokens = normalizeToTokens(summary.recapSnippet);
-        if (allQueryTokensMatch(queryTokens, noteTokens)) {
-            return { tier: 3, kind: 'matched_notes' };
-        }
-        const ratio = fuzzyQueryTokenMatchRatio(queryTokens, noteTokens);
-        if (ratio >= MIN_PARTIAL_MATCH_RATIO) {
-            return { tier: 4, kind: 'matched_notes_partial', matchRatio: ratio };
-        }
-    }
-    if (queryTokens && queryTokens.size > 0 && summary.workflow.kind === 'identified') {
-        const workflowTokens = normalizeToTokens(String(summary.workflow.workflowId));
-        if (allQueryTokensMatch(queryTokens, workflowTokens)) {
-            return { tier: 5, kind: 'matched_workflow_id' };
-        }
-        const ratio = fuzzyQueryTokenMatchRatio(queryTokens, workflowTokens);
-        if (ratio >= MIN_PARTIAL_MATCH_RATIO) {
-            return { tier: 5, kind: 'matched_workflow_id' };
+            return { tier: 5, kind: 'matched_branch', matchType: 'prefix' };
         }
     }
     return { tier: 6, kind: 'recency_fallback' };
@@ -126,16 +281,25 @@ function tierToWhyMatched(tier) {
 }
 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;
@@ -146,18 +310,25 @@ function rankResumeCandidates(summaries, query) {
             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,
-        pendingStepId: summary.pendingStepId,
-        isComplete: summary.isComplete,
-        lastModifiedMs: summary.lastModifiedMs,
-    }));
+    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/package.json

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