elanous 0.2.32 → 0.2.35

package/src/agent-substrate/acp-reviewer.ts

@@ -35,6 +35,22 @@ export interface AcpReviewerOpts {
   timeoutMs?: number;
   /** One deadline for spawn → initialize → session/new → model select (ms). A child that never answers ACP must not hang the review. Default min(timeoutMs, 60000). */
   handshakeTimeoutMs?: number;
+  /**
+   * ACP-REVIEW-VIA-TEAMCLAUDE: how a `claude` review without an explicit `backendSpec` finds the teamclaude
+   * (cct) route. Default (production, non-injected) = `resolveTeamclaudeReviewRoute()`; an injected agent
+   * without this seam does not probe the host.
+   */
+  resolveClaudeRoute?: () => import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute
+    | Promise<import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute>;
+}
+
+/** ACP claude reviews read the repo with tools and ran 228–345s in practice (OPC #25934); 300s cut them. */
+const ACP_CLAUDE_REVIEW_TIMEOUT_SEC = 600;
+const ACP_REVIEW_TIMEOUT_SEC = 300;
+
+/** Default per-review deadline (seconds) when the caller gives none. */
+export function defaultAcpReviewTimeoutSec(backend: string): number {
+  return canonicalizeBackendId(backend) === 'claude' ? ACP_CLAUDE_REVIEW_TIMEOUT_SEC : ACP_REVIEW_TIMEOUT_SEC;
 }
 
 /**
@@ -55,6 +71,9 @@ export interface AcpReviewerOpts {
  */
 export const DEFAULT_REVIEW_BACKEND = 'codex';
 
+/** Stable failureReason prefix carried through reviewPullRequest's fail-soft result. */
+export const GROK_ACP_REVIEW_TIMEOUT = 'ACP_REVIEW_TIMEOUT:grok:';
+
 // ACP ToolKind(zToolKind) 중 read-only(부작용 없음) — 리뷰어에게 허가할 계열.
 const READONLY_TOOL_KINDS = new Set(['read', 'search', 'fetch', 'think', 'switch_mode']);
 // 명시적 변경/실행 계열 — 리뷰(read-only)에선 절대 불허.
@@ -84,7 +103,7 @@ const TOOL_REVIEW_PREAMBLE = [
  *  - model 지정 시 selectSessionModel 로 tier 고정(picked 관측).
  *  - ⭐auto-allow permission approver — 리뷰어의 read-only 툴콜을 무조건 허가(대표 지시)해 Read 반복거부
  *    정체를 원천제거. 각 허가는 debug.log 로 각인(제1원칙 관측 관문 — 자동승인은 관측되는 결정).
- *  - timeout: 초과 시 cancel→throw. 오류/타임아웃은 각인 후 rethrow → reviewPullRequest 가 fail-soft
+ *  - timeout: 초과 시 실패를 확정하고 cancel·stop. 오류/타임아웃은 각인 후 rethrow → reviewPullRequest 가 fail-soft
  *    (reviewed=false)로 흡수, CLI 가 reviewed=false 를 "리뷰 실패"로 표면화(부분결과 오판 pass 방지). */
 export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images?: readonly ReviewImage[]) => Promise<string> {
   return async (prompt: string, images?: readonly ReviewImage[]): Promise<string> => {
@@ -93,6 +112,26 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     // The injected seam deliberately accepts arbitrary test backends. The
     // production path alone resolves aliases and transport through the factory.
     const backend = canonicalizeBackendId(requestedBackend);
+    const timeoutMs = opts.timeoutMs ?? defaultAcpReviewTimeoutSec(backend) * 1000;
+    // ACP-REVIEW-VIA-TEAMCLAUDE (대표 10-21): a claude review goes through teamclaude (multi-account proxy) when it
+    //   answers with a base URL — same cct spawn as the subscription lane. No answer = the prior path, recorded.
+    let backendSpec = opts.backendSpec;
+    let childEnv = opts.env;
+    const resolveClaudeRoute = backend === 'claude' && !opts.backendSpec
+      ? opts.resolveClaudeRoute ?? (injected ? undefined
+        : async () => (await import('../self-dev/review-provider-fallback.js')).resolveTeamclaudeReviewRoute())
+      : undefined;
+    if (resolveClaudeRoute) {
+      let route: import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute;
+      try { route = await resolveClaudeRoute(); } catch { route = { reason: 'teamclaude-unavailable' }; }
+      if (route.spawn) { backendSpec = route.spawn.backendSpec; childEnv = route.spawn.env; }
+      debug.log('review.acp', 'claude-route', {
+        viaTeamclaude: Boolean(route.spawn),
+        baseUrlSet: Boolean(childEnv?.ANTHROPIC_BASE_URL),
+        timeoutSec: Math.round(timeoutMs / 1000),
+        reason: route.reason,
+      });
+    }
     // ⛔⭐⭐⭐ 백엔드 해석은 «`try` 밖»이라 여기서 던지면 아래 `catch` 의 `acp-review/error` 가
     //   «안 걸린다**. 그래서 `--acp-backend claude-code`(미등록) 같은 오타를 주면 레지스트리가
     //   ***`Unknown ACP backend "claude-code". Known: …"`*** 라는 «완벽한» 오류를 던지는데도
@@ -102,14 +141,13 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     //   ⇒ 이 한 줄만 자기 catch 로 감싼다(전체 try 를 앞당기면 `start` 관측이 그 안으로 들어간다).
     let transport: string | null;
     try {
-      transport = injected ? null : opts.backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
+      transport = injected ? null : backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
     } catch (e) {
       debug.log('acp-review', 'error', {
         requestedBackend, backend, stage: 'resolve-backend', message: (e as Error).message,
       }, { level: 'error' });
       throw e;
     }
-    const timeoutMs = opts.timeoutMs ?? 300_000;
     debug.log('acp-review', 'start', {
       requestedBackend,
       backend,
@@ -117,12 +155,17 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
       model: opts.model ?? '(default)',
       promptChars: prompt.length,
     });
+    const startedAt = Date.now();
+    let phase = 'spawn';
+    let phaseStartedAt = startedAt;
+    const enterPhase = (next: string): void => { phase = next; phaseStartedAt = Date.now(); };
     let allowed = 0;
     let denied = 0;
+    const observedToolCalls = new Set<string>();
     let capabilitiesObserved = false;
     const agentOpts: Omit<AcpAgentOpts, 'backendId'> = {
       cwd: opts.cwd,
-      ...(opts.backendSpec ? { backendSpec: opts.backendSpec, env: opts.env } : {}),
+      ...(backendSpec ? { backendSpec, env: childEnv } : {}),
       log: (message) => debug.log('acp-review', 'agent-log', { backend, message }),
       onCapabilities: (capabilities) => {
         capabilitiesObserved = true;
@@ -149,10 +192,12 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     };
     // A review owns its manager and subprocess: the global manager caches
     // chat agents, whose callbacks and lifecycle must not be mutated here.
-    const reviewManager = injected || opts.backendSpec ? undefined : new AcpAgentManager();
+    // Grok's start can hang before the manager registers the subprocess;
+    // own it directly so the handshake timeout can stop that child.
+    const directAgent = injected || Boolean(backendSpec) || backend === 'grok';
+    const reviewManager = directAgent ? undefined : new AcpAgentManager();
     let agent: AcpAgent | undefined;
     let text = '';
-    let timedOut = false;
     let timer: ReturnType<typeof setTimeout> | undefined;
     const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? Math.min(timeoutMs, 60_000);
     const handshakeDeadline = Date.now() + handshakeTimeoutMs;
@@ -165,9 +210,16 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     })]).finally(() => { if (handshakeTimer) clearTimeout(handshakeTimer); });
     try {
       if (opts.createAgent) agent = opts.createAgent({ backendId: requestedBackend, ...agentOpts });
-      else if (opts.backendSpec) agent = new AcpAgent({ backendId: requestedBackend, ...agentOpts });
-      else agent = await withinHandshake(reviewManager!.getAgent(requestedBackend, agentOpts));
-      if (injected || opts.backendSpec) await withinHandshake(agent.start());
+      else if (directAgent) agent = new AcpAgent({ backendId: requestedBackend, ...agentOpts });
+      else {
+        // getAgent owns both spawn and initialize; neither step is independently observable here.
+        enterPhase('spawn-initialize');
+        agent = await withinHandshake(reviewManager!.getAgent(requestedBackend, agentOpts));
+      }
+      if (directAgent) {
+        enterPhase(injected ? 'initialize' : 'spawn-initialize');
+        await withinHandshake(agent.start());
+      }
       if (!capabilitiesObserved) {
         try {
           debug.log('acp-review', 'capabilities', {
@@ -181,12 +233,14 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
           // Observability must not interrupt a review.
         }
       }
+      enterPhase('session-new');
       const sid = await withinHandshake(agent.newSession());
       if (opts.model) {
+        enterPhase('model-select');
         const picked = await withinHandshake(agent.selectSessionModel(sid, opts.model));
         debug.log('acp-review', 'model', { requested: opts.model, picked: picked?.name ?? null, backend });
       }
-      timer = setTimeout(() => { timedOut = true; agent!.cancel(sid).catch(() => { /* noop */ }); }, timeoutMs);
+      enterPhase('prompt');
       // ⭐⭐ `P4b` 멀티미디어 — 이미지를 «별도 ContentBlock» 으로 싣는다.
       //   ⛔ 광고를 «먼저 본다** — 백엔드가 image 를 안 받는다고 말하면 안 보낸다. 보내 봐야
       //      거절이 이 층보다 훨씬 읽기 어려운 자리에서 나고, 그 거절은 리뷰 실패로 보인다.
@@ -211,23 +265,44 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
           // Observation must not prevent the review from running.
         }
       }
-      await agent.prompt(sid, [{ type: 'text', text: TOOL_REVIEW_PREAMBLE + prompt }, ...imageBlocks], (u) => {
+      const promptAttempt = agent.prompt(sid, [{ type: 'text', text: TOOL_REVIEW_PREAMBLE + prompt }, ...imageBlocks], (u) => {
+        if (u.sessionUpdate === 'tool_call' || u.sessionUpdate === 'tool_call_update') {
+          observedToolCalls.add(u.toolCallId);
+        }
         if (u.sessionUpdate === 'agent_message_chunk') {
           const c = u.content;
           if (c.type === 'text' && c.text) text += c.text;
         }
       });
-      if (timedOut) throw new Error(`ACP 리뷰 타임아웃(${timeoutMs}ms·툴콜 ${allowed})`);
+      // Do not rely on cancel causing prompt() to settle: a stalled ACP child may never answer it.
+      await Promise.race([promptAttempt, new Promise<never>((_, reject) => {
+        timer = setTimeout(() => {
+          // Commit the timeout before cancel can settle prompt with a partial response.
+          reject(new Error(backend === 'grok'
+            ? `${GROK_ACP_REVIEW_TIMEOUT} ${timeoutMs}ms·툴콜 ${observedToolCalls.size}`
+            : `ACP 리뷰 타임아웃(${timeoutMs}ms·툴콜 ${allowed})`));
+          void agent!.cancel(sid).catch(() => { /* noop */ });
+        }, timeoutMs);
+      })]);
     } catch (e) {
-      debug.log('acp-review', 'error', { backend, model: opts.model ?? '(default)', message: (e as Error).message }, { level: 'error' });
-      throw e;
+      const message = (e as Error).message;
+      const handshakeTimeout = message.startsWith('ACP handshake timeout (');
+      const failure = backend === 'grok' && handshakeTimeout
+        ? new Error(`${GROK_ACP_REVIEW_TIMEOUT} ${message}`) : e;
+      const timeout = message.startsWith(GROK_ACP_REVIEW_TIMEOUT) || message.startsWith('ACP 리뷰 타임아웃(') || handshakeTimeout;
+      debug.log('acp-review', 'error', {
+        backend, provider: backend, model: opts.model ?? '(default)', message: (failure as Error).message,
+        phase, elapsedMs: Date.now() - startedAt, phaseElapsedMs: Date.now() - phaseStartedAt,
+        toolCalls: observedToolCalls.size, allowed, denied, ...(timeout ? { classification: phase === 'prompt' && observedToolCalls.size === 0 ? 'pre-tool-timeout' : 'acp-timeout' } : {}),
+      }, { level: 'error' });
+      throw failure;
     } finally {
       if (timer) clearTimeout(timer);
       // Both paths are review-owned: injected agents retain their direct
       // cleanup seam, while the per-review manager releases its agents and
       // process hooks. An injected agent is external to the manager.
       try {
-        if (injected || opts.backendSpec) await agent?.stop();
+        if (directAgent) await agent?.stop();
         else await reviewManager!.dispose();
       } catch (e) {
         debug.log('acp-review', 'stop-fail', { backend, message: (e as Error).message }, { level: 'error' });

package/src/agent-substrate/pr-reviewer.ts

@@ -684,7 +684,21 @@ const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]
 const KNOWN_NO_FINDING_REMARKS = new Set([
   // #27349 저장 JSON의 실제 무소견 문구.
   '문서 전용 변경이고 의도된 산출물이 실제로 존재하며 배선 누락·죽은 코드·Goodhart 해당 없음',
+  // #29974 ACP 실측: 단독 (없음) 뒤에 차단 결함 부재와 통과 근거를 적은 닫힌 문장.
+  '막는 결함은 찾지 못했다. ref → 전체 SHA 고정, 이미지 SHA12 태그, Job 쪽 `imageCommit==source.sha`·`image==shelfImage` 가드까지 한 줄로 이어진다.',
 ]);
+// #30028 ACP 저장 리뷰의 긍정 수용 서술. 광범위한 의미 추정보다 원문을 고정한다.
+const KNOWN_POSITIVE_FINDINGS = new Set([
+  '없음. 수용 기준은 코드와 시험 기준으로 충족한다.',
+  '프로토타입 키(`constructor`·`__proto__`)를 Map 으로 바르게 센다.',
+  '분모는 `task-agent/entrance-denominator` 별도 이벤트로만 나간다. `task-agent/action` 은 그대로다.',
+  'retro 사실과 tasks cover 집계는 분모 줄이 있든 없든 같다. 시험(`retro-cli.test.ts`)이 이를 고정하고, 임시 폴더는 `finally` 의 `rmSync` 로 지운다.',
+  // 이 후속 PR 자체의 ACP r2: 닫힌 무소견 문장.
+  '없음 — 막는 결함은 찾지 못했다.',
+]);
+function isPositiveNoFinding(text: string): boolean {
+  return KNOWN_POSITIVE_FINDINGS.has(text);
+}
 /** 괄호 안 `없음` 뒤 설명이 닫힌 무소견 문법에 정확히 들어가는가. */
 function isLongNoFindingBracket(text: string): boolean {
   const m = LONG_BRACKETED_SENTINEL.exec(text.trim());
@@ -699,8 +713,11 @@ function isLongNoFindingBracket(text: string): boolean {
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
   if (!text || isBracketedPlaceholder(text)) return true;
+  if (isPositiveNoFinding(text)) return true;
   if (/^[-—–]+$/.test(text)) return true;
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
+  const leadingNone = /^[（(]\s*(?:없음|none)\s*[）)]\s+(.+)$/i.exec(markerText);
+  if (leadingNone && KNOWN_NO_FINDING_REMARKS.has(leadingNone[1]!.trim())) return true;
   if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;
   const bracketed = BRACKETED_SENTINEL.exec(markerText);
   if (bracketed) {

package/src/agent-substrate/review-finding-key.ts

@@ -1,8 +1,10 @@
 import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 
 export const REVIEW_FINDING_KEY_VERSION = 'reviewFindingKey-v1';
 export const MAX_CITED_REVIEW_SYMBOL_CHARS = 256;
 const CITED_REVIEW_SYMBOL_HASH_CHARS = 16;
+const CITED_PATH_EXTENSION = /\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yaml|yml|sh|py|toml|css|go|sql|rs|rb|java|kt|swift|c|h|cpp|hpp|graphql|proto)$/;
 
 export interface CitedReviewSymbol {
   hash: string;
@@ -18,6 +20,57 @@ export interface ReviewFindingKeyOverlap {
   overlapRatio: number | undefined;
 }
 
+export type CitedReviewPathStatus = 'present' | 'missing' | 'unreadable';
+
+export interface ReviewFindingPathHeadCheck {
+  head: string;
+  status: 'verified' | 'path-missing' | 'unreadable' | 'no-cited-path';
+  paths: Array<{ path: string; status: CitedReviewPathStatus }>;
+}
+
+/** Only file-shaped citations are checked; symbols such as `terminal.id` are not paths. */
+export function citedReviewPaths(finding: string): string[] {
+  return [...new Set(fullCitedReviewSymbols(finding)
+    .map((symbol) => symbol.replace(/^\.\//, '').replace(/:\d+(?::\d+)?$/, ''))
+    .filter((symbol) => !symbol.startsWith('/')
+      && !symbol.includes('\\')
+      && !symbol.includes('://')
+      && /^[A-Za-z0-9_.@+/-]+$/.test(symbol)
+      && !symbol.split('/').some((part) => part === '..' || part === '')
+      && (symbol.includes('/') || CITED_PATH_EXTENSION.test(symbol))))];
+}
+
+/** Check cited paths against the supplied exact commit, never the worktree's current HEAD. */
+export function checkCitedReviewPathsAtHead(finding: string, repo: string, head: string): ReviewFindingPathHeadCheck {
+  const paths = citedReviewPaths(finding);
+  if (paths.length === 0) return { head, status: 'no-cited-path', paths: [] };
+  if (!/^[0-9a-f]{40}$/i.test(head)) {
+    return { head, status: 'unreadable', paths: paths.map((path) => ({ path, status: 'unreadable' })) };
+  }
+  const commitType = spawnSync('git', ['-C', repo, 'cat-file', '-t', head], { encoding: 'utf8' });
+  if (commitType.error || commitType.status !== 0 || commitType.stdout?.trim() !== 'commit') {
+    return { head, status: 'unreadable', paths: paths.map((path) => ({ path, status: 'unreadable' })) };
+  }
+  const checked = paths.map((path): { path: string; status: CitedReviewPathStatus } => {
+    const result = spawnSync('git', ['--literal-pathspecs', '-C', repo, 'ls-tree', '-r', '-z', '--full-tree', head, '--', path], {
+      encoding: 'utf8', maxBuffer: 1024 * 1024,
+    });
+    if (result.error || result.status !== 0) return { path, status: 'unreadable' };
+    const output = typeof result.stdout === 'string' ? result.stdout : '';
+    const present = output.split('\0').some((entry) => {
+      const separator = entry.indexOf('\t');
+      return separator >= 0 && entry.slice(separator + 1) === path;
+    });
+    return { path, status: present ? 'present' : 'missing' };
+  });
+  return {
+    head,
+    status: checked.some(({ status }) => status === 'unreadable') ? 'unreadable'
+      : checked.some(({ status }) => status === 'missing') ? 'path-missing' : 'verified',
+    paths: checked,
+  };
+}
+
 interface ReviewFindingKey {
   key: string;
   source: 'symbol' | 'prose';