@mirnoorata/codexa 0.2.0

package/dist/query/context.js

@@ -0,0 +1,1162 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { isTestPath, moduleNameForPath } from "../language.js";
+import { uniqueSorted } from "../util.js";
+import { formatDiffGroups, formatGaps, groupDiffImpact, indexGaps } from "./diff.js";
+import { addContextPackImpactExpansion, verificationRecipes } from "./impact.js";
+import { lspAssistForFiles, lspOptionsFromQueryOptions } from "../lsp/assist.js";
+import { betterTier, clampInt, confidenceTier, focusTierCounts, formatReasons, formatRecipes, limitTextToTokens, tierScore } from "./formatting.js";
+import { formatWorkflowSummary, recommendNextCodexaCall } from "./graph.js";
+import { nextTool } from "./next-tools.js";
+import { assessContextQuality, formatContextQuality, formatValueEstimate, valueEstimate } from "./quality.js";
+import { baselineSearchSummary } from "./raw-search.js";
+import { codeLikeQueryFromTask, fileStemQueryTerms, matchReason, matchScore, uniqueFiles } from "./search.js";
+import { freshnessBanner } from "./runtime.js";
+import { ensureQuerySession } from "./session.js";
+import { compactWorktreeState, getWorktreeState, worktreeStateGaps, worktreeStateText } from "./worktree-state.js";
+import { isCodexaControlPath } from "./worktree.js";
+import { formatTestRecommendations, recommendTests } from "./tests.js";
+import { findFile, resolveFileTarget, resolveSymbolTarget } from "./targets.js";
+import { coverageForDisplay, formatVerificationCoverage, verificationCommandPlan, verificationCommandsForContext } from "./verification.js";
+import { classifyTaskIntent, retrieveForTask } from "../retrieval.js";
+import { semanticOptionsFromQueryOptions } from "../semantic-retrieval.js";
+import { compactChangedSymbol, compactDiffGroup, compactFileFact, compactRetrievalResult, compactWorkflowTrace } from "./compact-data.js";
+import { summarizeSessionMemory } from "../session-memory.js";
+import { workspaceGuidancePreview } from "./workspace-guidance.js";
+export async function contextPackQuery(input, contextInput = {}, options = {}) {
+    const session = await ensureQuerySession(input, options);
+    const { index, freshness, refresh, repoRoot } = session;
+    const tokenBudget = clampInt(contextInput.tokenBudget ?? 4000, 500, 12000);
+    const limit = clampInt(contextInput.limit ?? 12, 3, session.maxResults);
+    const includeSnippets = contextInput.includeSnippets ?? true;
+    const changeType = contextInput.changeType ?? "unknown";
+    const warnings = [...session.warnings];
+    const focusState = createContextFocusState(index, warnings);
+    const { focus, impactSeeds, addFocus } = focusState;
+    const requestedFiles = contextInput.files ?? [];
+    const requestedSymbols = contextInput.symbols ?? [];
+    const requestedResolvedPaths = addExplicitTargetsToContextFocus({
+        index,
+        repoRoot,
+        requestedFiles,
+        requestedSymbols,
+        focus: focusState,
+        warnings
+    });
+    const explicitQuery = contextInput.query?.trim() ?? "";
+    const explicitTargetProvided = requestedFiles.length > 0 || requestedSymbols.length > 0;
+    const explicitConfigTarget = requestedResolvedPaths.some(isConfigExpansionPath);
+    const taskIntents = contextInput.task ? classifyTaskIntent(contextInput.task) : [];
+    const dirtyContextHint = Boolean(contextInput.task && taskReferencesDirtyContext(contextInput.task) && !explicitTargetProvided && !explicitQuery);
+    const includeDiff = contextInput.diff ?? true;
+    const worktree = includeDiff ? await getWorktreeState(session) : undefined;
+    const changedEntries = worktree?.entries ?? [];
+    const changed = worktree?.files ?? [];
+    const changedSymbols = worktree?.symbols ?? [];
+    const dirtyContextTask = dirtyContextHint && includeDiff && changed.length > 0;
+    const derivedTaskQuery = explicitQuery || explicitTargetProvided || dirtyContextTask ? "" : codeLikeQueryFromTask(contextInput.task);
+    const queryText = explicitQuery || derivedTaskQuery;
+    const naturalRetrieval = contextInput.task && !dirtyContextTask && shouldRunNaturalRetrieval(explicitTargetProvided, explicitConfigTarget, taskIntents)
+        ? await retrieveForTask(index, contextInput.task, Math.max(limit * 2, 12), semanticOptionsFromQueryOptions(repoRoot, options))
+        : undefined;
+    const naturalExpansionAllowed = Boolean(naturalRetrieval &&
+        !dirtyContextTask &&
+        !queryText.trim() &&
+        (!explicitTargetProvided ||
+            (explicitConfigTarget &&
+                (naturalRetrieval.intentConfidence.mode === "edit" ||
+                    naturalRetrieval.intentConfidence.anchors.length > 0 ||
+                    naturalRetrieval.intents.some((intent) => intent === "configuration" || intent === "testing")))));
+    const naturalRetrievalFocused = Boolean(naturalRetrieval && naturalRetrieval.matches.length > 0 && naturalExpansionAllowed);
+    const explicitFocusProvided = explicitTargetProvided || Boolean(queryText) || naturalRetrievalFocused;
+    if (queryText.trim()) {
+        addLexicalQueryFocus(index, queryText, addFocus);
+    }
+    if (naturalExpansionAllowed && naturalRetrieval) {
+        addNaturalRetrievalFocus({
+            naturalRetrieval,
+            explicitTargetProvided,
+            explicitConfigTarget,
+            limit,
+            focus: focusState
+        });
+    }
+    const indexedPaths = new Set(index.files.map((file) => file.path));
+    const unindexedChanged = changed.filter((file) => !indexedPaths.has(file));
+    const groups = groupDiffImpact(index, changedEntries, changedSymbols, unindexedChanged).slice(0, 12);
+    const { broadDirty, dirtyDrivesFocus } = addDirtyWorktreeFocus({
+        index,
+        changed,
+        changedSymbols,
+        groups,
+        indexedPaths,
+        explicitFocusProvided,
+        dirtyContextTask,
+        limit,
+        focus: focusState,
+        warnings
+    });
+    if (!dirtyContextTask) {
+        addContextPackImpactExpansion(index, impactSeeds, changeType, limit, addFocus);
+    }
+    if (requestedFiles.length > 0 || requestedSymbols.length > 0 || queryText.trim() || naturalExpansionAllowed) {
+        const testSeedPaths = uniqueSorted([...impactSeeds.keys(), ...focus.keys()]);
+        for (const test of recommendTests(index, testSeedPaths, repoRoot).slice(0, Math.max(1, Math.min(4, Math.floor(limit / 2))))) {
+            addFocus(test.path, `likely test: ${test.reason}`, test.evidenceTier === "authoritative" ? 18 : test.evidenceTier === "derived" ? 14 : 8, test.evidenceTier ?? "derived", "test_evidence");
+        }
+    }
+    if (focus.size === 0) {
+        for (const file of index.files.slice(0, limit)) {
+            addFocus(file.path, "top-ranked fallback", 1, "fallback", "rank_fallback");
+        }
+    }
+    const focusEntries = [...focus.values()].sort((a, b) => tierScore(a.tier) - tierScore(b.tier) || b.rank - a.rank || a.file.path.localeCompare(b.file.path)).slice(0, limit);
+    const focusPaths = focusEntries.map((entry) => entry.file.path);
+    const contextSeedPaths = dirtyContextTask ? focusPaths : dirtyDrivesFocus ? uniqueSorted([...focusPaths, ...changed]) : focusPaths;
+    const snippetChangedSymbols = dirtyDrivesFocus ? changedSymbols : changedSymbols.filter((entry) => impactSeeds.has(entry.symbol.path));
+    const testLimit = dirtyContextTask ? Math.max(1, Math.min(2, contextSeedPaths.length)) : 12;
+    const tests = recommendTests(index, contextSeedPaths, repoRoot).slice(0, testLimit);
+    const snippetQueryText = queryText ||
+        contextInput.task ||
+        requestedSymbols.join(" ") ||
+        requestedFiles
+            .flatMap((filePath) => fileStemQueryTerms(path.posix.basename(filePath).replace(/\.[^.]+$/, "")))
+            .join(" ");
+    const snippets = includeSnippets ? await contextSnippets(repoRoot, index, focusPaths, snippetChangedSymbols, snippetQueryText, limit) : [];
+    const nextReads = focusEntries.slice(0, Math.min(8, focusEntries.length)).map((entry) => entry.file.path);
+    const dirtyScope = dirtyContextTask
+        ? dirtyScopeSummary({
+            taskIntents,
+            changed,
+            worktree,
+            broadDirty,
+            focusEntries
+        })
+        : undefined;
+    const packetIntent = naturalRetrieval
+        ? packetIntentConfidence(naturalRetrieval.intentConfidence, focusEntries, {
+            explicitTargetProvided,
+            dirtyAnchorAllowed: Boolean(contextInput.task && taskReferencesDirtyContext(contextInput.task) && dirtyDrivesFocus && !broadDirty)
+        })
+        : dirtyScope
+            ? dirtyWorktreeIntentConfidence({
+                taskIntents,
+                dirtyScope,
+                focusEntries,
+                worktree
+            })
+            : undefined;
+    const packetDiagnostics = packetIntent ? packetIntentDiagnostics(packetIntent, naturalRetrieval?.diagnostics ?? []) : [];
+    const actionability = packetIntent
+        ? actionabilityFromPacketVerdict(packetIntent.verdict)
+        : explicitTargetProvided
+            ? "inspect_first"
+            : qualityLikeFallbackActionability(focusEntries);
+    const baseline = explicitQuery ? await baselineSearchSummary(repoRoot, queryText) : undefined;
+    const gaps = [...indexGaps(index, freshness, unindexedChanged), ...(worktree ? worktreeStateGaps(worktree) : [])];
+    const quality = assessContextQuality({
+        freshness,
+        gaps,
+        tiers: focusTierCounts(focusEntries),
+        selectedCount: focusEntries.length,
+        fanoutCount: dirtyDrivesFocus ? changed.length : focusEntries.length,
+        testCount: tests.length,
+        queryBroad: naturalRetrieval?.broad,
+        centralFileCount: focusEntries.filter((entry) => entry.file.rank >= (index.files[Math.min(index.files.length - 1, 5)]?.rank ?? Number.POSITIVE_INFINITY)).length,
+        packetVerdict: explicitTargetProvided ? undefined : packetIntent?.verdict,
+        discardedAnchorCount: explicitTargetProvided ? 0 : packetIntent?.discardedAnchorCount
+    });
+    const suppressActionGuidance = quality.level === "low";
+    const displayedTests = suppressActionGuidance ? [] : tests;
+    const recipes = suppressActionGuidance ? [] : verificationRecipes(index, contextSeedPaths, changeType).slice(0, 8);
+    const verificationCommands = suppressActionGuidance ? [] : verificationCommandsForContext(index, repoRoot, contextSeedPaths, displayedTests, 16);
+    const verificationCoverage = suppressActionGuidance ? [] : coverageForDisplay(index, verificationCommands, repoRoot);
+    const commandPlan = suppressActionGuidance ? [] : verificationCommandPlan(verificationCoverage);
+    const value = valueEstimate("context_pack", {
+        rawFileCount: baseline?.lines,
+        codexaFileCount: focusEntries.length,
+        exactTargetCount: requestedFiles.length + requestedSymbols.length,
+        testCount: displayedTests.length,
+        parserErrors: index.parserErrors.length,
+        affectedCount: changed.length,
+        quality
+    });
+    const lspAssist = options.lsp || process.env.CODEXA_LSP === "1"
+        ? await lspAssistForFiles(repoRoot, focusEntries.map((entry) => entry.file), lspOptionsFromQueryOptions(options))
+        : [];
+    const sessionMemory = await sessionMemoryPreview({
+        repoRoot,
+        freshness,
+        files: focusPaths,
+        symbols: requestedSymbols,
+        topics: contextInput.task ? [contextInput.task] : explicitQuery ? [explicitQuery] : [],
+        limit: 6
+    });
+    const workspaceGuidance = await workspaceGuidancePreview({
+        repoRoot,
+        task: contextInput.task,
+        query: explicitQuery,
+        files: uniqueSorted([...requestedFiles, ...focusPaths]).slice(0, 24),
+        symbols: requestedSymbols,
+        limit: 6
+    });
+    const contextSources = summarizeContextSources(focusEntries);
+    const dirtyScopeChangePlan = dirtyScope?.mode === "edit" && dirtyScope.canPlan && packetIntent?.verdict === "edit-ready";
+    const changePlanInputs = dirtyScopeChangePlan
+        ? { task: contextInput.task, diff: true, changeType, saveSnapshot: true }
+        : { task: contextInput.task, files: focusPaths.slice(0, 8), changeType, saveSnapshot: true };
+    const nextTools = [
+        packetIntent?.verdict === "needs-target" || packetIntent?.verdict === "orientation-only"
+            ? nextTool(packetIntent.recommendedNextTool, "context packet needs a narrower edit target", { task: contextInput.task ?? explicitQuery })
+            : undefined,
+        focusPaths.length > 0
+            ? nextTool("change_plan", dirtyScopeChangePlan ? "save the full dirty-worktree edit plan and planned verification before editing" : "save the focused edit plan and planned verification before editing", changePlanInputs, true, [".codex/cache/codexa-task-snapshots"])
+            : undefined,
+        displayedTests.length > 0 ? nextTool("test_plan", "inspect targeted verification for the focused files", { files: focusPaths.slice(0, 8) }) : undefined
+    ].filter((tool) => Boolean(tool));
+    const text = [
+        freshnessBanner(freshness, refresh),
+        formatContextQuality(quality),
+        formatValueEstimate(value),
+        "Codexa context pack",
+        contextInput.task ? `Task: ${contextInput.task}` : undefined,
+        packetIntent ? `Packet verdict: ${packetIntent.verdict}; edit-ready ${packetIntent.editReady ? "yes" : "no"}; confidence ${Math.round(packetIntent.confidence * 100)}%` : undefined,
+        `Actionability: ${actionability}`,
+        packetIntent ? `Intent mode: ${packetIntent.mode}; primary ${packetIntent.intent}; anchors ${packetIntent.anchors.slice(0, 4).join(", ") || "none"}` : undefined,
+        packetIntent ? `Recommended next MCP call: ${packetIntent.recommendedNextTool}` : undefined,
+        packetDiagnostics.length ? `Retrieval diagnostics: ${packetDiagnostics.join("; ")}` : undefined,
+        `Change type: ${changeType}`,
+        `Budget: ${tokenBudget} tokens approx; focus files: ${focusEntries.length}; changed files: ${changed.length}`,
+        contextSources.length > 0 ? `Context sources: ${formatContextSources(contextSources)}` : undefined,
+        baseline ? `Baseline search: ${baseline.command} returned ${baseline.lines} non-empty lines; Codexa selected ${focusEntries.length} focus files.` : undefined,
+        warnings.length + session.warnings.length > 0
+            ? `Warnings: ${uniqueSorted([...session.warnings, ...warnings]).join("; ")}`
+            : undefined,
+        "",
+        "Read first:",
+        ...focusEntries.map((entry) => `- ${entry.file.path}: ${entry.tier}; rank ${entry.file.rank.toFixed(2)}, risk ${entry.file.riskScore.toFixed(1)}; ${formatReasons(entry.reasons)}`),
+        groups.length > 0 ? "" : undefined,
+        groups.length > 0 ? "Change groups:" : undefined,
+        ...(groups.length > 0 ? formatDiffGroups(groups) : []),
+        "",
+        "Likely tests:",
+        ...(suppressActionGuidance ? ["- deferred until Codexa has an explicit file, symbol, or higher-confidence packet."] : formatTestRecommendations(displayedTests)),
+        "",
+        "Known gaps:",
+        ...formatGaps(gaps),
+        ...(worktree ? worktreeStateText(worktree) : []),
+        lspAssist.length > 0 ? "" : undefined,
+        lspAssist.length > 0 ? "LSP assist:" : undefined,
+        ...lspAssist.flatMap((assist) => [
+            `- ${assist.file ?? "unknown"}: ${assist.status}${assist.server ? ` via ${assist.server}` : ""}; symbols ${assist.documentSymbols.length}; diagnostics ${assist.diagnostics.length}`,
+            ...assist.warnings.slice(0, 3).map((warning) => `  warning: ${warning}`)
+        ]),
+        sessionMemory.lines.length > 0 ? "" : undefined,
+        sessionMemory.lines.length > 0 ? "Session memory:" : undefined,
+        ...sessionMemory.lines,
+        workspaceGuidance.lines.length > 0 ? "" : undefined,
+        workspaceGuidance.lines.length > 0 ? "Workspace guidance:" : undefined,
+        ...workspaceGuidance.lines,
+        suppressActionGuidance ? undefined : "",
+        suppressActionGuidance ? undefined : "If run, these commands would cover:",
+        ...(suppressActionGuidance ? [] : formatVerificationCoverage(verificationCoverage)),
+        suppressActionGuidance ? undefined : "",
+        suppressActionGuidance ? undefined : "Verification recipes:",
+        ...(suppressActionGuidance ? [] : formatRecipes(recipes)),
+        snippets.length > 0 ? "" : undefined,
+        snippets.length > 0 ? "Evidence snippets:" : undefined,
+        ...snippets,
+        "",
+        "Next inspection order:",
+        ...nextReads.map((file) => `- ${file}`)
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+    return {
+        freshness,
+        refresh,
+        text: limitTextToTokens(text, tokenBudget),
+        data: {
+            mode: "context_pack",
+            task: contextInput.task,
+            changeType,
+            tokenBudget,
+            focusFiles: focusEntries.map((entry) => ({ file: compactFileFact(entry.file), reasons: uniqueSorted(entry.reasons).slice(0, 12), rank: entry.rank, tier: entry.tier })),
+            changedFiles: changed.slice(0, 120),
+            changedEntries: changedEntries.slice(0, 120),
+            changedSymbols: changedSymbols.slice(0, 80).map(compactChangedSymbol),
+            unindexedChanged: unindexedChanged.slice(0, 80),
+            worktree: worktree ? compactWorktreeState(worktree) : undefined,
+            worktreeDegradationReasons: worktree?.degradedReasons ?? [],
+            dirtyScope,
+            groups: groups.slice(0, 20).map(compactDiffGroup),
+            tests: displayedTests.slice(0, 30),
+            snippets,
+            contextSources,
+            warnings: uniqueSorted([...session.warnings, ...warnings]),
+            nextReads,
+            baseline,
+            retrieval: naturalRetrieval ? compactRetrievalResult(naturalRetrieval) : undefined,
+            lspAssist,
+            sessionMemory: sessionMemory.data,
+            workspaceGuidance: workspaceGuidance.data,
+            intentConfidence: packetIntent,
+            packetVerdict: packetIntent?.verdict,
+            actionability,
+            diagnostics: packetDiagnostics,
+            actionGuidanceSuppressed: suppressActionGuidance,
+            recipes,
+            verificationCommands,
+            verificationCoverage,
+            verificationCommandPlan: commandPlan,
+            value,
+            quality,
+            gaps,
+            nextTools,
+            systemMessage: nextTools[0]?.reason,
+            session: { commandBudgetMs: session.commandBudgetMs, maxResultBytes: session.maxResultBytes, maxResults: session.maxResults, provenance: session.provenance }
+        }
+    };
+}
+function createContextFocusState(index, warnings) {
+    const focus = new Map();
+    const impactSeeds = new Map();
+    const addFocus = (filePath, reason, rank = 1, tier = "derived", source) => {
+        const file = findFile(index, filePath);
+        if (!file) {
+            warnings.push(`unindexed file ${filePath}`);
+            return;
+        }
+        const existing = focus.get(file.path) ?? { file, reasons: new Set(), rank: file.rank, tier, provenance: [] };
+        existing.reasons.add(reason);
+        const sources = source ? [source] : contextSourcesForReason(reason);
+        for (const provenanceSource of sources.length > 0 ? sources : ["rank_fallback"]) {
+            const provenanceTier = provenanceSource === "lexical_query" && tier === "authoritative" ? "derived" : tier;
+            if (!existing.provenance.some((entry) => entry.source === provenanceSource && entry.reason === reason && entry.tier === provenanceTier)) {
+                existing.provenance.push({ source: provenanceSource, reason, tier: provenanceTier });
+            }
+        }
+        existing.rank += rank;
+        existing.tier = betterTier(existing.tier, tier);
+        focus.set(file.path, existing);
+    };
+    return { focus, impactSeeds, addFocus };
+}
+function addExplicitTargetsToContextFocus(input) {
+    const requestedResolvedPaths = [];
+    for (const requested of input.requestedFiles) {
+        const resolved = resolveFileTarget(input.index, requested, input.repoRoot);
+        if (resolved.ambiguous.length > 0) {
+            input.warnings.push(`ambiguous file ${requested}`);
+            continue;
+        }
+        if (resolved.file) {
+            requestedResolvedPaths.push(resolved.file.path);
+            input.focus.addFocus(resolved.file.path, "requested file", 100, "authoritative", "explicit_target");
+            input.focus.impactSeeds.set(resolved.file.path, "requested file");
+        }
+        else {
+            input.warnings.push(`missing file ${requested}`);
+        }
+    }
+    for (const requested of input.requestedSymbols) {
+        const resolved = resolveSymbolTarget(input.index, requested);
+        if (resolved.ambiguous.length > 0) {
+            input.warnings.push(`ambiguous symbol ${requested}`);
+            continue;
+        }
+        if (resolved.symbol) {
+            input.focus.addFocus(resolved.symbol.path, `requested symbol ${resolved.symbol.qualifiedName}`, 100, "authoritative", "explicit_target");
+            input.focus.impactSeeds.set(resolved.symbol.path, `requested symbol ${resolved.symbol.qualifiedName}`);
+            for (const usage of input.index.usageSites.filter((site) => site.targetSymbolId === resolved.symbol.id).slice(0, 12)) {
+                input.focus.addFocus(usage.path, `uses ${resolved.symbol.qualifiedName}`, 4, confidenceTier(usage.confidence), "graph_impact");
+            }
+        }
+        else {
+            input.warnings.push(`missing symbol ${requested}`);
+        }
+    }
+    return requestedResolvedPaths;
+}
+function addLexicalQueryFocus(index, queryText, addFocus) {
+    for (const file of index.files) {
+        const score = matchScore(queryText, file.path);
+        if (score > 0) {
+            addFocus(file.path, `path ${matchReason(score)} ${queryText}`, score, score >= 9 ? "derived" : "heuristic", "lexical_query");
+        }
+    }
+    for (const symbol of index.symbols) {
+        const score = Math.max(matchScore(queryText, symbol.name), matchScore(queryText, symbol.qualifiedName), matchScore(queryText, symbol.path));
+        if (score > 0) {
+            addFocus(symbol.path, `symbol ${matchReason(score)} ${symbol.qualifiedName}`, score + 1, score >= 9 ? confidenceTier(symbol.confidence) : "heuristic", "lexical_query");
+        }
+    }
+    for (const usage of index.usageSites) {
+        const score = Math.max(matchScore(queryText, usage.name), matchScore(queryText, usage.text), matchScore(queryText, usage.path));
+        if (score > 0) {
+            addFocus(usage.path, `usage ${matchReason(score)} ${usage.name}`, score, confidenceTier(usage.confidence), "lexical_query");
+        }
+    }
+}
+function addNaturalRetrievalFocus(input) {
+    const scoreScale = input.explicitTargetProvided ? 0.6 : 1;
+    for (const match of input.naturalRetrieval.matches.slice(0, input.limit * 2)) {
+        if (input.explicitTargetProvided && !shouldAddExplicitNaturalMatch(match, input.explicitConfigTarget)) {
+            continue;
+        }
+        const testLaneBacked = Boolean((match.lanes.test ?? 0) > 0 && input.naturalRetrieval.intents.includes("testing") && !input.naturalRetrieval.intents.includes("implementation"));
+        const laneBacked = Boolean((match.lanes.exact ?? 0) > 0 || (match.lanes.symbol ?? 0) > 0 || (match.lanes.workflow ?? 0) > 0 || testLaneBacked);
+        input.focus.addFocus(match.file.path, `natural task retrieval ${match.matchedTerms.slice(0, 6).join(", ") || "intent"}: ${formatReasons(match.reasons, 3)}`, Math.max(2, match.score * scoreScale), laneBacked ? "derived" : "heuristic", "natural_retrieval");
+        if (laneBacked || match.score >= 4) {
+            input.focus.impactSeeds.set(match.file.path, "natural task retrieval");
+        }
+    }
+    if (!input.explicitTargetProvided) {
+        for (const workflow of input.naturalRetrieval.workflows.slice(0, 4)) {
+            for (const filePath of workflow.relatedFiles.slice(0, 6)) {
+                input.focus.addFocus(filePath, `workflow ${workflow.title}`, Math.max(2, workflow.rank / 4), confidenceTier(workflow.confidence), "workflow_trace");
+            }
+        }
+    }
+}
+function addDirtyWorktreeFocus(input) {
+    const broadDirty = input.changed.length > Math.max(8, input.limit);
+    const dirtyDrivesFocus = input.changed.length > 0 && (!input.explicitFocusProvided || !broadDirty);
+    if (input.changed.length > 0 && input.explicitFocusProvided && broadDirty) {
+        input.warnings.push(`broad dirty tree (${input.changed.length} files) kept as diff context, not read-first focus`);
+    }
+    if (!dirtyDrivesFocus) {
+        return { broadDirty, dirtyDrivesFocus };
+    }
+    const dirtyRepresentativeLimit = input.dirtyContextTask ? Math.max(1, Math.min(2, Math.ceil(input.limit / 5))) : input.limit * 2;
+    const dirtyRepresentativePaths = new Set();
+    if (input.dirtyContextTask) {
+        for (const group of input.groups.slice(0, dirtyRepresentativeLimit)) {
+            const representative = representativeFileForDiffGroup(input.index, group.files);
+            if (representative) {
+                dirtyRepresentativePaths.add(representative.path);
+                input.focus.addFocus(representative.path, `change-group representative ${group.module}`, 12, group.kind === "unknown" ? "fallback" : "authoritative", "dirty_worktree");
+                input.focus.impactSeeds.set(representative.path, `change-group representative ${group.module}`);
+            }
+        }
+        if (dirtyRepresentativePaths.size === 0) {
+            for (const file of input.changed.filter((candidate) => input.indexedPaths.has(candidate)).slice(0, dirtyRepresentativeLimit)) {
+                dirtyRepresentativePaths.add(file);
+                input.focus.addFocus(file, "dirty diff", 6, "authoritative", "dirty_worktree");
+                input.focus.impactSeeds.set(file, "dirty diff");
+            }
+        }
+    }
+    else {
+        for (const file of input.changed.filter((candidate) => input.indexedPaths.has(candidate)).slice(0, input.limit * 2)) {
+            input.focus.addFocus(file, "dirty diff", 6, "authoritative", "dirty_worktree");
+            input.focus.impactSeeds.set(file, "dirty diff");
+        }
+        for (const entry of input.changedSymbols.slice(0, input.limit * 2)) {
+            input.focus.addFocus(entry.symbol.path, `changed symbol ${entry.symbol.qualifiedName}`, 6, "derived", "dirty_worktree");
+            input.focus.impactSeeds.set(entry.symbol.path, `changed symbol ${entry.symbol.qualifiedName}`);
+        }
+    }
+    for (const group of input.groups) {
+        if (input.dirtyContextTask && dirtyRepresentativePaths.size >= dirtyRepresentativeLimit) {
+            break;
+        }
+        const representative = representativeFileForDiffGroup(input.index, group.files);
+        if (representative) {
+            if (input.dirtyContextTask) {
+                dirtyRepresentativePaths.add(representative.path);
+            }
+            input.focus.addFocus(representative.path, `change-group representative ${group.module}`, 5, group.kind === "unknown" ? "fallback" : "derived", "dirty_worktree");
+        }
+    }
+    return { broadDirty, dirtyDrivesFocus };
+}
+function summarizeContextSources(focusEntries) {
+    const summaries = new Map();
+    const add = (source, filePath, tier, reason) => {
+        const summary = summaries.get(source) ?? {
+            fileTiers: new Map(),
+            reasons: new Set()
+        };
+        summary.fileTiers.set(filePath, betterTier(summary.fileTiers.get(filePath) ?? "fallback", tier));
+        summary.reasons.add(reason);
+        summaries.set(source, summary);
+    };
+    for (const entry of focusEntries) {
+        if (entry.provenance.length === 0) {
+            add("rank_fallback", entry.file.path, "fallback", "ranked context selection");
+            continue;
+        }
+        for (const provenance of entry.provenance) {
+            add(provenance.source, entry.file.path, provenance.tier, provenance.reason);
+        }
+    }
+    const priority = ["explicit_target", "dirty_worktree", "natural_retrieval", "graph_impact", "workflow_trace", "test_evidence", "lexical_query", "rank_fallback"];
+    return [...summaries.entries()]
+        .map(([source, summary]) => {
+        const evidenceTierCounts = { authoritative: 0, derived: 0, heuristic: 0, fallback: 0 };
+        for (const tier of summary.fileTiers.values()) {
+            evidenceTierCounts[tier] += 1;
+        }
+        return {
+            source,
+            fileCount: summary.fileTiers.size,
+            evidenceTierCounts,
+            sampleFiles: [...summary.fileTiers.keys()].sort().slice(0, 6),
+            sampleReasons: [...summary.reasons].sort().slice(0, 6)
+        };
+    })
+        .sort((a, b) => priority.indexOf(a.source) - priority.indexOf(b.source) || b.fileCount - a.fileCount || a.source.localeCompare(b.source));
+}
+function contextSourcesForReason(reason) {
+    const lower = reason.toLowerCase();
+    if (lower.startsWith("likely test")) {
+        return ["test_evidence"];
+    }
+    const sources = [];
+    if (lower === "requested file" || lower.startsWith("requested symbol ")) {
+        sources.push("explicit_target");
+    }
+    if (lower.includes("dirty diff") || lower.includes("changed symbol") || lower.includes("change-group representative")) {
+        sources.push("dirty_worktree");
+    }
+    if (lower.includes("natural task retrieval")) {
+        sources.push("natural_retrieval");
+    }
+    if (lower.includes("impact from") || lower.includes("imports ") || lower.includes("uses ") || lower.includes("call ") || lower.includes("reference ")) {
+        sources.push("graph_impact");
+    }
+    if (lower.startsWith("workflow ") || lower.includes("workflow entry") || lower.includes("workflow test candidate")) {
+        sources.push("workflow_trace");
+    }
+    if (lower.includes("likely test") || lower.includes("tests ")) {
+        sources.push("test_evidence");
+    }
+    if (lower.startsWith("path ") || lower.startsWith("symbol ") || lower.startsWith("usage ")) {
+        sources.push("lexical_query");
+    }
+    if (lower.includes("top-ranked fallback") || lower.includes("ranked project entry point")) {
+        sources.push("rank_fallback");
+    }
+    return sources;
+}
+function formatContextSources(sources) {
+    return sources
+        .slice(0, 8)
+        .map((source) => {
+        const tiers = ["authoritative", "derived", "heuristic", "fallback"]
+            .map((tier) => (source.evidenceTierCounts[tier] > 0 ? `${source.evidenceTierCounts[tier]} ${tier}` : undefined))
+            .filter((entry) => Boolean(entry))
+            .join(", ");
+        return `${source.source} ${source.fileCount} file${source.fileCount === 1 ? "" : "s"}${tiers ? ` (${tiers})` : ""}`;
+    })
+        .join("; ");
+}
+function representativeFileForDiffGroup(index, files) {
+    return files
+        .map((filePath) => findFile(index, filePath))
+        .filter((file) => Boolean(file))
+        .sort((a, b) => b.riskScore - a.riskScore || b.rank - a.rank || a.path.localeCompare(b.path))[0];
+}
+function shouldRunNaturalRetrieval(explicitTargetProvided, explicitConfigTarget, taskIntents) {
+    if (!explicitTargetProvided) {
+        return true;
+    }
+    if (!explicitConfigTarget) {
+        return false;
+    }
+    return taskIntents.some((intent) => intent === "configuration" || intent === "testing" || intent === "implementation");
+}
+export async function taskBriefQuery(input, contextInput = {}, options = {}) {
+    const result = await contextPackQuery(input, {
+        ...contextInput,
+        tokenBudget: contextInput.tokenBudget ?? 3000,
+        limit: contextInput.limit ?? 10,
+        includeSnippets: contextInput.includeSnippets ?? true
+    }, options);
+    return {
+        ...result,
+        text: result.text.replace("Codexa context pack", "Codexa task brief"),
+        data: {
+            ...(result.data && typeof result.data === "object" ? result.data : {}),
+            mode: "task_brief"
+        }
+    };
+}
+export async function focusBriefQuery(input, focusInput = {}, options = {}) {
+    const session = await ensureQuerySession(input, options);
+    const { index, freshness, refresh, repoRoot } = session;
+    const task = focusInput.task?.trim() || "Session start: identify project focus, current changes, workflows, and next Codexa call";
+    const limit = clampInt(focusInput.limit ?? 10, 3, session.maxResults);
+    const tokenBudget = clampInt(focusInput.tokenBudget ?? 2400, 600, 8000);
+    const retrieval = await retrieveForTask(index, task, limit, semanticOptionsFromQueryOptions(repoRoot, options));
+    const includeDiff = focusInput.diff ?? true;
+    const worktree = includeDiff ? await getWorktreeState(session) : undefined;
+    const changedEntries = worktree?.entries ?? [];
+    const changed = worktree?.files ?? [];
+    const indexedPaths = new Set(index.files.map((file) => file.path));
+    const unindexedChanged = changed.filter((file) => !indexedPaths.has(file));
+    const groups = includeDiff ? groupDiffImpact(index, changedEntries, worktree?.symbols ?? [], unindexedChanged).slice(0, 8) : [];
+    const exactMatches = exactFocusFileMatches(index, task).map((file) => ({
+        file,
+        score: file.rank + 100,
+        reasons: ["exact path in task"],
+        matchedTerms: [file.path],
+        tier: "derived"
+    }));
+    const workflowMatches = workflowFocusEntries(index, retrieval.workflows, task, limit);
+    const workflowTestMatches = workflowMatches.length > 0 && taskAsksForTests(task)
+        ? recommendTests(index, uniqueSorted(workflowMatches.map((entry) => entry.file.path)), repoRoot)
+            .slice(0, 4)
+            .map((test) => {
+            const file = findFile(index, test.path);
+            return file
+                ? {
+                    file,
+                    score: test.evidenceTier === "authoritative" ? 70 : test.evidenceTier === "derived" ? 62 : 48,
+                    reasons: [`workflow test candidate: ${test.reason}`],
+                    matchedTerms: [],
+                    tier: test.evidenceTier ?? "derived"
+                }
+                : undefined;
+        })
+            .filter((entry) => Boolean(entry))
+        : [];
+    const retrievalMatches = retrieval.matches.map((match) => ({ ...match, tier: focusMatchTier(match.file, task, match) }));
+    const workflowModules = new Set(workflowMatches.map((entry) => moduleNameForPath(entry.file.path)));
+    const workflowScopedMatches = workflowMatches.length > 0 && retrieval.broad
+        ? retrieval.matches
+            .filter((match) => workflowModules.has(moduleNameForPath(match.file.path)) || hasExactRetrievalLane(match))
+            .map((match) => ({ ...match, tier: focusMatchTier(match.file, task, match) }))
+        : retrievalMatches;
+    const selected = retrieval.matches.length > 0 || exactMatches.length > 0 || workflowMatches.length > 0
+        ? uniqueFocusEntries([...exactMatches, ...workflowMatches, ...workflowTestMatches, ...workflowScopedMatches]).slice(0, limit)
+        : index.files.slice(0, limit).map((file) => ({ file, score: file.rank, reasons: ["ranked project entry point fallback"], matchedTerms: [], tier: "fallback" }));
+    const focusFiles = uniqueFiles(selected.map((entry) => entry.file)).slice(0, limit);
+    const tiersByPath = new Map(selected.map((entry) => [entry.file.path, entry.tier]));
+    const tests = recommendTests(index, focusFiles.map((file) => file.path), repoRoot).slice(0, 10);
+    const nextCall = recommendNextCodexaCall(retrieval.intents, retrieval.workflows, changed.length, task);
+    const actionability = actionabilityFromPacketVerdict(retrieval.intentConfidence.verdict);
+    const recommendedNextCall = retrieval.intentConfidence.recommendedNextTool === nextCall.tool
+        ? `${nextCall.tool} - ${nextCall.reason}`
+        : `${retrieval.intentConfidence.recommendedNextTool} - ${nextCall.reason}`;
+    const gaps = [...indexGaps(index, freshness, unindexedChanged), ...(worktree ? worktreeStateGaps(worktree) : [])];
+    const quality = assessContextQuality({
+        freshness,
+        gaps,
+        tiers: {
+            authoritative: 0,
+            derived: focusFiles.filter((file) => tiersByPath.get(file.path) === "derived").length,
+            heuristic: focusFiles.filter((file) => tiersByPath.get(file.path) === "heuristic").length +
+                retrieval.workflows.filter((workflow) => workflow.confidence === "heuristic").length,
+            fallback: focusFiles.filter((file) => tiersByPath.get(file.path) === "fallback").length
+        },
+        selectedCount: focusFiles.length,
+        testCount: tests.length,
+        queryBroad: retrieval.broad,
+        centralFileCount: focusFiles.filter((file) => file.rank >= index.files[Math.min(index.files.length - 1, 5)]?.rank).length,
+        packetVerdict: retrieval.intentConfidence.verdict,
+        discardedAnchorCount: retrieval.intentConfidence.discardedAnchorCount
+    });
+    const sessionMemory = await sessionMemoryPreview({
+        repoRoot,
+        freshness,
+        files: focusFiles.map((file) => file.path),
+        topics: [task],
+        limit: 6
+    });
+    const workspaceGuidance = await workspaceGuidancePreview({
+        repoRoot,
+        task,
+        files: focusFiles.map((file) => file.path),
+        limit: 6
+    });
+    const text = [
+        freshnessBanner(freshness, refresh),
+        formatContextQuality(quality),
+        "Codexa focus brief",
+        `Task: ${task}`,
+        `Intent: ${retrieval.intents.join(", ")}`,
+        `Packet verdict: ${retrieval.intentConfidence.verdict}; edit-ready ${retrieval.intentConfidence.editReady ? "yes" : "no"}; confidence ${Math.round(retrieval.intentConfidence.confidence * 100)}%`,
+        `Actionability: ${actionability}`,
+        `Intent mode: ${retrieval.intentConfidence.mode}; primary ${retrieval.intentConfidence.intent}; anchors ${retrieval.intentConfidence.anchors.slice(0, 4).join(", ") || "none"}`,
+        retrieval.diagnostics.length > 0 ? `Retrieval diagnostics: ${retrieval.diagnostics.join("; ")}` : undefined,
+        `Recommended next MCP call: ${recommendedNextCall}`,
+        nextCall.arguments ? `Suggested arguments: ${JSON.stringify(nextCall.arguments)}` : undefined,
+        "",
+        "Likely subsystems:",
+        ...(retrieval.modules.length > 0
+            ? retrieval.modules.map((module) => `- ${module.name}: score ${module.score.toFixed(2)}; files ${module.files.slice(0, 5).join(", ")}; ${module.reasons.join("; ") || "task intent match"}`)
+            : index.modules.slice(0, 5).map((module) => `- ${module.name}: rank ${module.rank.toFixed(2)}; ${module.summary}`)),
+        "",
+        "Read first:",
+        ...focusFiles.map((file) => {
+            const match = selected.find((entry) => entry.file.path === file.path);
+            const reasons = match?.reasons.length ? match.reasons.join("; ") : "ranked project entry point";
+            return `- ${file.path}: score ${(match?.score ?? file.rank).toFixed(2)}, rank ${file.rank.toFixed(2)}, risk ${file.riskScore.toFixed(1)}; ${reasons}`;
+        }),
+        retrieval.workflows.length > 0 ? "" : undefined,
+        retrieval.workflows.length > 0 ? "Likely workflows:" : undefined,
+        ...retrieval.workflows.slice(0, 6).map(formatWorkflowSummary),
+        groups.length > 0 ? "" : undefined,
+        groups.length > 0 ? "Current change groups:" : undefined,
+        ...(groups.length > 0 ? formatDiffGroups(groups) : []),
+        sessionMemory.lines.length > 0 ? "" : undefined,
+        sessionMemory.lines.length > 0 ? "Session memory:" : undefined,
+        ...sessionMemory.lines,
+        workspaceGuidance.lines.length > 0 ? "" : undefined,
+        workspaceGuidance.lines.length > 0 ? "Workspace guidance:" : undefined,
+        ...workspaceGuidance.lines,
+        "",
+        "Likely tests:",
+        ...formatTestRecommendations(tests),
+        "",
+        "Known gaps:",
+        ...formatGaps(gaps),
+        ...(worktree ? worktreeStateText(worktree) : [])
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+    return {
+        freshness,
+        refresh,
+        text: limitTextToTokens(text, tokenBudget),
+        data: {
+            mode: "focus_brief",
+            task,
+            retrieval: compactRetrievalResult(retrieval),
+            intentConfidence: retrieval.intentConfidence,
+            packetVerdict: retrieval.intentConfidence.verdict,
+            actionability,
+            diagnostics: retrieval.diagnostics,
+            focusFiles: focusFiles.map(compactFileFact),
+            workflows: retrieval.workflows.slice(0, 12).map(compactWorkflowTrace),
+            modules: retrieval.modules.slice(0, 12).map((module) => ({ ...module, files: module.files.slice(0, 40), reasons: module.reasons.slice(0, 12) })),
+            groups: groups.slice(0, 12).map(compactDiffGroup),
+            worktree: worktree ? compactWorktreeState(worktree) : undefined,
+            worktreeDegradationReasons: worktree?.degradedReasons ?? [],
+            tests: tests.slice(0, 30),
+            nextCall,
+            sessionMemory: sessionMemory.data,
+            workspaceGuidance: workspaceGuidance.data,
+            quality,
+            gaps
+        }
+    };
+}
+function focusMatchTier(file, task, match) {
+    const lowerTask = task.toLowerCase();
+    const lowerPath = file.path.toLowerCase();
+    const baseName = path.posix.basename(lowerPath);
+    const stem = baseName.replace(/\.[^.]+$/u, "");
+    if (lowerTask.includes(lowerPath) || lowerTask.includes(baseName) || (stem.length >= 4 && lowerTask.includes(stem))) {
+        return "derived";
+    }
+    if (match && ((match.lanes.exact ?? 0) > 0 || (match.lanes.symbol ?? 0) > 0 || (match.lanes.workflow ?? 0) > 0 || (match.lanes.dirty ?? 0) > 0)) {
+        return "derived";
+    }
+    if (match && (match.lanes.test ?? 0) > 0 && taskAsksForTests(task)) {
+        return "derived";
+    }
+    return "heuristic";
+}
+function workflowFocusEntries(index, workflows, task, limit) {
+    const includeTests = taskAsksForTests(task);
+    const entries = [];
+    const scopedWorkflows = preferredWorkflowsForTask(workflows, task);
+    const add = (filePath, score, reason, tier) => {
+        if (!filePath) {
+            return;
+        }
+        const file = findFile(index, filePath);
+        if (!file) {
+            return;
+        }
+        if ((file.test || isTestPath(file.path)) && !includeTests) {
+            return;
+        }
+        entries.push({
+            file,
+            score,
+            reasons: [reason],
+            matchedTerms: [],
+            tier
+        });
+    };
+    for (const workflow of scopedWorkflows.slice(0, Math.max(1, Math.min(3, limit)))) {
+        const tier = confidenceTier(workflow.confidence);
+        add(workflow.entryPath, 90 + workflow.rank, `workflow entry ${workflow.title}`, tier);
+        for (const step of workflow.steps.slice(0, 24)) {
+            const stepTier = confidenceTier(step.confidence);
+            const score = step.kind === "entry"
+                ? 85
+                : step.kind === "endpoint" || step.kind === "ui"
+                    ? 72
+                    : step.kind === "store" || step.kind === "adapter" || step.kind === "manifest"
+                        ? 68
+                        : step.kind === "test"
+                            ? 62
+                            : step.kind === "call" || step.kind === "reference" || step.kind === "import"
+                                ? 58
+                                : 36;
+            add(step.path, score, `workflow ${workflow.title}: ${step.kind}`, stepTier);
+            add(step.targetPath, Math.max(20, score - 8), `workflow ${workflow.title}: target ${step.kind}`, stepTier);
+        }
+        for (const filePath of workflow.relatedFiles.slice(0, 12)) {
+            add(filePath, 45, `workflow related ${workflow.title}`, tier);
+        }
+    }
+    return entries;
+}
+function preferredWorkflowsForTask(workflows, task) {
+    const lower = task.toLowerCase();
+    const preferredKinds = new Set();
+    if (/\b(route|routes|endpoint|endpoints|api|request|handler|backend)\b/u.test(lower)) {
+        preferredKinds.add("route");
+    }
+    if (/\b(job|jobs|queue|worker|task|tasks|background|celery|polling)\b/u.test(lower)) {
+        preferredKinds.add("job");
+    }
+    if (/\b(manifest|node|nodes|adapter|package|registry)\b/u.test(lower)) {
+        preferredKinds.add("manifest");
+    }
+    if (preferredKinds.size === 0) {
+        return workflows;
+    }
+    const narrowed = workflows.filter((workflow) => preferredKinds.has(workflow.workflowKind));
+    return narrowed.length > 0 ? narrowed : workflows;
+}
+function hasExactRetrievalLane(match) {
+    return Boolean((match.lanes.exact ?? 0) > 0);
+}
+function taskAsksForTests(task) {
+    return /\b(test|tests|spec|specs|pytest|vitest|coverage|verification|verify|tested)\b/iu.test(task);
+}
+function exactFocusFileMatches(index, task) {
+    const lowerTask = task.toLowerCase();
+    return index.files
+        .filter((file) => {
+        const lowerPath = file.path.toLowerCase();
+        const baseName = path.posix.basename(lowerPath);
+        return lowerTask.includes(lowerPath) || lowerTask.includes(baseName);
+    })
+        .sort((a, b) => b.rank - a.rank || a.path.localeCompare(b.path));
+}
+function isConfigExpansionPath(filePath) {
+    return (/^manifests?\//u.test(filePath) ||
+        /(^|\/)(package|manifest|node|adapter)[^/]*\.(json|ya?ml|toml)$/iu.test(filePath) ||
+        /\.(json|ya?ml|toml)$/iu.test(filePath));
+}
+function shouldAddExplicitNaturalMatch(match, explicitConfigTarget) {
+    if (!explicitConfigTarget) {
+        return false;
+    }
+    const laneBacked = Boolean((match.lanes.exact ?? 0) > 0 || (match.lanes.symbol ?? 0) > 0 || (match.lanes.bm25 ?? 0) > 0);
+    if (!laneBacked) {
+        return false;
+    }
+    const evidenceText = `${match.file.path} ${match.reasons.join(" ")}`.toLowerCase();
+    return /\b(adapter|manifest|node|type_id|node_type)\b/u.test(evidenceText) || /(^|\/)adapters?\//u.test(match.file.path);
+}
+function dirtyScopeSummary(input) {
+    const mode = dirtyScopeMode(input.taskIntents);
+    const changedPlanFiles = uniqueSorted(input.changed.filter((filePath) => !isCodexaControlPath(filePath)));
+    const degraded = input.worktree?.degraded ?? false;
+    const canPlan = changedPlanFiles.length > 0 && !degraded;
+    const reason = degraded
+        ? `worktree state unavailable: ${input.worktree?.degradedReasons.join("; ") || "unknown"}`
+        : changedPlanFiles.length === 0
+            ? "no dirty files available for the requested dirty-worktree scope"
+            : mode === "edit"
+                ? "current dirty worktree is the explicit edit scope"
+                : "current dirty worktree is the explicit inspection scope";
+    return {
+        requested: true,
+        mode,
+        canPlan,
+        broad: input.broadDirty,
+        changedFileCount: changedPlanFiles.length,
+        representativeCount: input.focusEntries.filter((entry) => entry.provenance.some((item) => item.source === "dirty_worktree")).length,
+        plannedEditTargets: changedPlanFiles,
+        reason
+    };
+}
+function dirtyScopeMode(taskIntents) {
+    return taskIntents.some((intent) => intent === "implementation" || intent === "debugging") ? "edit" : "orientation";
+}
+function dirtyWorktreeIntentConfidence(input) {
+    const primaryIntent = input.taskIntents.find((intent) => intent !== "unknown") ?? "unknown";
+    const dirtyAnchors = uniqueSorted(input.focusEntries
+        .filter((entry) => entry.provenance.some((item) => item.source === "dirty_worktree"))
+        .map((entry) => entry.file.path)).slice(0, 8);
+    const missingAnchors = [];
+    if (input.dirtyScope.changedFileCount === 0) {
+        missingAnchors.push("no dirty files");
+    }
+    if (input.worktree?.degraded) {
+        missingAnchors.push("worktree state unavailable");
+    }
+    if (input.dirtyScope.mode === "edit" && dirtyAnchors.length === 0) {
+        missingAnchors.push("no selected dirty-worktree anchors");
+    }
+    const confidence = Math.max(0, Math.min(1, 0.46 +
+        Math.min(0.24, dirtyAnchors.length * 0.06) +
+        (input.dirtyScope.canPlan ? 0.18 : 0) -
+        (input.dirtyScope.broad ? 0.08 : 0) -
+        missingAnchors.length * 0.2));
+    const editReady = input.dirtyScope.mode === "edit" && input.dirtyScope.canPlan && dirtyAnchors.length > 0 && missingAnchors.length === 0 && confidence >= 0.48;
+    const verdict = editReady
+        ? "edit-ready"
+        : input.dirtyScope.mode === "orientation" && dirtyAnchors.length > 0 && !input.worktree?.degraded
+            ? "orientation-only"
+            : "needs-target";
+    const recommendedNextTool = verdict === "edit-ready" ? "change_plan" : verdict === "orientation-only" ? "diff_impact" : "search";
+    return {
+        mode: input.dirtyScope.mode,
+        intent: primaryIntent,
+        confidence,
+        anchors: dirtyAnchors,
+        selectedAnchorCount: dirtyAnchors.length,
+        discardedAnchorCount: Math.max(0, input.dirtyScope.changedFileCount - dirtyAnchors.length),
+        missingAnchors: uniqueSorted(missingAnchors),
+        recommendedNextTool,
+        editReady,
+        verdict,
+        reasons: uniqueSorted([
+            `mode ${input.dirtyScope.mode}`,
+            `primary intent ${primaryIntent}`,
+            "explicit dirty-worktree scope",
+            `${input.dirtyScope.changedFileCount} dirty file(s)`,
+            input.dirtyScope.broad ? "broad dirty tree represented by ranked change groups" : undefined,
+            dirtyAnchors.length > 0 ? `${dirtyAnchors.length} selected dirty-worktree anchor(s)` : "no selected dirty-worktree anchors",
+            ...missingAnchors.map((anchor) => `missing ${anchor}`)
+        ].filter((entry) => Boolean(entry)))
+    };
+}
+function packetIntentConfidence(base, focusEntries, options) {
+    const focusPathSet = new Set(focusEntries.map((entry) => entry.file.path));
+    const allowTestAnchors = options.explicitTargetProvided || base.intent === "testing";
+    const selectedBaseAnchors = base.anchors.filter((anchor) => focusPathSet.has(anchor));
+    const evidenceEntries = focusEntries
+        .filter((entry) => entry.tier === "authoritative" || entry.tier === "derived")
+        .filter((entry) => entry.reasons.size > 0);
+    const strongEvidenceAnchors = evidenceEntries
+        .filter((entry) => isStrongPacketAnchor(entry, options.dirtyAnchorAllowed))
+        .filter((entry) => allowTestAnchors || (!entry.file.test && !isTestPath(entry.file.path)))
+        .map((entry) => entry.file.path);
+    const anchors = uniqueSorted([...selectedBaseAnchors, ...strongEvidenceAnchors]).slice(0, 8);
+    const nonTestEvidenceCount = evidenceEntries.filter((entry) => !entry.file.test && !isTestPath(entry.file.path)).length;
+    const selectedTestOnlyAnchorCount = allowTestAnchors || anchors.length > 0 || nonTestEvidenceCount > 0
+        ? 0
+        : evidenceEntries.filter((entry) => entry.file.test || isTestPath(entry.file.path)).length;
+    const discardedAnchorCount = base.anchors.filter((anchor) => !focusPathSet.has(anchor)).length;
+    const missingAnchors = base.missingAnchors.filter((reason) => {
+        if (anchors.length > 0 && (reason === "no authoritative or derived edit anchor" || reason === "broad prompt matched only weak lexical evidence")) {
+            return false;
+        }
+        if (selectedTestOnlyAnchorCount === 0 && reason === "only test anchors for edit prompt") {
+            return false;
+        }
+        return true;
+    });
+    if (base.mode === "edit" && anchors.length === 0 && !missingAnchors.includes("no selected packet anchors")) {
+        missingAnchors.push("no selected packet anchors");
+    }
+    if (base.mode === "edit" && selectedTestOnlyAnchorCount > 0 && !missingAnchors.includes("only test anchors for edit prompt")) {
+        missingAnchors.push("only test anchors for edit prompt");
+    }
+    const confidence = Math.max(0, Math.min(1, base.confidence +
+        Math.min(0.16, anchors.length * 0.03) +
+        (options.explicitTargetProvided && anchors.length > 0 ? 0.08 : 0) +
+        (options.dirtyAnchorAllowed && anchors.length > 0 ? 0.05 : 0) -
+        Math.min(0.3, discardedAnchorCount * 0.05) -
+        (missingAnchors.length - base.missingAnchors.length) * 0.18));
+    const editReady = base.mode === "edit" && missingAnchors.length === 0 && anchors.length > 0 && confidence >= 0.48;
+    const rawSearchBetter = missingAnchors.includes("broad prompt matched only weak lexical evidence") || missingAnchors.includes("only test anchors for edit prompt");
+    const verdict = editReady ? "edit-ready" : rawSearchBetter || confidence < 0.24 ? "raw-search-better" : base.mode === "orientation" && confidence >= 0.3 && anchors.length > 0 ? "orientation-only" : "needs-target";
+    return {
+        ...base,
+        confidence,
+        anchors,
+        selectedAnchorCount: anchors.length,
+        discardedAnchorCount,
+        missingAnchors: uniqueSorted(missingAnchors),
+        editReady,
+        verdict,
+        recommendedNextTool: verdict === "edit-ready" ? (base.mode === "edit" ? "task_brief" : "find_context") : verdict === "orientation-only" ? "find_context" : "search",
+        reasons: uniqueSorted([
+            ...base.reasons.filter((reason) => !/direct anchor/.test(reason)),
+            anchors.length > 0 ? `${anchors.length} selected packet anchor(s)` : "no selected packet anchors",
+            discardedAnchorCount > 0 ? `${discardedAnchorCount} discarded retrieval anchor(s) not shown in packet` : undefined
+        ].filter((entry) => Boolean(entry)))
+    };
+}
+function isStrongPacketAnchor(entry, dirtyAnchorAllowed) {
+    if (entry.provenance.some((item) => item.source === "explicit_target")) {
+        return true;
+    }
+    if (dirtyAnchorAllowed && entry.provenance.some((item) => item.source === "dirty_worktree")) {
+        return true;
+    }
+    return false;
+}
+function taskReferencesDirtyContext(task) {
+    return /\b(current|dirty|diff|worktree|working tree|changed|changes|unstaged|staged|this change|these changes)\b/iu.test(task);
+}
+function packetIntentDiagnostics(intent, baseDiagnostics) {
+    if (intent.editReady) {
+        return [];
+    }
+    const diagnostics = baseDiagnostics.filter((diagnostic) => !/needs explicit file|raw search likely|broad packet|only test anchors/iu.test(diagnostic));
+    if (intent.verdict === "needs-target") {
+        diagnostics.push("needs explicit file, symbol, or narrower search before edit planning");
+    }
+    if (intent.verdict === "raw-search-better") {
+        diagnostics.push("raw search likely gives a cleaner first pass than this broad packet");
+    }
+    for (const anchor of intent.missingAnchors) {
+        diagnostics.push(`missing ${anchor}`);
+    }
+    return uniqueSorted(diagnostics);
+}
+function actionabilityFromPacketVerdict(verdict) {
+    if (verdict === "edit-ready") {
+        return "edit_ready";
+    }
+    if (verdict === "orientation-only") {
+        return "orientation";
+    }
+    if (verdict === "raw-search-better") {
+        return "raw_search_better";
+    }
+    if (verdict === "needs-target") {
+        return "needs_target";
+    }
+    return "inspect_first";
+}
+function qualityLikeFallbackActionability(entries) {
+    if (entries.length === 0 || entries.every((entry) => entry.tier === "fallback")) {
+        return "needs_target";
+    }
+    return "inspect_first";
+}
+function uniqueFocusEntries(entries) {
+    const byPath = new Map();
+    for (const entry of entries.sort((a, b) => tierScore(a.tier) - tierScore(b.tier) || b.score - a.score || a.file.path.localeCompare(b.file.path))) {
+        if (!byPath.has(entry.file.path)) {
+            byPath.set(entry.file.path, entry);
+        }
+    }
+    return [...byPath.values()];
+}
+async function contextSnippets(repoRoot, index, focusPaths, changedSymbols, queryText, limit) {
+    const snippets = [];
+    const used = new Set();
+    const unreadableFiles = new Set();
+    const add = async (filePath, line, reason) => {
+        if (snippets.length >= Math.min(10, limit)) {
+            return;
+        }
+        const key = `${filePath}:${line}`;
+        if (used.has(key)) {
+            return;
+        }
+        used.add(key);
+        const snippet = await readSnippet(repoRoot, filePath, line, 3);
+        if ("unreadable" in snippet) {
+            if (!unreadableFiles.has(filePath)) {
+                unreadableFiles.add(filePath);
+                snippets.push(`- ${filePath}:${line} ${reason}\n  <snippet unavailable: ${snippet.unreadable}>`);
+            }
+            return;
+        }
+        if (snippet.text) {
+            snippets.push(`- ${filePath}:${line} ${reason}\n${snippet.text}`);
+        }
+    };
+    for (const entry of changedSymbols.slice(0, limit)) {
+        await add(entry.symbol.path, entry.symbol.range?.startLine ?? 1, `changed ${entry.symbol.qualifiedName}`);
+    }
+    const focusSet = new Set(focusPaths);
+    const hasQuery = Boolean(queryText.trim());
+    const symbols = index.symbols
+        .filter((symbol) => focusSet.has(symbol.path))
+        .sort((a, b) => {
+        const fileA = findFile(index, a.path)?.rank ?? 0;
+        const fileB = findFile(index, b.path)?.rank ?? 0;
+        return fileB - fileA || (a.range?.startLine ?? 0) - (b.range?.startLine ?? 0) || a.qualifiedName.localeCompare(b.qualifiedName);
+    });
+    if (hasQuery) {
+        const usages = index.usageSites
+            .map((usage) => ({
+            usage,
+            score: focusSet.has(usage.path) ? Math.max(matchScore(queryText, usage.name), matchScore(queryText, usage.text), matchScore(queryText, usage.path)) : 0
+        }))
+            .filter((entry) => entry.score > 0)
+            .sort((a, b) => b.score - a.score ||
+            Number(a.usage.kind === "import") - Number(b.usage.kind === "import") ||
+            a.usage.path.localeCompare(b.usage.path) ||
+            (a.usage.range?.startLine ?? 0) - (b.usage.range?.startLine ?? 0))
+            .slice(0, limit);
+        for (const { usage } of usages) {
+            await add(usage.path, usage.range?.startLine ?? 1, `usage ${usage.name} ${usage.confidence}`);
+        }
+    }
+    const symbolCandidates = hasQuery
+        ? symbols.filter((symbol) => Math.max(matchScore(queryText, symbol.name), matchScore(queryText, symbol.qualifiedName), matchScore(queryText, symbol.path)) > 0)
+        : symbols;
+    for (const symbol of symbolCandidates.slice(0, limit)) {
+        await add(symbol.path, symbol.range?.startLine ?? 1, `${symbol.kind} ${symbol.qualifiedName}`);
+    }
+    return snippets;
+}
+async function sessionMemoryPreview(input) {
+    try {
+        const result = await summarizeSessionMemory({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+            files: input.files,
+            symbols: input.symbols,
+            topics: input.topics,
+            freshness: input.freshness,
+            limit: input.limit,
+            includeStale: true
+        });
+        if (result.memory.entries.length === 0) {
+            return { lines: [] };
+        }
+        return {
+            lines: (result.memory.markdown ?? "").split(/\r?\n/u).slice(0, 12),
+            data: {
+                sessionId: result.sessionId,
+                revision: result.revision,
+                entries: result.memory.entries.slice(0, input.limit),
+                warnings: result.warnings
+            }
+        };
+    }
+    catch (error) {
+        return {
+            lines: [`- unavailable: ${error instanceof Error ? error.message : String(error)}`],
+            data: { warning: error instanceof Error ? error.message : String(error) }
+        };
+    }
+}
+async function readSnippet(repoRoot, filePath, centerLine, radius) {
+    try {
+        const source = await fs.readFile(path.join(repoRoot, filePath), "utf8");
+        const lines = source.split(/\r?\n/);
+        const start = Math.max(1, centerLine - radius);
+        const end = Math.min(lines.length, centerLine + radius);
+        const text = lines
+            .slice(start - 1, end)
+            .map((line, index) => `  ${String(start + index).padStart(4, " ")} | ${line.slice(0, 180)}`)
+            .join("\n");
+        return { text };
+    }
+    catch (error) {
+        const code = error?.code;
+        return { unreadable: typeof code === "string" ? code : "ERR" };
+    }
+}
+//# sourceMappingURL=context.js.map