@moretea-labs/forge 1.7.2 → 1.8.1

package/src/cli/controller/completion-backlog.ts

@@ -145,11 +145,11 @@ function classifyTask(repoRoot: string, issue: ControllerIssue, task: Controller
   }
 
   if (run && FINISHABLE_RUN_STATUSES.has(run.status)) {
-    if (policy.requiresHumanAcceptance) {
+    if (task.acceptanceCriteria.length > 0) {
       return {
         ...base,
         action: 'needs_human_review',
-        reason: `${policy.executionClass} requires explicit review before finishing ${run.runId}.`,
+        reason: `Task declares acceptance criteria that require an explicit acceptance decision before finishing ${run.runId}.`,
         canAutoFinish: false,
         suggestedDecision: 'approve_and_finish',
       };
@@ -157,7 +157,7 @@ function classifyTask(repoRoot: string, issue: ControllerIssue, task: Controller
     return {
       ...base,
       action: 'auto_finish',
-      reason: `Run ${run.runId} is ${run.status} and policy allows automatic finish.`,
+      reason: `Run ${run.runId} is ${run.status} and the Task declares no semantic acceptance criteria, so automatic finish may proceed.`,
       canAutoFinish: true,
       suggestedDecision: 'auto',
     };

package/src/cli/controller/completion-orchestrator.ts

@@ -11,7 +11,7 @@ import { resolveRepoPreferredControllerHome } from '../repositories/controller-h
 import { withControllerLock } from '../repositories/locks';
 import { listActiveLeases } from '../../runtime/resources/leases/store';
 import { acceptVerifiedTask, getIssue, projectIssueEffectiveView, recordTaskVerification, updateTask } from './issue-store';
-import { cleanupEvidenceResourceBlockers, completionEvidenceComplete, taskExecutionPolicy } from './execution-policy';
+import { cleanupEvidenceResourceBlockers, completionEvidenceComplete } from './execution-policy';
 import { currentCompletionTarget, resolveCompletionTargetBranch } from './completion-target';
 import { runControllerCheck } from './check-runner';
 import type { CleanupEvidence, ControllerIssue, ControllerTask, IntegrationEvidence, TaskCommandEvidence, TaskVerification } from './types';
@@ -183,7 +183,6 @@ function verificationForRun(
   reviewer: string,
   evidence: { integrationEvidence?: IntegrationEvidence; cleanupEvidence?: CleanupEvidence; completionReceipt?: CompletionReceipt; acceptanceConfirmed?: boolean } = {},
 ): TaskVerification {
-  const policy = taskExecutionPolicy(task);
   const acceptanceResults = task.acceptanceCriteria.map((criterion) => evidence.acceptanceConfirmed
     ? {
       criterion,
@@ -204,8 +203,7 @@ function verificationForRun(
     integratedRevision: evidence.integrationEvidence?.targetRevision,
     reviewedDiffHash: hashArtifact(repoRoot, run.diffArtifactPath),
     reviewer,
-    checkResults: policy.autoRunDeclaredChecks
-      ? task.checks.map((checkId) => {
+    checkResults: task.checks.map((checkId) => {
         try {
           const result = runControllerCheck(repoRoot, checkId);
           return {
@@ -218,8 +216,7 @@ function verificationForRun(
         } catch (error) {
           return { checkId, ok: false, summary: error instanceof Error ? error.message : String(error) };
         }
-      })
-      : [],
+      }),
     commandEvidence: commandEvidenceForRun(run),
     acceptanceResults,
     verifiedAt: nowIso(),
@@ -233,8 +230,7 @@ function result(repoRoot: string, input: Omit<FinishTaskRunResult, 'issue'>): Fi
 }
 
 function canAutoFinish(task: ControllerTask): boolean {
-  const policy = taskExecutionPolicy(task);
-  return policy.autoCompleteAfterSuccessfulRun && !policy.requiresHumanAcceptance;
+  return task.acceptanceCriteria.length === 0;
 }
 
 function verifyAndMaybeAccept(input: {
@@ -247,16 +243,7 @@ function verifyAndMaybeAccept(input: {
   allowCompletion?: boolean;
 }): { issue: ControllerIssue; taskStatus: string } {
   const { repoRoot, run, task, decision, reviewer } = input;
-  const policy = taskExecutionPolicy(task);
   const allowHumanAcceptance = decision === 'approve_and_finish';
-  if (policy.requiresHumanAcceptance && !allowHumanAcceptance) {
-    updateTask(repoRoot, run.issueId, run.taskId, {
-      status: task.status === 'verified' ? 'verified' : task.status,
-      note: input.note ?? `Run ${run.runId} is ready but ${policy.executionClass} requires an explicit review decision.`,
-    });
-    const waiting = getIssue(repoRoot, run.issueId);
-    return { issue: waiting, taskStatus: taskForRun(waiting, run.taskId).status };
-  }
 
   const current = getIssue(repoRoot, run.issueId);
   const currentTask = taskForRun(current, run.taskId);
@@ -438,19 +425,6 @@ function finishEditSessionUnlocked(repoRoot: string, options: FinishEditSessionO
     });
   }
 
-  const policy = taskExecutionPolicy(task);
-  if (policy.requiresHumanAcceptance && decision !== 'approve_and_finish') {
-    return editResult(repoRoot, {
-      action: 'needs_decision',
-      sessionId: initialSession.sessionId,
-      issueId: issue.id,
-      taskId: task.id,
-      decision,
-      taskStatus: task.status,
-      reason: `${policy.executionClass} requires approve_and_finish, request_changes, or discard.`,
-    });
-  }
-
   const completionTarget = currentCompletionTarget(repoRoot);
   if (!completionTarget.onTargetBranch) {
     return editResult(repoRoot, {
@@ -1165,19 +1139,6 @@ function finishTaskRunUnlocked(repoRoot: string, options: FinishTaskRunOptions):
     });
   }
 
-  const policy = taskExecutionPolicy(task);
-  if (policy.requiresHumanAcceptance && decision !== 'approve_and_finish') {
-    return result(repoRoot, {
-      action: 'needs_decision',
-      runId: run.runId,
-      issueId: issue.id,
-      taskId: task.id,
-      decision,
-      taskStatus: task.status,
-      reason: `${policy.executionClass} requires approve_and_finish, request_changes, or discard.`,
-    });
-  }
-
   const ownedAutoFinalization = run.status === 'running'
     && run.autoIntegrate === true
     && run.executionMode === 'worktree'

package/src/cli/controller/completion-target.ts

@@ -1,8 +1,4 @@
-import { realpathSync, statSync } from 'fs';
 import { spawnSync } from 'child_process';
-import { join } from 'path';
-import { resolveRepoPreferredControllerHome, resolveControllerHome } from '../repositories/controller-home';
-import { listRepositories } from '../repositories/registry';
 
 function gitText(repoRoot: string, args: string[]): string {
   const result = spawnSync('git', args, { cwd: repoRoot, encoding: 'utf-8' });
@@ -10,75 +6,10 @@ function gitText(repoRoot: string, args: string[]): string {
   return typeof result.stdout === 'string' ? result.stdout.trim() : '';
 }
 
-function canonical(path: string): string {
-  try { return realpathSync(path); }
-  catch (_error) { return path; }
-}
-
-interface TargetBranchCacheEntry {
-  branch: string;
-  registryMtimeMs: number;
-  expiresAt: number;
-}
-
-/**
- * Short-lived cache: invalidated by registry mtime or 30s TTL.
- *
- * Policy (do not rewrite without explicit design change):
- * - registry mtime 变化时立即失效；
- * - 未检测到 mtime 变化时，defaultBranch 变更最多存在 30 秒可见延迟。
- * - Cache keys include controllerHome + canonical repo root (no cross-repo bleed).
- * - Registry unavailable → Git fallback (origin/HEAD, main/master, current branch).
- */
-const targetBranchCache = new Map<string, TargetBranchCacheEntry>();
-const TARGET_BRANCH_TTL_MS = 30_000;
-
-function registryMtimeMs(controllerHome: string): number {
-  try {
-    return statSync(join(resolveControllerHome(controllerHome), 'repositories.json')).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-
-export function clearCompletionTargetCache(): void {
-  targetBranchCache.clear();
-}
-
 export function resolveCompletionTargetBranch(repoRoot: string): string {
-  const root = canonical(repoRoot);
-  try {
-    const home = resolveRepoPreferredControllerHome(repoRoot);
-    const mtime = registryMtimeMs(home);
-    const cacheKey = `${home}\0${root}`;
-    const cached = targetBranchCache.get(cacheKey);
-    const now = Date.now();
-    if (cached && cached.registryMtimeMs === mtime && cached.expiresAt > now) {
-      return cached.branch;
-    }
-    const registered = listRepositories(home, { includeRemoved: true }).find((record) => {
-      if (canonical(record.canonicalRoot) === root || canonical(record.localRoot) === root) return true;
-      return record.checkouts.some((checkout) => canonical(checkout.canonicalRoot) === root || canonical(checkout.localRoot) === root);
-    });
-    if (registered?.defaultBranch?.trim()) {
-      const branch = registered.defaultBranch.trim();
-      targetBranchCache.set(cacheKey, {
-        branch,
-        registryMtimeMs: mtime,
-        expiresAt: now + TARGET_BRANCH_TTL_MS,
-      });
-      return branch;
-    }
-  } catch (_error) {
-    // Temporary test repositories and unregistered clones fall through to Git discovery.
-  }
-
-  const remoteHead = gitText(repoRoot, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD']);
-  if (remoteHead.startsWith('origin/')) return remoteHead.slice('origin/'.length);
-  for (const candidate of ['main', 'master']) {
-    if (gitText(repoRoot, ['show-ref', '--verify', '--hash', `refs/heads/${candidate}`])) return candidate;
-  }
-  return gitText(repoRoot, ['branch', '--show-current']) || 'main';
+  const branch = gitText(repoRoot, ['branch', '--show-current']);
+  if (!branch) throw new Error('integration target must be an attached branch');
+  return branch;
 }
 
 export function currentCompletionTarget(repoRoot: string): {

package/src/cli/controller/context/source-materializer.ts

@@ -1,5 +1,5 @@
-import ts from 'typescript';
 import type { McpPolicy } from '../../mcp/types';
+import { extractTypeScriptSourceSymbolsInSidecar } from '../../../runtime/context/typescript-navigation-process';
 import { redactMcpText } from '../../mcp/redaction';
 import { readRepositoryRange, type RepositoryReadSession } from '../../repository/inspector';
 
@@ -46,16 +46,8 @@ interface SymbolRange {
   enclosing?: string;
 }
 
-interface IndexedDeclaration {
-  node: ts.Node;
-  kind: string;
-  fullStart: number;
-  end: number;
-}
-
 interface SourceSymbolIndex {
-  sourceFile: ts.SourceFile;
-  declarations: IndexedDeclaration[];
+  declarations: SymbolRange[];
 }
 
 const SOURCE_SYMBOL_INDEX_CACHE_MAX_ENTRIES = 32;
@@ -77,11 +69,6 @@ export function clearSourceSymbolIndexCacheForTest(): void {
   sourceSymbolIndexCacheMisses = 0;
 }
 
-function boundedContent(content: string, maxChars: number): { content: string; truncated: boolean } {
-  if (content.length <= maxChars) return { content, truncated: false };
-  return { content: `${content.slice(0, maxChars)}\n... <snippet truncated>`, truncated: true };
-}
-
 function plainSource(numbered: string): string {
   return numbered
     .split(/\r?\n/)
@@ -107,70 +94,13 @@ function mergeHitLines(lines: number[]): number[] {
   return merged;
 }
 
-function scriptKind(path: string): ts.ScriptKind | undefined {
-  if (/\.tsx$/i.test(path)) return ts.ScriptKind.TSX;
-  if (/\.jsx$/i.test(path)) return ts.ScriptKind.JSX;
-  if (/\.(?:mts|cts|ts)$/i.test(path)) return ts.ScriptKind.TS;
-  if (/\.(?:mjs|cjs|js)$/i.test(path)) return ts.ScriptKind.JS;
-  return undefined;
-}
-
-function declarationName(node: ts.Node): string | undefined {
-  const named = node as ts.Node & { name?: ts.Node };
-  if (!named.name) return undefined;
-  return named.name.getText().slice(0, 200);
-}
-
-function declarationKind(node: ts.Node): string | undefined {
-  if (ts.isFunctionDeclaration(node)) return 'function';
-  if (ts.isMethodDeclaration(node)) return 'method';
-  if (ts.isConstructorDeclaration(node)) return 'constructor';
-  if (ts.isGetAccessorDeclaration(node)) return 'getter';
-  if (ts.isSetAccessorDeclaration(node)) return 'setter';
-  if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) return 'class';
-  if (ts.isInterfaceDeclaration(node)) return 'interface';
-  if (ts.isTypeAliasDeclaration(node)) return 'type';
-  if (ts.isEnumDeclaration(node)) return 'enum';
-  if (ts.isModuleDeclaration(node)) return 'module';
-  if (ts.isVariableStatement(node) && node.declarationList.declarations.some((declaration) =>
-    declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)))) return 'function-variable';
-  return undefined;
-}
-
-function enclosingName(node: ts.Node): string | undefined {
-  let current = node.parent;
-  while (current) {
-    if (ts.isClassDeclaration(current) || ts.isClassExpression(current) || ts.isInterfaceDeclaration(current) || ts.isModuleDeclaration(current)) {
-      const kind = declarationKind(current) ?? 'container';
-      const name = declarationName(current);
-      return name ? `${kind}:${name}` : kind;
-    }
-    current = current.parent;
-  }
-  return undefined;
-}
-
-function buildSourceSymbolIndex(path: string, source: string, kind: ts.ScriptKind): SourceSymbolIndex {
-  const sourceFile = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, kind);
-  const declarations: IndexedDeclaration[] = [];
-  const visit = (node: ts.Node): void => {
-    const candidateKind = declarationKind(node);
-    if (candidateKind) {
-      declarations.push({
-        node,
-        kind: candidateKind,
-        fullStart: node.getFullStart(),
-        end: node.end,
-      });
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return { sourceFile, declarations };
+function sourceSyntaxKind(path: string): string | undefined {
+  const match = path.toLowerCase().match(/\.(tsx|jsx|mts|cts|ts|mjs|cjs|js)$/);
+  return match?.[1];
 }
 
 function cachedSourceSymbolIndex(path: string, fileSha: string, numberedSource: string): SourceSymbolIndex | undefined {
-  const kind = scriptKind(path);
+  const kind = sourceSyntaxKind(path);
   if (kind === undefined) return undefined;
   const key = `${kind}:${fileSha}`;
   const cached = sourceSymbolIndexCache.get(key);
@@ -182,7 +112,9 @@ function cachedSourceSymbolIndex(path: string, fileSha: string, numberedSource:
   }
 
   sourceSymbolIndexCacheMisses += 1;
-  const built = buildSourceSymbolIndex(path, plainSource(numberedSource), kind);
+  const built: SourceSymbolIndex = {
+    declarations: extractTypeScriptSourceSymbolsInSidecar(path, plainSource(numberedSource)),
+  };
   sourceSymbolIndexCache.set(key, built);
   while (sourceSymbolIndexCache.size > SOURCE_SYMBOL_INDEX_CACHE_MAX_ENTRIES) {
     const oldest = sourceSymbolIndexCache.keys().next().value as string | undefined;
@@ -194,22 +126,13 @@ function cachedSourceSymbolIndex(path: string, fileSha: string, numberedSource:
 
 function symbolAtLine(index: SourceSymbolIndex | undefined, line: number): SymbolRange | undefined {
   if (!index) return undefined;
-  const { sourceFile, declarations } = index;
-  const targetLine = Math.min(Math.max(1, line), sourceFile.getLineAndCharacterOfPosition(sourceFile.end).line + 1);
-  const position = sourceFile.getPositionOfLineAndCharacter(targetLine - 1, 0);
-  let selected: IndexedDeclaration | undefined;
-  for (const candidate of declarations) {
-    if (candidate.fullStart > position || candidate.end < position) continue;
-    if (!selected || (candidate.end - candidate.fullStart) < (selected.end - selected.fullStart)) selected = candidate;
+  const targetLine = Math.max(1, line);
+  let selected: SymbolRange | undefined;
+  for (const candidate of index.declarations) {
+    if (candidate.startLine > targetLine || candidate.endLine < targetLine) continue;
+    if (!selected || (candidate.endLine - candidate.startLine) < (selected.endLine - selected.startLine)) selected = candidate;
   }
-  if (!selected) return undefined;
-  return {
-    startLine: sourceFile.getLineAndCharacterOfPosition(selected.node.getStart(sourceFile)).line + 1,
-    endLine: sourceFile.getLineAndCharacterOfPosition(selected.node.end).line + 1,
-    kind: selected.kind,
-    name: declarationName(selected.node),
-    enclosing: enclosingName(selected.node),
-  };
+  return selected;
 }
 
 function materializedSnippet(
@@ -219,18 +142,42 @@ function materializedSnippet(
   materialization: SourceMaterializationKind,
   symbol?: SymbolRange,
 ): MaterializedSourceSnippet {
-  const numbered = sliceNumbered(full.content, range.startLine, range.endLine);
-  const redacted = redactMcpText(numbered);
-  const bounded = boundedContent(redacted.text, options.maxCharsPerSnippet);
+  let low = range.startLine;
+  let high = range.endLine;
+  let exactEndLine = range.startLine - 1;
+  let exactContent = '';
+  let exactRedactions: Array<{ type: string; count: number }> = [];
+  while (low <= high) {
+    const candidateEndLine = Math.floor((low + high) / 2);
+    const redacted = redactMcpText(sliceNumbered(full.content, range.startLine, candidateEndLine));
+    if (redacted.text.length <= options.maxCharsPerSnippet) {
+      exactEndLine = candidateEndLine;
+      exactContent = redacted.text;
+      exactRedactions = redacted.redactions;
+      low = candidateEndLine + 1;
+    } else {
+      high = candidateEndLine - 1;
+    }
+  }
+  // Source evidence is line-addressed. Never character-cut content while still
+  // reporting the original endLine. A single unusually long line stays intact
+  // so the reported source range remains truthful; outer response budgets remain
+  // the hard transport fence.
+  if (exactEndLine < range.startLine) {
+    const redacted = redactMcpText(sliceNumbered(full.content, range.startLine, range.startLine));
+    exactEndLine = range.startLine;
+    exactContent = redacted.text;
+    exactRedactions = redacted.redactions;
+  }
   return {
     path: full.path,
     startLine: range.startLine,
-    endLine: range.endLine,
+    endLine: exactEndLine,
     totalLines: full.totalLines,
     sha256: full.sha256,
-    content: bounded.content,
-    truncated: bounded.truncated,
-    redactions: redacted.redactions,
+    content: exactContent,
+    truncated: exactEndLine < range.endLine,
+    redactions: exactRedactions,
     reason: options.reasons.join(', '),
     cacheHit: full.cacheHit,
     materialization,
@@ -238,6 +185,33 @@ function materializedSnippet(
   };
 }
 
+function materializedRange(
+  full: ReturnType<typeof readRepositoryRange>,
+  range: { startLine: number; endLine: number },
+  options: MaterializeSourceOptions,
+  materialization: SourceMaterializationKind,
+  maxSnippets: number,
+  symbol?: SymbolRange,
+): MaterializedSourceSnippet[] {
+  const snippets: MaterializedSourceSnippet[] = [];
+  let startLine = range.startLine;
+  while (startLine <= range.endLine && snippets.length < maxSnippets) {
+    const snippet = materializedSnippet(
+      full,
+      { startLine, endLine: range.endLine },
+      options,
+      materialization,
+      symbol,
+    );
+    snippets.push({ ...snippet, truncated: false });
+    startLine = snippet.endLine + 1;
+  }
+  if (startLine <= range.endLine && snippets.length > 0) {
+    snippets[snippets.length - 1] = { ...snippets[snippets.length - 1]!, truncated: true };
+  }
+  return snippets;
+}
+
 /**
  * Materialize current source in semantic units. Complete small files and
  * complete TypeScript/JavaScript declarations win; a fixed line window is the
@@ -272,7 +246,14 @@ export function materializeSource(options: MaterializeSourceOptions): Materializ
     const key = `${range.startLine}:${range.endLine}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    snippets.push(materializedSnippet(full, range, options, symbol ? 'symbol' : 'line_window', symbol));
+    snippets.push(...materializedRange(
+      full,
+      range,
+      options,
+      symbol ? 'symbol' : 'line_window',
+      options.maxSnippets - snippets.length,
+      symbol,
+    ));
   }
   return snippets;
 }

package/src/cli/controller/context/types.ts

@@ -3,7 +3,7 @@ import type { CodeGraphIndexMetadata, CodeGraphNodeSummary, CodeGraphReadProvide
 import type { queryCodeGraphReadProvider, queryCodeGraphReadProviderAsync } from '../../../runtime/context/codegraph-read-provider';
 import type { MaterializedSourceSnippet } from './source-materializer';
 
-export const CONTEXT_PACK_SCHEMA_VERSION = 10;
+export const CONTEXT_PACK_SCHEMA_VERSION = 11;
 export type StructuralContextMode = 'off' | 'auto' | 'required';
 export type ControllerContextRetrievalMode = 'implementation' | 'plan' | 'debug' | 'review';
 export type ControllerEvidenceReadinessStatus = 'ready' | 'degraded' | 'insufficient';
@@ -113,7 +113,10 @@ export interface ControllerContextPackProjection {
     policyDeniedFiles: number;
     skippedLargeFiles: number;
     skippedBinaryFiles: number;
+    /** Raw lexical/discovery result cap was reached. This may be harmless when exact-known files were fully materialized. */
     truncated: boolean;
+    /** True only when truncation can hide material source evidence. */
+    evidenceTruncated: boolean;
     cacheHit: boolean;
   };
   instructionContext: {
@@ -233,7 +236,10 @@ export interface ControllerContextPackProjection {
       policyDeniedFiles: number;
       largeFiles: number;
       binaryFiles: number;
+      /** Raw result cap signal retained for diagnostics. */
       searchTruncated: boolean;
+      /** Whether the raw cap actually omitted material evidence. */
+      evidenceTruncated: boolean;
       structuralTruncated: boolean;
     };
     materialization: { completeFiles: number; symbols: number; fallbackWindows: number };

package/src/cli/controller/context-pack.ts

@@ -237,6 +237,7 @@ export function buildControllerContextPack(
         limit: Math.min(Math.max(maxFiles, 4), 12),
         maxNodes: Math.min(Math.max(maxFiles * 5, 20), 60),
         maxDepth: 2,
+        ...(structuralMode === 'required' ? { refresh: 'if_stale' as const } : {}),
       });
       const graph = structuralResult(structural);
       const metadata = structural.metadata
@@ -380,7 +381,7 @@ export function buildControllerContextPack(
   // though inventory itself was cached.
   const lexicalStartedAt = performance.now();
   const requiredStructuralFallbackNeedsLexical = structuralMode === "required" && !structuralContext.requiredSatisfied;
-  if (searchQueries.length > 0 && (requiredStructuralFallbackNeedsLexical || candidates.size < maxFiles * 3)) {
+  if (searchQueries.length > 0 && (requiredSearchQueries.length > 0 || requiredStructuralFallbackNeedsLexical || candidates.size < maxFiles * 3)) {
     const search = searchRepositoryMany(repoRoot, policy, {
       queries: searchQueries,
       files: scopedExactKnownFileSearch ? exactKnownFiles : undefined,
@@ -450,8 +451,7 @@ export function buildControllerContextPack(
   // implementation mode a permanent evidence-closure blind spot.
   const multiWaveEligible = retrievalMode !== "implementation"
     || structuralMode !== "off"
-    || impactDomains.length > 0
-    || explicitKnownPaths.length > 1;
+    || impactDomains.length > 0;
   timingsMs.expansionBudgetMax = multiWaveEligible ? Math.min(6, Math.max(2, Math.ceil(maxFiles / 2))) : 0;
   const rankedExactKnownCount = rankedCandidates.filter(isExactKnownCandidate).length;
   const initialCandidateLimit = multiWaveEligible
@@ -810,6 +810,25 @@ export function buildControllerContextPack(
     .filter((file) => file.reasons.includes("explicit-known-path"))
     .map((file) => file.path);
   const materializedExactKnownSet = new Set(materializedExactKnownPaths);
+  const omittedCandidateCount = rankedCandidates.filter((entry) => !inspectedSet.has(entry.path)).length;
+  const exactKnownFilesLosslesslyMaterialized = scopedExactKnownFileSearch
+    && exactKnownFiles.length > 0
+    && exactKnownFiles.every((path) => files.some((file) => file.path === path
+      && file.snippets.length > 0
+      && file.snippets.every((snippet) => !snippet.truncated)));
+  // `search.truncated` records that lexical hit collection reached a result cap.
+  // That is not automatically an evidence gap. For an exact-known implementation
+  // scope, bounded symbol/window materialization is still authoritative raw-source
+  // evidence as long as every requested file was materialized without snippet loss
+  // and no candidate was omitted or denied. Actual raw snippet truncation remains a
+  // separate readiness failure through `rawSnippetTruncated`.
+  const evidenceSearchTruncated = searchTruncated
+    && !(exactKnownFilesLosslesslyMaterialized
+      && omittedCandidateCount === 0
+      && policyDeniedFiles === 0
+      && deniedPaths.length === 0
+      && skippedLargeFiles === 0
+      && skippedBinaryFiles === 0);
   const unresolvedRelationships = Array.from(new Set([
     ...coverageGaps,
     ...expansionSignals,
@@ -819,7 +838,7 @@ export function buildControllerContextPack(
   const readinessReasonCodes = Array.from(new Set([
     ...(files.length === 0 ? ["raw_source_unavailable"] : []),
     ...(rawSnippetTruncated ? ["raw_source_truncated"] : []),
-    ...(searchTruncated ? ["retrieval_truncated"] : []),
+    ...(evidenceSearchTruncated ? ["retrieval_truncated"] : []),
     ...(structuralMode === "required" && !structuralContext.requiredSatisfied ? ["required_structural_context_unsatisfied"] : []),
     ...(structuralContext.status === "stale" ? ["structural_context_stale"] : []),
     ...(structuralContext.status === "unavailable" || structuralContext.status === "degraded" ? ["structural_provider_degraded"] : []),
@@ -853,8 +872,8 @@ export function buildControllerContextPack(
     },
     semantic: { status: "not_requested", reasonCodes: ["semantic_navigation_not_requested"] },
     retrieval: {
-      searchTruncated,
-      omittedCandidateCount: rankedCandidates.filter((entry) => !inspectedSet.has(entry.path)).length,
+      searchTruncated: evidenceSearchTruncated,
+      omittedCandidateCount,
       policyDeniedCandidateCount: policyDeniedFiles + deniedPaths.length,
       likelyRelatedNotInspectedCount: likelyRelatedNotInspected.length,
     },
@@ -895,6 +914,7 @@ export function buildControllerContextPack(
       skippedLargeFiles,
       skippedBinaryFiles,
       truncated: searchTruncated,
+      evidenceTruncated: evidenceSearchTruncated,
       cacheHit: lexicalCacheHit,
     },
     instructionContext,
@@ -920,6 +940,7 @@ export function buildControllerContextPack(
         largeFiles: skippedLargeFiles,
         binaryFiles: skippedBinaryFiles,
         searchTruncated,
+        evidenceTruncated: evidenceSearchTruncated,
         structuralTruncated: structuralContext.truncated,
       },
       materialization: {
@@ -1104,6 +1125,7 @@ export async function buildControllerContextPackAsync(
     limit: Math.min(Math.max(maxFiles, 4), 12),
     maxNodes: Math.min(Math.max(maxFiles * 5, 20), 60),
     maxDepth: 2,
+    ...(structuralMode === 'required' ? { refresh: 'if_stale' as const } : {}),
   };
   const structuralCacheKey = JSON.stringify({ queryRoot: structuralIndexRoot, request: structuralRequest });
   const sessionCache = getRepositoryReadSessionCache(repoRoot, options.session);

package/src/cli/controller/execution-completion.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import type { AgentJobMeta } from '../agent-jobs/types';
 import { runControllerCheck } from './check-runner';
-import { cleanupEvidenceResourceBlockers, completionEvidenceComplete, taskExecutionPolicy } from './execution-policy';
+import { cleanupEvidenceResourceBlockers, completionEvidenceComplete } from './execution-policy';
 import { acceptVerifiedTask, getIssue, recordTaskVerification, updateTask } from './issue-store';
 import type { CompletionReceipt, CompletionReceiptSource, TaskCommandEvidence, TaskVerification } from './types';
 import { legacyIssueAuthorityRetired } from './legacy-issue-cutover';
@@ -92,9 +92,7 @@ export function continueTaskAfterSuccessfulRun(
   if (['done', 'cancelled', 'superseded'].includes(task.status)) {
     return { continued: false, status: task.status, reason: 'Task is already terminal.' };
   }
-  const policy = taskExecutionPolicy(task);
-  const checkResults = policy.autoRunDeclaredChecks
-    ? task.checks.map((checkId) => {
+  const checkResults = task.checks.map((checkId) => {
         try {
           const result = runControllerCheck(repoRoot, checkId);
           return {
@@ -105,8 +103,7 @@ export function continueTaskAfterSuccessfulRun(
         } catch (error) {
           return { checkId, ok: false, summary: error instanceof Error ? error.message : String(error) };
         }
-      })
-    : [];
+      });
 
   const commandEvidence: TaskCommandEvidence[] = [{
     command: ['forge', 'agent-run', run.runId],
@@ -148,7 +145,7 @@ export function continueTaskAfterSuccessfulRun(
     });
     return { continued: true, status, checkCount: checkResults.length };
   }
-  if (status === 'verified' && policy.autoCompleteAfterSuccessfulRun && !policy.requiresHumanAcceptance) {
+  if (status === 'verified' && task.acceptanceCriteria.length === 0) {
     const closureComplete = run.closureState === 'completed' && completionEvidenceComplete(verification, {
       issueId: run.issueId,
       taskId: run.taskId,