@moretea-labs/forge 1.8.0 → 1.8.1

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-pack.ts

@@ -381,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,
@@ -451,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
@@ -812,16 +811,19 @@ export function buildControllerContextPack(
     .map((file) => file.path);
   const materializedExactKnownSet = new Set(materializedExactKnownPaths);
   const omittedCandidateCount = rankedCandidates.filter((entry) => !inspectedSet.has(entry.path)).length;
-  const exactKnownFilesFullyMaterialized = scopedExactKnownFileSearch
+  const exactKnownFilesLosslesslyMaterialized = scopedExactKnownFileSearch
     && exactKnownFiles.length > 0
     && exactKnownFiles.every((path) => files.some((file) => file.path === path
-      && file.snippets.some((snippet) => snippet.materialization === "complete_file" && !snippet.truncated)));
+      && 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, if every requested file is fully materialized and there are no omitted
-  // or denied candidates, the cap only discarded redundant hit lines.
+  // 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
-    && !(exactKnownFilesFullyMaterialized
+    && !(exactKnownFilesLosslesslyMaterialized
       && omittedCandidateCount === 0
       && policyDeniedFiles === 0
       && deniedPaths.length === 0

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,