scai 0.1.178 → 1.0.1

package/dist/agent/policy/coveragePolicy.js

@@ -0,0 +1,309 @@
+import { resolveResolutionState } from "./resolutionPipeline.js";
+import { hasFreshReadForPath } from "../read/index.js";
+import { extractQuotedFragments } from "../search/searchContext.js";
+const FEW_CANDIDATE_THRESHOLD = 3;
+const DEFAULT_TRIAGE_BUDGET = 2;
+const DOMINANT_TRIAGE_SCORE = 0.72;
+const DOMINANT_TRIAGE_LEAD = 0.18;
+const CONTINUE_FULL_READ_MIN_TRIAGE_SCORE = 0.45;
+function getSearchScore(memory, filePath) {
+    return memory.evidence.candidateMetadata?.[filePath]?.searchScore ?? 0;
+}
+function getTriageScore(memory, filePath) {
+    return memory.evidence.candidateMetadata?.[filePath]?.triageScore ?? 0;
+}
+function getCandidatePriority(memory, filePath) {
+    const hardBoost = memory.task.hardFileTargets.includes(filePath) ? 1000 : 0;
+    const fullReadBoost = hasReadMode(memory, filePath, "full") ? 100 : 0;
+    return hardBoost + getSearchScore(memory, filePath) + getTriageScore(memory, filePath) + fullReadBoost;
+}
+function hasReadMode(memory, filePath, mode) {
+    return hasFreshReadForPath(memory, filePath, { mode });
+}
+function isTriagedOnly(memory, filePath) {
+    return hasReadMode(memory, filePath, "triage") && !hasReadMode(memory, filePath, "full");
+}
+function isUnreadForTriage(memory, filePath) {
+    return !hasReadMode(memory, filePath, "triage") && !hasReadMode(memory, filePath, "full");
+}
+function isUnreadForFullRead(memory, filePath) {
+    return !hasReadMode(memory, filePath, "full");
+}
+function orderCandidates(memory, filePaths) {
+    return [...filePaths].sort((left, right) => {
+        const priorityDelta = getCandidatePriority(memory, right) - getCandidatePriority(memory, left);
+        if (priorityDelta !== 0) {
+            return priorityDelta;
+        }
+        return memory.evidence.candidateFiles.indexOf(left) - memory.evidence.candidateFiles.indexOf(right);
+    });
+}
+function broadCandidatesNeedTriage(broadCandidates) {
+    return broadCandidates.length > FEW_CANDIDATE_THRESHOLD;
+}
+function hasDominantTriagedCandidate(memory, triagedCandidateTargets) {
+    if (triagedCandidateTargets.length === 0) {
+        return false;
+    }
+    const ordered = orderCandidates(memory, triagedCandidateTargets);
+    const topScore = getTriageScore(memory, ordered[0]);
+    const nextScore = ordered.length > 1 ? getTriageScore(memory, ordered[1]) : 0;
+    return topScore >= DOMINANT_TRIAGE_SCORE && topScore - nextScore >= DOMINANT_TRIAGE_LEAD;
+}
+function shouldAllowBroadFullRead(memory, triagedCandidateTargets, fullReadCandidateTargets, eligibleFullReadTargets) {
+    if (eligibleFullReadTargets.length === 0) {
+        return false;
+    }
+    if (fullReadCandidateTargets.length > 0) {
+        return getTriageScore(memory, eligibleFullReadTargets[0]) >= CONTINUE_FULL_READ_MIN_TRIAGE_SCORE;
+    }
+    if (triagedCandidateTargets.length >= DEFAULT_TRIAGE_BUDGET) {
+        return true;
+    }
+    return hasDominantTriagedCandidate(memory, triagedCandidateTargets);
+}
+function resolveRequiredGroundedCoverage(memory, args) {
+    const latestExactTargetSearch = [...memory.evidence.searches]
+        .reverse()
+        .find((search) => search.action === "search-db" && search.lane === "exact-target" && search.filePaths.length > 1);
+    if (latestExactTargetSearch) {
+        return Math.min(latestExactTargetSearch.filePaths.length, 3);
+    }
+    const explicitTargetCount = new Set([
+        ...args.hardFileTargets,
+        ...args.requiredFolderTargets,
+        ...args.unresolvedHardFileTargets,
+    ]).size;
+    if (explicitTargetCount > 1) {
+        return explicitTargetCount;
+    }
+    const quotedFragments = extractQuotedFragments(memory.task.initialQuery);
+    if (quotedFragments.length > 0) {
+        return memory.evidence.candidateFiles.length >= 2 ? 2 : 1;
+    }
+    const normalizedQuery = memory.task.normalizedQuery.toLowerCase();
+    if (memory.task.queryScope === "broad-repo") {
+        if (/\b(entrypoints?|tests?|test runner|architecture|flow|configured|configuration)\b/.test(normalizedQuery)) {
+            return 3;
+        }
+        return 2;
+    }
+    if (/\b(compare|between|versus|vs)\b/.test(normalizedQuery) ||
+        /\bfrom\b.+\band\b/.test(normalizedQuery) ||
+        /\bentrypoints?\b/.test(normalizedQuery) ||
+        /\barchitecture\b/.test(normalizedQuery) ||
+        /\bdivide\b/.test(normalizedQuery) ||
+        /\bresponsibilit(?:y|ies)\b/.test(normalizedQuery)) {
+        return 2;
+    }
+    return 1;
+}
+function resolveRequiredFullReadCoverage(memory, args) {
+    const latestExactTargetSearch = [...memory.evidence.searches]
+        .reverse()
+        .find((search) => search.action === "search-db" && search.lane === "exact-target" && search.filePaths.length > 1);
+    if (latestExactTargetSearch) {
+        return Math.min(latestExactTargetSearch.filePaths.length, 3);
+    }
+    const explicitTargetCount = new Set([
+        ...args.hardFileTargets,
+        ...args.requiredFolderTargets,
+    ]).size;
+    if (explicitTargetCount > 1) {
+        return explicitTargetCount;
+    }
+    if (extractQuotedFragments(memory.task.initialQuery).length > 0) {
+        return memory.evidence.candidateFiles.length >= 2 ? 2 : 1;
+    }
+    if (memory.task.queryScope === "broad-repo") {
+        const normalizedQuery = memory.task.normalizedQuery.toLowerCase();
+        if (/\b(entrypoints?|tests?|test runner|architecture|flow|configured|configuration)\b/.test(normalizedQuery)) {
+            return 2;
+        }
+    }
+    return 1;
+}
+function listGroundedReadFiles(memory) {
+    return Object.values(memory.evidence.fileReads).map((read) => read.filePath);
+}
+function resolveRequiredFolderTargets(memory, folderTargets) {
+    return uniqueFilePaths(folderTargets.flatMap((folder) => {
+        const ordered = orderCandidates(memory, folder.candidates);
+        if (ordered.length <= FEW_CANDIDATE_THRESHOLD) {
+            return ordered;
+        }
+        return ordered.slice(0, FEW_CANDIDATE_THRESHOLD);
+    }));
+}
+function uniqueFilePaths(values) {
+    return Array.from(new Set(values));
+}
+function resolveEvidenceCoverage(memory, args) {
+    const groundedFiles = listGroundedReadFiles(memory);
+    if (args.hasStructuredTargetRequirement) {
+        if (args.hasAmbiguousHardFileRequirement) {
+            return {
+                kind: "needs-search",
+                reason: "Need the user to choose one exact target before more grounded reads.",
+            };
+        }
+        if (args.hasUnresolvedHardFileRequirement) {
+            return {
+                kind: "needs-search",
+                reason: "Need search to resolve the remaining explicit target inside the repo.",
+            };
+        }
+        if (args.unreadHardFileTargets.length > 0) {
+            return {
+                kind: "needs-read",
+                nextTargets: args.unreadHardFileTargets,
+                reason: args.folderTargets.length > 0
+                    ? "Need grounded reads for the remaining explicit file or folder targets."
+                    : "Need grounded reads for the remaining explicit file targets.",
+            };
+        }
+        return {
+            kind: "enough",
+            groundedFiles,
+            reason: args.folderTargets.length > 0
+                ? "All explicit file and folder targets have grounded reads."
+                : "All explicit file targets have grounded reads.",
+        };
+    }
+    if (args.needsBroadTriage) {
+        if (args.hasGroundedCandidateRead) {
+            return {
+                kind: "enough",
+                groundedFiles,
+                reason: "The ranked candidate set has enough grounded coverage for one answer attempt.",
+            };
+        }
+        return {
+            kind: "needs-read",
+            nextTargets: [],
+            reason: "Need another triage or full read from the ranked candidate set before answering.",
+        };
+    }
+    if (args.hasGroundedCandidateRead) {
+        return {
+            kind: "enough",
+            groundedFiles,
+            reason: "The gathered grounded reads are enough for one answer attempt.",
+        };
+    }
+    if (args.hasAnyCandidateRead || args.hasAnyCandidateFrontier) {
+        return {
+            kind: "needs-read",
+            nextTargets: [],
+            reason: "Need another ranked candidate read before answering.",
+        };
+    }
+    return {
+        kind: "needs-search",
+        reason: "Need another small search or read step before answering.",
+    };
+}
+export function resolveReadCoverageState(memory) {
+    const resolution = resolveResolutionState(memory);
+    const requiredFolderTargets = resolveRequiredFolderTargets(memory, resolution.folderTargets);
+    const hardReads = new Set([...resolution.hardFileTargets, ...requiredFolderTargets]);
+    const broadCandidates = memory.evidence.candidateFiles.filter((filePath) => !hardReads.has(filePath));
+    const orderedBroadCandidates = orderCandidates(memory, broadCandidates);
+    const needsBroadTriage = broadCandidatesNeedTriage(broadCandidates);
+    const triagedCandidateTargets = orderedBroadCandidates.filter((filePath) => isTriagedOnly(memory, filePath));
+    const fullReadCandidateTargets = orderedBroadCandidates.filter((filePath) => hasReadMode(memory, filePath, "full"));
+    const unreadHardFileTargets = uniqueFilePaths([
+        ...resolution.hardFileTargets.filter((filePath) => isUnreadForFullRead(memory, filePath)),
+        ...requiredFolderTargets.filter((filePath) => isUnreadForFullRead(memory, filePath)),
+    ]);
+    const eligibleBroadFullReadTargets = needsBroadTriage
+        ? orderCandidates(memory, orderedBroadCandidates.filter((filePath) => isTriagedOnly(memory, filePath)))
+        : [];
+    const broadFullReadReady = needsBroadTriage &&
+        shouldAllowBroadFullRead(memory, triagedCandidateTargets, fullReadCandidateTargets, eligibleBroadFullReadTargets);
+    const unreadTriageTargets = needsBroadTriage && !broadFullReadReady
+        ? orderedBroadCandidates.filter((filePath) => isUnreadForTriage(memory, filePath))
+        : [];
+    const unreadBroadFullReadTargets = needsBroadTriage
+        ? (broadFullReadReady ? eligibleBroadFullReadTargets : [])
+        : orderedBroadCandidates.filter((filePath) => isUnreadForFullRead(memory, filePath));
+    const groundedCandidateReads = countGroundedCandidateReads(memory);
+    const groundedCoverageCount = groundedCandidateReads.full > 0
+        ? groundedCandidateReads.full + groundedCandidateReads.supportingTriage
+        : groundedCandidateReads.full;
+    const requiredGroundedCoverage = resolveRequiredGroundedCoverage(memory, {
+        hardFileTargets: resolution.hardFileTargets,
+        requiredFolderTargets,
+        unresolvedHardFileTargets: resolution.unresolvedHardFileTargets,
+    });
+    const requiredFullReadCoverage = resolveRequiredFullReadCoverage(memory, {
+        hardFileTargets: resolution.hardFileTargets,
+        requiredFolderTargets,
+    });
+    const hasGroundedCandidateRead = groundedCoverageCount >= requiredGroundedCoverage &&
+        groundedCandidateReads.full >= requiredFullReadCoverage;
+    const hasAnyCandidateRead = triagedCandidateTargets.length > 0 || fullReadCandidateTargets.length > 0;
+    const hasStructuredTargetRequirement = resolution.hardFileTargets.length > 0 ||
+        requiredFolderTargets.length > 0 ||
+        resolution.unresolvedHardFileTargets.length > 0 ||
+        resolution.ambiguousTargets.length > 0;
+    const evidenceCoverage = resolveEvidenceCoverage(memory, {
+        hasStructuredTargetRequirement,
+        hasUnresolvedHardFileRequirement: resolution.unresolvedHardFileTargets.length > 0,
+        hasAmbiguousHardFileRequirement: resolution.ambiguousTargets.length > 0,
+        unreadHardFileTargets,
+        hasGroundedCandidateRead,
+        hasAnyCandidateRead,
+        hasAnyCandidateFrontier: memory.evidence.candidateFiles.length > 0,
+        needsBroadTriage,
+        folderTargets: resolution.folderTargets,
+    });
+    return {
+        targetResolutions: resolution.targetResolutions,
+        hardFileTargets: resolution.hardFileTargets,
+        folderTargets: resolution.folderTargets,
+        requiredFolderTargets,
+        unresolvedHardFileTargets: resolution.unresolvedHardFileTargets,
+        ambiguousTargets: resolution.ambiguousTargets,
+        unreadHardFileTargets,
+        unreadTriageTargets,
+        unreadFullReadTargets: [...unreadHardFileTargets, ...unreadBroadFullReadTargets.filter((filePath) => !unreadHardFileTargets.includes(filePath))],
+        triagedCandidateTargets,
+        fullReadCandidateTargets,
+        softHints: resolution.softHints,
+        hasHardFileRequirement: resolution.hardFileTargets.length > 0 ||
+            requiredFolderTargets.length > 0 ||
+            resolution.unresolvedHardFileTargets.length > 0 ||
+            resolution.ambiguousTargets.length > 0,
+        hasStructuredTargetRequirement,
+        hasUnresolvedHardFileRequirement: resolution.unresolvedHardFileTargets.length > 0,
+        hasAmbiguousHardFileRequirement: resolution.ambiguousTargets.length > 0,
+        needsBroadTriage,
+        requiredGroundedCoverage,
+        requiredFullReadCoverage,
+        evidenceCoverage,
+    };
+}
+/**
+ * Counts broad-candidate grounding in a way that matches the triage workflow.
+ * Example: 1 full read + 1 separate triage-only read => { full: 1, supportingTriage: 1 }.
+ */
+export function countGroundedCandidateReads(memory) {
+    let full = 0;
+    let supportingTriage = 0;
+    for (const read of Object.values(memory.evidence.fileReads)) {
+        const mode = read.readMode ?? "full";
+        if (mode === "full") {
+            full += 1;
+            continue;
+        }
+        if (mode === "triage") {
+            supportingTriage += 1;
+        }
+    }
+    return {
+        full,
+        supportingTriage,
+    };
+}
+//# sourceMappingURL=coveragePolicy.js.map

package/dist/agent/policy/coveragePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coveragePolicy.js","sourceRoot":"","sources":["../../../src/agent/policy/coveragePolicy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Derives evidence coverage and candidate progression for the modular agent runtime.\n *\n * Why this file exists:\n * - the resolver should tell us what the targets mean before coverage runs\n * - broad candidate sets need explicit triage before full reads without hiding later candidates\n * - answer readiness should come from one explicit owner instead of loose booleans\n */\nimport type { AgentMemory, AgentTargetResolution } from \"../types.js\";\nimport type { EvidenceCoverage } from \"./contracts.js\";\nimport { resolveResolutionState } from \"./resolutionPipeline.js\";\nimport { hasFreshReadForPath } from \"../read/index.js\";\nimport { extractQuotedFragments } from \"../search/searchContext.js\";\n\nconst FEW_CANDIDATE_THRESHOLD = 3;\nconst DEFAULT_TRIAGE_BUDGET = 2;\nconst DOMINANT_TRIAGE_SCORE = 0.72;\nconst DOMINANT_TRIAGE_LEAD = 0.18;\nconst CONTINUE_FULL_READ_MIN_TRIAGE_SCORE = 0.45;\n\ntype ReadMode = \"triage\" | \"full\";\n\nfunction getSearchScore(memory: AgentMemory, filePath: string): number {\n  return memory.evidence.candidateMetadata?.[filePath]?.searchScore ?? 0;\n}\n\nfunction getTriageScore(memory: AgentMemory, filePath: string): number {\n  return memory.evidence.candidateMetadata?.[filePath]?.triageScore ?? 0;\n}\n\nfunction getCandidatePriority(memory: AgentMemory, filePath: string): number {\n  const hardBoost = memory.task.hardFileTargets.includes(filePath) ? 1000 : 0;\n  const fullReadBoost = hasReadMode(memory, filePath, \"full\") ? 100 : 0;\n  return hardBoost + getSearchScore(memory, filePath) + getTriageScore(memory, filePath) + fullReadBoost;\n}\n\nfunction hasReadMode(memory: AgentMemory, filePath: string, mode: ReadMode): boolean {\n  return hasFreshReadForPath(memory, filePath, { mode });\n}\n\nfunction isTriagedOnly(memory: AgentMemory, filePath: string): boolean {\n  return hasReadMode(memory, filePath, \"triage\") && !hasReadMode(memory, filePath, \"full\");\n}\n\nfunction isUnreadForTriage(memory: AgentMemory, filePath: string): boolean {\n  return !hasReadMode(memory, filePath, \"triage\") && !hasReadMode(memory, filePath, \"full\");\n}\n\nfunction isUnreadForFullRead(memory: AgentMemory, filePath: string): boolean {\n  return !hasReadMode(memory, filePath, \"full\");\n}\n\nfunction orderCandidates(memory: AgentMemory, filePaths: string[]): string[] {\n  return [...filePaths].sort((left, right) => {\n    const priorityDelta = getCandidatePriority(memory, right) - getCandidatePriority(memory, left);\n    if (priorityDelta !== 0) {\n      return priorityDelta;\n    }\n    return memory.evidence.candidateFiles.indexOf(left) - memory.evidence.candidateFiles.indexOf(right);\n  });\n}\n\nfunction broadCandidatesNeedTriage(broadCandidates: string[]): boolean {\n  return broadCandidates.length > FEW_CANDIDATE_THRESHOLD;\n}\n\nfunction hasDominantTriagedCandidate(memory: AgentMemory, triagedCandidateTargets: string[]): boolean {\n  if (triagedCandidateTargets.length === 0) {\n    return false;\n  }\n  const ordered = orderCandidates(memory, triagedCandidateTargets);\n  const topScore = getTriageScore(memory, ordered[0]);\n  const nextScore = ordered.length > 1 ? getTriageScore(memory, ordered[1]) : 0;\n  return topScore >= DOMINANT_TRIAGE_SCORE && topScore - nextScore >= DOMINANT_TRIAGE_LEAD;\n}\n\nfunction shouldAllowBroadFullRead(\n  memory: AgentMemory,\n  triagedCandidateTargets: string[],\n  fullReadCandidateTargets: string[],\n  eligibleFullReadTargets: string[]\n): boolean {\n  if (eligibleFullReadTargets.length === 0) {\n    return false;\n  }\n  if (fullReadCandidateTargets.length > 0) {\n    return getTriageScore(memory, eligibleFullReadTargets[0]) >= CONTINUE_FULL_READ_MIN_TRIAGE_SCORE;\n  }\n  if (triagedCandidateTargets.length >= DEFAULT_TRIAGE_BUDGET) {\n    return true;\n  }\n  return hasDominantTriagedCandidate(memory, triagedCandidateTargets);\n}\n\nfunction resolveRequiredGroundedCoverage(\n  memory: AgentMemory,\n  args: {\n    hardFileTargets: string[];\n    requiredFolderTargets: string[];\n    unresolvedHardFileTargets: string[];\n  }\n): number {\n  const latestExactTargetSearch = [...memory.evidence.searches]\n    .reverse()\n    .find((search) => search.action === \"search-db\" && search.lane === \"exact-target\" && search.filePaths.length > 1);\n  if (latestExactTargetSearch) {\n    return Math.min(latestExactTargetSearch.filePaths.length, 3);\n  }\n\n  const explicitTargetCount = new Set([\n    ...args.hardFileTargets,\n    ...args.requiredFolderTargets,\n    ...args.unresolvedHardFileTargets,\n  ]).size;\n  if (explicitTargetCount > 1) {\n    return explicitTargetCount;\n  }\n\n  const quotedFragments = extractQuotedFragments(memory.task.initialQuery);\n  if (quotedFragments.length > 0) {\n    return memory.evidence.candidateFiles.length >= 2 ? 2 : 1;\n  }\n\n  const normalizedQuery = memory.task.normalizedQuery.toLowerCase();\n  if (memory.task.queryScope === \"broad-repo\") {\n    if (/\\b(entrypoints?|tests?|test runner|architecture|flow|configured|configuration)\\b/.test(normalizedQuery)) {\n      return 3;\n    }\n    return 2;\n  }\n  if (\n    /\\b(compare|between|versus|vs)\\b/.test(normalizedQuery) ||\n    /\\bfrom\\b.+\\band\\b/.test(normalizedQuery) ||\n    /\\bentrypoints?\\b/.test(normalizedQuery) ||\n    /\\barchitecture\\b/.test(normalizedQuery) ||\n    /\\bdivide\\b/.test(normalizedQuery) ||\n    /\\bresponsibilit(?:y|ies)\\b/.test(normalizedQuery)\n  ) {\n    return 2;\n  }\n\n  return 1;\n}\n\nfunction resolveRequiredFullReadCoverage(\n  memory: AgentMemory,\n  args: {\n    hardFileTargets: string[];\n    requiredFolderTargets: string[];\n  }\n): number {\n  const latestExactTargetSearch = [...memory.evidence.searches]\n    .reverse()\n    .find((search) => search.action === \"search-db\" && search.lane === \"exact-target\" && search.filePaths.length > 1);\n  if (latestExactTargetSearch) {\n    return Math.min(latestExactTargetSearch.filePaths.length, 3);\n  }\n\n  const explicitTargetCount = new Set([\n    ...args.hardFileTargets,\n    ...args.requiredFolderTargets,\n  ]).size;\n  if (explicitTargetCount > 1) {\n    return explicitTargetCount;\n  }\n\n  if (extractQuotedFragments(memory.task.initialQuery).length > 0) {\n    return memory.evidence.candidateFiles.length >= 2 ? 2 : 1;\n  }\n\n  if (memory.task.queryScope === \"broad-repo\") {\n    const normalizedQuery = memory.task.normalizedQuery.toLowerCase();\n    if (/\\b(entrypoints?|tests?|test runner|architecture|flow|configured|configuration)\\b/.test(normalizedQuery)) {\n      return 2;\n    }\n  }\n\n  return 1;\n}\n\nexport type ReadCoverageState = {\n  targetResolutions: ReturnType<typeof resolveResolutionState>[\"targetResolutions\"];\n  hardFileTargets: string[];\n  folderTargets: ReturnType<typeof resolveResolutionState>[\"folderTargets\"];\n  requiredFolderTargets: string[];\n  unresolvedHardFileTargets: string[];\n  ambiguousTargets: AgentTargetResolution[];\n  unreadHardFileTargets: string[];\n  unreadTriageTargets: string[];\n  unreadFullReadTargets: string[];\n  triagedCandidateTargets: string[];\n  fullReadCandidateTargets: string[];\n  softHints: string[];\n  hasHardFileRequirement: boolean;\n  hasStructuredTargetRequirement: boolean;\n  hasUnresolvedHardFileRequirement: boolean;\n  hasAmbiguousHardFileRequirement: boolean;\n  needsBroadTriage: boolean;\n  requiredGroundedCoverage: number;\n  requiredFullReadCoverage: number;\n  evidenceCoverage: EvidenceCoverage;\n};\n\ntype GroundedCandidateReadCounts = {\n  full: number;\n  supportingTriage: number;\n};\n\nfunction listGroundedReadFiles(memory: AgentMemory): string[] {\n  return Object.values(memory.evidence.fileReads).map((read) => read.filePath);\n}\n\nfunction resolveRequiredFolderTargets(memory: AgentMemory, folderTargets: ReturnType<typeof resolveResolutionState>[\"folderTargets\"]): string[] {\n  return uniqueFilePaths(folderTargets.flatMap((folder) => {\n    const ordered = orderCandidates(memory, folder.candidates);\n    if (ordered.length <= FEW_CANDIDATE_THRESHOLD) {\n      return ordered;\n    }\n    return ordered.slice(0, FEW_CANDIDATE_THRESHOLD);\n  }));\n}\n\nfunction uniqueFilePaths(values: string[]): string[] {\n  return Array.from(new Set(values));\n}\n\nfunction resolveEvidenceCoverage(\n  memory: AgentMemory,\n  args: {\n    hasStructuredTargetRequirement: boolean;\n    hasUnresolvedHardFileRequirement: boolean;\n    hasAmbiguousHardFileRequirement: boolean;\n    unreadHardFileTargets: string[];\n    hasGroundedCandidateRead: boolean;\n    hasAnyCandidateRead: boolean;\n    hasAnyCandidateFrontier: boolean;\n    needsBroadTriage: boolean;\n    folderTargets: ReturnType<typeof resolveResolutionState>[\"folderTargets\"];\n  }\n): EvidenceCoverage {\n  const groundedFiles = listGroundedReadFiles(memory);\n\n  if (args.hasStructuredTargetRequirement) {\n    if (args.hasAmbiguousHardFileRequirement) {\n      return {\n        kind: \"needs-search\",\n        reason: \"Need the user to choose one exact target before more grounded reads.\",\n      };\n    }\n    if (args.hasUnresolvedHardFileRequirement) {\n      return {\n        kind: \"needs-search\",\n        reason: \"Need search to resolve the remaining explicit target inside the repo.\",\n      };\n    }\n    if (args.unreadHardFileTargets.length > 0) {\n      return {\n        kind: \"needs-read\",\n        nextTargets: args.unreadHardFileTargets,\n        reason: args.folderTargets.length > 0\n          ? \"Need grounded reads for the remaining explicit file or folder targets.\"\n          : \"Need grounded reads for the remaining explicit file targets.\",\n      };\n    }\n    return {\n      kind: \"enough\",\n      groundedFiles,\n      reason: args.folderTargets.length > 0\n        ? \"All explicit file and folder targets have grounded reads.\"\n        : \"All explicit file targets have grounded reads.\",\n    };\n  }\n\n  if (args.needsBroadTriage) {\n    if (args.hasGroundedCandidateRead) {\n      return {\n        kind: \"enough\",\n        groundedFiles,\n        reason: \"The ranked candidate set has enough grounded coverage for one answer attempt.\",\n      };\n    }\n    return {\n      kind: \"needs-read\",\n      nextTargets: [],\n      reason: \"Need another triage or full read from the ranked candidate set before answering.\",\n    };\n  }\n\n  if (args.hasGroundedCandidateRead) {\n    return {\n      kind: \"enough\",\n      groundedFiles,\n      reason: \"The gathered grounded reads are enough for one answer attempt.\",\n    };\n  }\n\n  if (args.hasAnyCandidateRead || args.hasAnyCandidateFrontier) {\n    return {\n      kind: \"needs-read\",\n      nextTargets: [],\n      reason: \"Need another ranked candidate read before answering.\",\n    };\n  }\n\n  return {\n    kind: \"needs-search\",\n    reason: \"Need another small search or read step before answering.\",\n  };\n}\n\nexport function resolveReadCoverageState(memory: AgentMemory): ReadCoverageState {\n  const resolution = resolveResolutionState(memory);\n  const requiredFolderTargets = resolveRequiredFolderTargets(memory, resolution.folderTargets);\n  const hardReads = new Set([...resolution.hardFileTargets, ...requiredFolderTargets]);\n  const broadCandidates = memory.evidence.candidateFiles.filter((filePath) => !hardReads.has(filePath));\n  const orderedBroadCandidates = orderCandidates(memory, broadCandidates);\n  const needsBroadTriage = broadCandidatesNeedTriage(broadCandidates);\n  const triagedCandidateTargets = orderedBroadCandidates.filter((filePath) => isTriagedOnly(memory, filePath));\n  const fullReadCandidateTargets = orderedBroadCandidates.filter((filePath) => hasReadMode(memory, filePath, \"full\"));\n  const unreadHardFileTargets = uniqueFilePaths([\n    ...resolution.hardFileTargets.filter((filePath) => isUnreadForFullRead(memory, filePath)),\n    ...requiredFolderTargets.filter((filePath) => isUnreadForFullRead(memory, filePath)),\n  ]);\n  const eligibleBroadFullReadTargets = needsBroadTriage\n    ? orderCandidates(memory, orderedBroadCandidates.filter((filePath) => isTriagedOnly(memory, filePath)))\n    : [];\n  const broadFullReadReady = needsBroadTriage &&\n    shouldAllowBroadFullRead(memory, triagedCandidateTargets, fullReadCandidateTargets, eligibleBroadFullReadTargets);\n  const unreadTriageTargets = needsBroadTriage && !broadFullReadReady\n    ? orderedBroadCandidates.filter((filePath) => isUnreadForTriage(memory, filePath))\n    : [];\n  const unreadBroadFullReadTargets = needsBroadTriage\n    ? (broadFullReadReady ? eligibleBroadFullReadTargets : [])\n    : orderedBroadCandidates.filter((filePath) => isUnreadForFullRead(memory, filePath));\n  const groundedCandidateReads = countGroundedCandidateReads(memory);\n  const groundedCoverageCount = groundedCandidateReads.full > 0\n    ? groundedCandidateReads.full + groundedCandidateReads.supportingTriage\n    : groundedCandidateReads.full;\n  const requiredGroundedCoverage = resolveRequiredGroundedCoverage(memory, {\n    hardFileTargets: resolution.hardFileTargets,\n    requiredFolderTargets,\n    unresolvedHardFileTargets: resolution.unresolvedHardFileTargets,\n  });\n  const requiredFullReadCoverage = resolveRequiredFullReadCoverage(memory, {\n    hardFileTargets: resolution.hardFileTargets,\n    requiredFolderTargets,\n  });\n  const hasGroundedCandidateRead = groundedCoverageCount >= requiredGroundedCoverage &&\n    groundedCandidateReads.full >= requiredFullReadCoverage;\n  const hasAnyCandidateRead = triagedCandidateTargets.length > 0 || fullReadCandidateTargets.length > 0;\n  const hasStructuredTargetRequirement = resolution.hardFileTargets.length > 0 ||\n    requiredFolderTargets.length > 0 ||\n    resolution.unresolvedHardFileTargets.length > 0 ||\n    resolution.ambiguousTargets.length > 0;\n  const evidenceCoverage = resolveEvidenceCoverage(memory, {\n    hasStructuredTargetRequirement,\n    hasUnresolvedHardFileRequirement: resolution.unresolvedHardFileTargets.length > 0,\n    hasAmbiguousHardFileRequirement: resolution.ambiguousTargets.length > 0,\n    unreadHardFileTargets,\n    hasGroundedCandidateRead,\n    hasAnyCandidateRead,\n    hasAnyCandidateFrontier: memory.evidence.candidateFiles.length > 0,\n    needsBroadTriage,\n    folderTargets: resolution.folderTargets,\n  });\n\n  return {\n    targetResolutions: resolution.targetResolutions,\n    hardFileTargets: resolution.hardFileTargets,\n    folderTargets: resolution.folderTargets,\n    requiredFolderTargets,\n    unresolvedHardFileTargets: resolution.unresolvedHardFileTargets,\n    ambiguousTargets: resolution.ambiguousTargets,\n    unreadHardFileTargets,\n    unreadTriageTargets,\n    unreadFullReadTargets: [...unreadHardFileTargets, ...unreadBroadFullReadTargets.filter((filePath) => !unreadHardFileTargets.includes(filePath))],\n    triagedCandidateTargets,\n    fullReadCandidateTargets,\n    softHints: resolution.softHints,\n    hasHardFileRequirement: resolution.hardFileTargets.length > 0 ||\n      requiredFolderTargets.length > 0 ||\n      resolution.unresolvedHardFileTargets.length > 0 ||\n      resolution.ambiguousTargets.length > 0,\n    hasStructuredTargetRequirement,\n    hasUnresolvedHardFileRequirement: resolution.unresolvedHardFileTargets.length > 0,\n    hasAmbiguousHardFileRequirement: resolution.ambiguousTargets.length > 0,\n    needsBroadTriage,\n    requiredGroundedCoverage,\n    requiredFullReadCoverage,\n    evidenceCoverage,\n  };\n}\n\n/**\n * Counts broad-candidate grounding in a way that matches the triage workflow.\n * Example: 1 full read + 1 separate triage-only read => { full: 1, supportingTriage: 1 }.\n */\nexport function countGroundedCandidateReads(memory: AgentMemory): GroundedCandidateReadCounts {\n  let full = 0;\n  let supportingTriage = 0;\n\n  for (const read of Object.values(memory.evidence.fileReads)) {\n    const mode = read.readMode ?? \"full\";\n    if (mode === \"full\") {\n      full += 1;\n      continue;\n    }\n    if (mode === \"triage\") {\n      supportingTriage += 1;\n    }\n  }\n\n  return {\n    full,\n    supportingTriage,\n  };\n}\n"]}

package/dist/agent/policy/endDecisionPolicy.js

@@ -0,0 +1,31 @@
+/**
+ * Converts a policy decision into one forced terminal runtime action.
+ */
+export function resolveEndDecision(decision) {
+    if (decision.stop === "final-answer") {
+        return {
+            action: "final-answer",
+            taskStatus: "done",
+            stopReason: "completed",
+            purpose: "Summarize the gathered grounded evidence for the user.",
+            expectedEvidence: ["final answer"],
+        };
+    }
+    if (decision.stop === "request-user-input") {
+        return {
+            action: "request-user-input",
+            taskStatus: "waiting",
+            stopReason: "need-user-input",
+            purpose: "Ask the user for one concrete missing input before continuing.",
+            expectedEvidence: ["user follow-up request"],
+        };
+    }
+    return {
+        action: "cannot-answer",
+        taskStatus: "blocked",
+        stopReason: "max-turns",
+        purpose: "Report honestly that the request could not be answered from grounded repo evidence.",
+        expectedEvidence: ["failure summary"],
+    };
+}
+//# sourceMappingURL=endDecisionPolicy.js.map

package/dist/agent/policy/endDecisionPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endDecisionPolicy.js","sourceRoot":"","sources":["../../../src/agent/policy/endDecisionPolicy.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAAwB;IACzD,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;QACrC,OAAO;YACL,MAAM,EAAE,cAAuB;YAC/B,UAAU,EAAE,MAAe;YAC3B,UAAU,EAAE,WAAW;YACvB,OAAO,EAAE,wDAAwD;YACjE,gBAAgB,EAAE,CAAC,cAAc,CAAC;SACnC,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,CAAC,IAAI,KAAK,oBAAoB,EAAE,CAAC;QAC3C,OAAO;YACL,MAAM,EAAE,oBAA6B;YACrC,UAAU,EAAE,SAAkB;YAC9B,UAAU,EAAE,iBAAiB;YAC7B,OAAO,EAAE,gEAAgE;YACzE,gBAAgB,EAAE,CAAC,wBAAwB,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED,OAAO;QACL,MAAM,EAAE,eAAwB;QAChC,UAAU,EAAE,SAAkB;QAC9B,UAAU,EAAE,WAAW;QACvB,OAAO,EAAE,qFAAqF;QAC9F,gBAAgB,EAAE,CAAC,iBAAiB,CAAC;KACtC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Owns forced end decisions for the modular agent runtime.\n */\nimport type { PolicyDecision } from \"./contracts.js\";\n\n/**\n * Converts a policy decision into one forced terminal runtime action.\n */\nexport function resolveEndDecision(decision: PolicyDecision) {\n  if (decision.stop === \"final-answer\") {\n    return {\n      action: \"final-answer\" as const,\n      taskStatus: \"done\" as const,\n      stopReason: \"completed\",\n      purpose: \"Summarize the gathered grounded evidence for the user.\",\n      expectedEvidence: [\"final answer\"],\n    };\n  }\n\n  if (decision.stop === \"request-user-input\") {\n    return {\n      action: \"request-user-input\" as const,\n      taskStatus: \"waiting\" as const,\n      stopReason: \"need-user-input\",\n      purpose: \"Ask the user for one concrete missing input before continuing.\",\n      expectedEvidence: [\"user follow-up request\"],\n    };\n  }\n\n  return {\n    action: \"cannot-answer\" as const,\n    taskStatus: \"blocked\" as const,\n    stopReason: \"max-turns\",\n    purpose: \"Report honestly that the request could not be answered from grounded repo evidence.\",\n    expectedEvidence: [\"failure summary\"],\n  };\n}\n"]}