elanous 0.2.29 → 0.2.32

package/src/ad-pipeline/run.ts

@@ -223,6 +223,8 @@ export interface AdProductionDeps {
   readonly render?: CommandRunner;
   /** Optional calibrated thresholds; omitted thresholds intentionally preserve unmeasured QC findings. */
   readonly qcThresholds?: QcThresholds;
+  /** Platform that decides whether on-screen text OCR (macOS Vision via swiftc) is planned; defaults to `process.platform`. */
+  readonly qcPlatform?: NodeJS.Platform;
 }
 
 export interface AdOutputIdentity {
@@ -828,7 +830,7 @@ async function runQc(
   captionedMasterPath?: string,
 ): Promise<QcResult | undefined> {
   if (!production?.render || !scene || !masterPath) return undefined;
-  const { measurements, unavailableTextRegions } = await measureQc(production, buildQcMeasurementPlan(scene, masterPath));
+  const { measurements, unavailableTextRegions } = await measureQc(production, buildQcMeasurementPlan(scene, masterPath, production.qcPlatform ?? process.platform));
   if (unavailableTextRegions !== undefined) {
     debug.log('ad-pipeline.qc', 'text-regions-unavailable', { reason: unavailableTextRegions });
   }
@@ -851,7 +853,7 @@ async function runQc(
     debug.log('ad-pipeline.qc', 'captioned-master-absent', { reason: !captionedMasterPath ? 'captioned-master-unavailable' : 'no-caption-lines' });
     return baseResult;
   }
-  const captionedPlan = buildQcMeasurementPlan(scene, captionedMasterPath, process.platform, {
+  const captionedPlan = buildQcMeasurementPlan(scene, captionedMasterPath, production.qcPlatform ?? process.platform, {
     textFrameAtSeconds: (line.startMs + line.endMs) / 2000,
   });
   const captionedMeasurement = await measureQc(production, captionedPlan, (step) => step === 'probe' || step.startsWith('text-'));

package/src/agent/runner.ts

@@ -13,6 +13,9 @@
 // generator terminates instead of hanging.
 
 import {
+  inferProviderFromModel,
+  isModelCompatible,
+  resolveDefaultProvider,
   streamLLMWithTools,
   type LLMMessage,
   type LLMToolSpec,
@@ -20,6 +23,7 @@ import {
 import { debug } from '../debug/log.js';
 import { buildUniversalPreamble } from '../prompt-library/universal-preamble.js';
 import { getModelFamily } from '../models/prompts.js';
+import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import type {
   AgentDefinition, AgentEvent, AgentSpawnOpts, AgentTask,
 } from './types.js';
@@ -57,6 +61,151 @@ class AsyncEventQueue<T> {
   }
 }
 
+// ── Model resolution (TUI-AGENT-MODEL-FALLBACK · 결함 #34) ──
+//
+// A definition's frontmatter `model:` is a REQUEST, not a guarantee. The
+// runner must check it against the provider the child will actually run
+// on BEFORE handing it to streamLLMWithTools — a codex parent used to
+// request `haiku` verbatim and die (the provider chain re-routed the
+// Claude-family id to Anthropic, 결함 #34, 2026-10-14).
+//
+// `model: undefined` in the result means "inherit the parent": the child
+// then rides streamLLMWithTools's own provider decision
+// (`opts.provider ?? resolveDefaultProvider(opts.model)`), exactly like a
+// spawn with no model hint at all.
+
+/** Why resolveAgentModel returned the model it did. Six distinct exits —
+ *  never collapse them into one value: "fell back to parent" and "sent an
+ *  unrecognized id verbatim" must stay separable in the logs. */
+export type AgentModelResolutionReason =
+  | 'no-definition-model'
+  | 'declared-inherit'
+  | 'definition'
+  | 'incompatible-provider'
+  | 'unknown-model'
+  | 'provider-unknown';
+
+export interface AgentModelResolution {
+  /** Canonical model id; undefined = inherit the parent's model. */
+  model: string | undefined;
+  reason: AgentModelResolutionReason;
+}
+
+/** Injection seams so tests can pin the provider / inference without
+ *  touching user config. Defaults are the production functions. */
+export interface ResolveAgentModelDeps {
+  currentProviderName: () => string;
+  isCompatible: (providerName: string, model: string) => boolean;
+  inferProvider: (model: string) => string | null;
+}
+
+/** Production `currentProviderName` — the provider a model-less spawn
+ *  would run on right now (the parent-configured default). A lookup
+ *  failure is NOT hidden behind a made-up name: it throws, and
+ *  resolveAgentModel turns it into the separate `provider-unknown` exit
+ *  (judging compatibility against a fake name like 'auto' would drop a
+ *  usable definition model to inherit). */
+function productionCurrentProviderName(): string {
+  return resolveDefaultProvider().name;
+}
+
+const defaultResolveAgentModelDeps: ResolveAgentModelDeps = {
+  currentProviderName: productionCurrentProviderName,
+  isCompatible: isModelCompatible,
+  inferProvider: inferProviderFromModel,
+};
+
+/** Resolve a definition model against the provider the child would run
+ *  on RIGHT NOW. Decision order — each step guards the next:
+ *    1. no model → { undefined, 'no-definition-model' }
+ *    2. `inherit` (trimmed, case-insensitive; an inheritance MARKER, not
+ *       a model name) → { undefined, 'declared-inherit' }
+ *    3. resolveModelAlias → canonical id
+ *    4. inferProvider(canonical) === null → { canonical, 'unknown-model' }
+ *       — do NOT fall back: free-form names ride the provider as-is
+ *       (isModelCompatible's "unknown prefix is the provider's problem"
+ *       stance; dropping a local free-form name to inherit is a regression)
+ *    5. isCompatible(currentProviderName, canonical)
+ *       true  → { canonical, 'definition' }
+ *       false → { undefined, 'incompatible-provider' } (parent fallback)
+ *       currentProviderName throws → { undefined, 'provider-unknown' } —
+ *       compatibility cannot be judged, so the definition model is NOT
+ *       sent (sending it could re-route the provider by model name); the
+ *       child inherits the parent model — the goal's «can't call it →
+ *       parent model» intent, kept as its own reason so a lookup failure
+ *       is never confused with a real incompatibility
+ *
+ *  Inference (4) runs BEFORE compatibility (5) because isModelCompatible
+ *  returns true on null inference — checking compatibility first would
+ *  mislabel every unknown model as compatible and the unknown-model exit
+ *  would be unreachable. */
+export function resolveAgentModel(
+  defModel: string | undefined,
+  deps: Partial<ResolveAgentModelDeps> = {},
+): AgentModelResolution {
+  const d: ResolveAgentModelDeps = { ...defaultResolveAgentModelDeps, ...deps };
+  if (defModel === undefined || defModel.trim() === '') {
+    return { model: undefined, reason: 'no-definition-model' };
+  }
+  const trimmed = defModel.trim();
+  if (trimmed.toLowerCase() === 'inherit') {
+    return { model: undefined, reason: 'declared-inherit' };
+  }
+  const canonical = resolveModelAlias(trimmed) ?? trimmed;
+  if (d.inferProvider(canonical) === null) {
+    return { model: canonical, reason: 'unknown-model' };
+  }
+  let providerName: string;
+  try {
+    providerName = d.currentProviderName();
+  } catch {
+    return { model: undefined, reason: 'provider-unknown' };
+  }
+  if (d.isCompatible(providerName, canonical)) {
+    return { model: canonical, reason: 'definition' };
+  }
+  return { model: undefined, reason: 'incompatible-provider' };
+}
+
+/** Resolve + record exactly one `agent.model` observation. Every runtime
+ *  resolution goes through here (runAgent ⊕ a direct buildAgentMessages call
+ *  without a pre-resolved `model`) so «one observation per resolution» holds
+ *  on both paths. incompatible-provider (parent fallback), unknown-model
+ *  (verbatim pass-through of an unrecognizable id) and provider-unknown
+ *  (provider lookup failed, inherited the parent unjudged) are the exits an
+ *  operator must tell apart from a log line alone — they get warn level. */
+function resolveAgentModelObserved(
+  def: Pick<AgentDefinition, 'name' | 'model'>,
+  pinnedProviderName?: string,
+): AgentModelResolution {
+  let providerError: string | undefined;
+  let currentProviderName: string | undefined = pinnedProviderName;
+  const resolution = resolveAgentModel(def.model, {
+    currentProviderName: () => {
+      if (currentProviderName !== undefined) return currentProviderName;
+      try {
+        currentProviderName = productionCurrentProviderName();
+        return currentProviderName;
+      } catch (error) {
+        providerError = error instanceof Error ? error.message : String(error);
+        throw error;
+      }
+    },
+  });
+  debug.log('agent.model', 'resolved', {
+    agent: def.name,
+    declared: def.model,
+    model: resolution.model,
+    reason: resolution.reason,
+    provider: currentProviderName ?? null,
+    ...(providerError !== undefined ? { providerError } : {}),
+  }, resolution.reason === 'incompatible-provider' || resolution.reason === 'unknown-model'
+    || resolution.reason === 'provider-unknown'
+    ? { level: 'warn' as const }
+    : undefined);
+  return resolution;
+}
+
 // ── Helpers ──
 
 /** Assemble the initial message history. The parent's rendered system
@@ -74,7 +223,7 @@ export function buildAgentMessages(
   def: AgentDefinition,
   prompt: string,
   systemPromptPrefix?: string,
-  ctx: { cwd?: string; enabledTools?: readonly string[] } = {},
+  ctx: { cwd?: string; enabledTools?: readonly string[]; model?: string } = {},
 ): LLMMessage[] {
   let effectivePrefix: string | undefined = systemPromptPrefix;
   if (def.omitInheritedContext) {
@@ -108,7 +257,15 @@ export function buildAgentMessages(
   // omitInheritedContext contract stable we honor it strictly.
   let universalPreamble: LLMMessage[] = [];
   if (!def.omitInheritedContext && ctx.cwd) {
-    const agentModelFamily = def.model ? getModelFamily(def.model) : undefined;
+    // TUI-AGENT-MODEL-FALLBACK: the preamble's modelFamily must track the
+    // model the run will actually use. runAgent passes the already-resolved
+    // model (one resolution + one `agent.model` observation per spawn);
+    // direct callers that omit `model` resolve here so a definition model
+    // the current provider can't run never reaches the preamble either.
+    const effectiveModel = 'model' in ctx
+      ? ctx.model
+      : resolveAgentModelObserved(def).model;
+    const agentModelFamily = effectiveModel ? getModelFamily(effectiveModel) : undefined;
     universalPreamble = buildUniversalPreamble({
       cwd: ctx.cwd,
       ...(agentModelFamily !== undefined ? { modelFamily: agentModelFamily } : {}),
@@ -206,6 +363,14 @@ export async function* runAgent(
   // `Agent` → search-vs-spawn split, `TaskCreate` → don't batch).
   const tools = filterAgentTools(opts.tools, task.definition.tools);
 
+  // TUI-AGENT-MODEL-FALLBACK (결함 #34): resolve the definition model
+  // against the provider the child will ACTUALLY run on — the pinned
+  // `opts.provider` when the dispatcher chose one, otherwise the
+  // parent-configured default (what streamLLMWithTools picks for a
+  // model-less spawn). `model: undefined` = inherit: the child then takes
+  // the same provider/model decision path as the parent.
+  const modelResolution = resolveAgentModelObserved(task.definition, opts.provider?.name);
+
   // Build history on the task so callers can inspect it after the run.
   // PFC-S1 P5: pass task.cwd so the slim-context notice (when
   // omitInheritedContext) can name the child's working directory.
@@ -214,6 +379,7 @@ export async function* runAgent(
     task.prompt,
     opts.systemPromptPrefix,
     {
+      model: modelResolution.model,
       ...(task.cwd ? { cwd: task.cwd } : {}),
       ...(tools ? { enabledTools: tools.map(t => t.name) } : {}),
     },
@@ -252,7 +418,7 @@ export async function* runAgent(
       dispatchTool,
     },
     {
-      model: task.definition.model,
+      model: modelResolution.model,
       tools,
       signal: task.controller.signal,
       provider: opts.provider,

package/src/agent/self-ambient-cache.ts

@@ -0,0 +1,156 @@
+// ── TUI 자기인지 ambient 캐시 — 턴 시작이 이벤트 루프를 막지 않게 (TUI-TYPING-LAG · 2026-10-14) ──
+//
+// 실측(격리 TUI · bun --cpu-prof): 턴마다 `elanousSelfAmbientBaseParts()`(ops 스캔·crontab·`ps`)가
+// 메인 스레드에서 동기로 돌았고, 한 턴에 «두 번»(대시보드 preamble ⊕ ACP buildTurnMessages) 돌아
+// 그 동안 키 입력이 0.4~9s 멈췄다. 이 캐시는 «요청과 무관한» 부분만 담는다:
+//   · 신선(< FRESH_MS) → 그대로 쓴다.
+//   · 오래됨(< STALE_MAX_MS) → 그대로 쓰고 워커에서 다시 잰다(다음 턴용).
+//   · 없음/너무 오래됨 → 종전대로 동기 계산(첫 턴 내용 보존). TUI 는 부팅 때 데우고 5s 주기
+//     틱(`refreshSelfAmbientCache({}, { ifOlderThanMs })` · src/dashboard/index.ts)으로 계속 데워
+//     두므로, 워커가 실패(백오프)하지 않는 한 오래 쉰 뒤 첫 턴도 이 길로 안 온다.
+// 관측 = `self-ambient.cache` (hit · stale-hit · sync · worker-refreshed · worker-failed).
+
+import { isMainThread, parentPort, workerData, Worker } from 'node:worker_threads';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { setElanousConfigDir } from '../elanous-config-dir.js';
+import { elanousSelfAmbientBaseParts } from './self-ambient.js';
+
+export const SELF_AMBIENT_FRESH_MS = 30_000;
+export const SELF_AMBIENT_STALE_MAX_MS = 10 * 60_000;
+const WORKER_TIMEOUT_MS = 60_000;
+
+interface CacheEntry { at: number; version: number; parts: string[] }
+
+export interface SelfAmbientCacheDeps {
+  now?: () => number;
+  computeSync?: () => string[];
+  computeInWorker?: (stateRoot: string | undefined, selectedRoot: string) => Promise<string[]>;
+  universeKey?: () => { stateRoot: string | undefined; selectedRoot: string };
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+const entries = new Map<string, CacheEntry>();
+/** Monotonic store sequence — orders async worker stores against synchronous ones.
+ *  A millisecond `at` clock ties within the same millisecond and let a worker's older
+ *  result overwrite a newer synchronous computation; the version never ties. */
+let storeSeq = 0;
+const inFlight = new Map<string, Promise<void>>();
+/** A failed worker is not retried (by ticks or stale turn reads) for this long; the turn path keeps
+ *  serving the stale entry, or falls back to sync once it is too old. */
+const WORKER_FAILURE_BACKOFF_MS = 60_000;
+const lastFailureAt = new Map<string, number>();
+
+function resolveDeps(deps: SelfAmbientCacheDeps): Required<SelfAmbientCacheDeps> {
+  return {
+    now: deps.now ?? Date.now,
+    computeSync: deps.computeSync ?? elanousSelfAmbientBaseParts,
+    computeInWorker: deps.computeInWorker ?? computeBasePartsInWorker,
+    universeKey: deps.universeKey ?? (() => ({ stateRoot: process.env.ELANOUS_STATE_DIR, selectedRoot: effectiveInstanceRoot() })),
+    log: deps.log ?? ((category, event, data) => debug.log(category, event, data)),
+  };
+}
+
+/** Start (or join) a background refresh. Resolves when the cache has been updated or the refresh failed.
+ *  `ifOlderThanMs` turns it into a keep-warm tick: a younger entry is left alone. */
+export function refreshSelfAmbientCache(deps: SelfAmbientCacheDeps = {}, opts: { ifOlderThanMs?: number } = {}): Promise<void> {
+  const d = resolveDeps(deps);
+  const { stateRoot, selectedRoot } = d.universeKey();
+  const key = JSON.stringify([selectedRoot, stateRoot ?? null]);
+  const cached = entries.get(key);
+  if (cached && opts.ifOlderThanMs !== undefined && d.now() - cached.at < opts.ifOlderThanMs) return Promise.resolve();
+  if (d.now() - (lastFailureAt.get(key) ?? -Infinity) < WORKER_FAILURE_BACKOFF_MS) return Promise.resolve();
+  const running = inFlight.get(key);
+  if (running) return running;
+  const startedAt = d.now();
+  const startedVersion = storeSeq;
+  // A worker that fails to even start (sync throw) is the same fail-soft failure as one that rejects.
+  let started: Promise<string[]>;
+  try { started = d.computeInWorker(stateRoot, selectedRoot); }
+  catch (error) { started = Promise.reject(error); }
+  const refresh = started
+    .then((parts) => {
+      // A newer entry (e.g. a synchronous first-turn computation that overlapped this worker) is kept.
+      // Judged by the monotonic store version, not the millisecond clock: a store that landed in the
+      // same millisecond as this worker's start is still newer.
+      const current = entries.get(key);
+      if (current && current.version > startedVersion) return;
+      entries.set(key, { at: startedAt, version: ++storeSeq, parts });
+      d.log('self-ambient.cache', 'worker-refreshed', { ms: d.now() - startedAt, parts: parts.length });
+    }, (error: unknown) => {
+      lastFailureAt.set(key, d.now());
+      d.log('self-ambient.cache', 'worker-failed', { ms: d.now() - startedAt, reason: error instanceof Error ? error.message : String(error) });
+    })
+    .finally(() => { inFlight.delete(key); });
+  inFlight.set(key, refresh);
+  return refresh;
+}
+
+/** Request-independent ambient parts for the TUI turn preamble, served from the cache when possible. */
+export function cachedSelfAmbientBaseParts(deps: SelfAmbientCacheDeps = {}): string[] {
+  const d = resolveDeps(deps);
+  const { stateRoot, selectedRoot } = d.universeKey();
+  const key = JSON.stringify([selectedRoot, stateRoot ?? null]);
+  const at = d.now();
+  const cached = entries.get(key);
+  const ageMs = cached ? at - cached.at : null;
+  if (cached && ageMs! < SELF_AMBIENT_FRESH_MS) {
+    d.log('self-ambient.cache', 'hit', { ageMs });
+    return [...cached.parts];
+  }
+  if (cached && ageMs! < SELF_AMBIENT_STALE_MAX_MS) {
+    d.log('self-ambient.cache', 'stale-hit', { ageMs });
+    void refreshSelfAmbientCache(deps);
+    return [...cached.parts];
+  }
+  const parts = d.computeSync();
+  entries.set(key, { at, version: ++storeSeq, parts });
+  d.log('self-ambient.cache', 'sync', { ms: d.now() - at, ageMs, parts: parts.length });
+  return [...parts];
+}
+
+export function _resetSelfAmbientCacheForTest(): void {
+  storeSeq = 0;
+  entries.clear();
+  inFlight.clear();
+  lastFailureAt.clear();
+}
+
+function computeBasePartsInWorker(stateRoot: string | undefined, selectedRoot: string): Promise<string[]> {
+  const worker = new Worker(new URL(import.meta.url), { workerData: { kind: 'self-ambient' } });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => finish(new Error(`self-ambient worker timed out after ${WORKER_TIMEOUT_MS}ms`)), WORKER_TIMEOUT_MS);
+    // A background warm-up must never keep a finished CLI or test process alive.
+    timeout.unref?.();
+    worker.unref?.();
+    const finish = (error?: Error, parts?: string[]): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      void worker.terminate();
+      if (error) reject(error);
+      else resolve(parts!);
+    };
+    worker.on('message', (message: { parts?: string[]; error?: string }) => {
+      if (message.error) finish(new Error(message.error));
+      else if (message.parts) finish(undefined, message.parts);
+    });
+    worker.on('error', error => finish(error instanceof Error ? error : new Error(String(error))));
+    worker.on('exit', code => { if (!settled) finish(new Error(`self-ambient worker exited before answering: ${code}`)); });
+    // Pin the caller's universe: a programmatic config override is not inherited by workers.
+    worker.postMessage({ stateRoot, selectedRoot });
+  });
+}
+
+const selfAmbientWorkerPort = parentPort;
+if (!isMainThread && selfAmbientWorkerPort && workerData?.kind === 'self-ambient') {
+  selfAmbientWorkerPort.on('message', ({ stateRoot, selectedRoot }: { stateRoot?: string; selectedRoot: string }) => {
+    try {
+      if (stateRoot === undefined) delete process.env.ELANOUS_STATE_DIR;
+      else process.env.ELANOUS_STATE_DIR = stateRoot;
+      setElanousConfigDir(selectedRoot);
+      selfAmbientWorkerPort.postMessage({ parts: elanousSelfAmbientBaseParts() });
+    } catch (error) { selfAmbientWorkerPort.postMessage({ error: error instanceof Error ? error.message : String(error) }); }
+  });
+}

package/src/agent/self-ambient.ts

@@ -184,11 +184,18 @@ export function investigationRecallAmbient(taskText: string): string {
 /** 자기인지 ambient — 최근 자기 구현/변경 + 최근 자율행동 + 자율 시스템 이상 + 미션 사건 사실
  *  (+ taskText 주면 조사문맥 관련 회상·축B). 매 턴 fresh · 각각 fail-soft(없음이면 빈 문자열). */
 export function elanousSelfAmbientParts(taskText?: string): string[] {
+  const parts = elanousSelfAmbientBaseParts();
+  if (taskText) { try { parts.push(investigationRecallAmbient(taskText)); } catch { /* fail-soft */ } }
+  return parts.filter(Boolean);
+}
+
+/** The request-independent ambient parts (store scans · `ps` · crontab). Split out so the
+ *  TUI can compute them off its event loop (`self-ambient-cache.ts`). */
+export function elanousSelfAmbientBaseParts(): string[] {
   const parts: string[] = [];
   try { parts.push(recentSelfChangesContext()); } catch { /* fail-soft */ }
   try { parts.push(recentAutonomyContext()); } catch { /* fail-soft */ }
   try { parts.push(opsHealthContext()); } catch { /* fail-soft */ }
   try { parts.push(missionIncidentAmbient()); } catch { /* fail-soft */ }
-  if (taskText) { try { parts.push(investigationRecallAmbient(taskText)); } catch { /* fail-soft */ } }
   return parts.filter(Boolean);
 }

package/src/agent/subagent-callable.ts

@@ -132,7 +132,7 @@ export function createGlobalSubagentCallable(
     const done = drainToResult(handle.events, () => ({
       durationMs: Date.now() - startedAt,
       modelId: effectiveDefinition.model,
-    }));
+    }), () => handle.task.controller?.signal.aborted ?? (signal?.aborted === true));
 
     return { address, done };
   };
@@ -154,6 +154,7 @@ async function drainToResult(
     unknown
   >,
   closing: () => { durationMs: number; modelId?: string },
+  signalAborted: () => boolean,
 ): Promise<{
   status: 'completed' | 'failed' | 'cancelled';
   output: string;
@@ -190,7 +191,7 @@ async function drainToResult(
 
   const close = closing();
   const baseModel = close.modelId ? { modelId: close.modelId } : {};
-  if (aborted) {
+  if (aborted || signalAborted()) {
     return { status: 'cancelled', output: accumulated, durationMs: close.durationMs, ...baseModel };
   }
   if (errorMsg !== null) {

package/src/agent/task-notification.ts

@@ -113,6 +113,11 @@ export class TaskNotificationQueue {
     return this.queue.length;
   }
 
+  /** Is this task's notification still queued (not yet drained into a turn)? */
+  has(taskId: string): boolean {
+    return this.queue.some((n) => n.taskId === taskId);
+  }
+
   /** Forget everything — tests use this for isolation. Listeners are
    *  preserved: clear() empties queue + seen, not the wake wiring. */
   clear(): void {

package/src/agent-mission/review-loop.ts

@@ -361,9 +361,12 @@ export function extractAppliedReviewItems(comments: readonly NonNullable<LatestR
 /** 브랜치의 열린 PR 코멘트에서 이전 self-dev 반영분을 fail-soft로 읽는다. */
 export function fetchAppliedReviewItemsForBranch(branch: string, runGh: (args: string[]) => string = gh): AppliedReviewItems {
   try {
-    const raw = runGh(['pr', 'view', branch, '--json', 'comments']);
-    const source = JSON.parse(raw) as LatestReviewSource;
-    const signals = filterReviewSignals(source);
+    // A Pod repair uses the synthetic worktree base `pr-N`; GitHub knows that
+    // source by PR number, not by the synthetic branch name.
+    const source = /^pr[:-]([1-9]\d*)$/.exec(branch)?.[1] ?? branch;
+    const raw = runGh(['pr', 'view', source, '--json', 'comments']);
+    const reviewSource = JSON.parse(raw) as LatestReviewSource;
+    const signals = filterReviewSignals(reviewSource);
     return { basePrLocated: true, ...analyzeAppliedReviewItems(signals.selfAuthoredComments) };
   } catch {
     return { basePrLocated: false, items: [], headlineComments: 0 };

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

@@ -85,6 +85,18 @@ export interface AcpImplementerResult {
 
 const OBS = 'agent-substrate.acp-implementer';
 
+/** Claude ACP's default preset imports user/project plugins and MCP servers into every
+ * prompt snapshot. The implementation child only needs the built-in coding tools. */
+export const CLAUDE_IMPLEMENTER_META = {
+  claudeCode: { options: {
+    tools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'],
+    settingSources: [],
+    plugins: [],
+    mcpServers: {},
+    strictMcpConfig: true,
+  } },
+} as const;
+
 export function makeAcpImplementer(opts: AcpImplementerOpts): (prompt: string) => Promise<AcpImplementerResult> {
   return async (prompt) => {
     const spawn = subscriptionReviewerSpawn(opts.spec ?? { provider: 'claude-acp' }, opts.env ?? process.env, opts.proxyBaseUrl);
@@ -119,10 +131,10 @@ export function makeAcpImplementer(opts: AcpImplementerOpts): (prompt: string) =
       await withinHandshake(agent.start());
       let sid: string;
       if (opts.resumeSessionId) {
-        await withinHandshake(agent.loadSession({ sessionId: opts.resumeSessionId, cwd: opts.worktree }));
+        await withinHandshake(agent.loadSession({ sessionId: opts.resumeSessionId, cwd: opts.worktree, _meta: CLAUDE_IMPLEMENTER_META }));
         sid = opts.resumeSessionId;
       } else {
-        sid = await withinHandshake(agent.newSession());
+        sid = await withinHandshake(agent.newSession(CLAUDE_IMPLEMENTER_META));
       }
       if (opts.model) await withinHandshake(agent.selectSessionModel(sid, opts.model));
       debug.log(OBS, 'start', { cwd: opts.worktree, model: opts.model ?? '(default)', resumed: Boolean(opts.resumeSessionId) });

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

@@ -652,6 +652,17 @@ export function buildReviewPrompt(
  *  `none of the tests …`. 표지 낱말로 시작하는 실제 블로커를 지우면 PASS/WARN 리뷰에서 블로커가 사라진다. */
 const NONE_WORD = String.raw`(?:없음|해당\s*없음|n\/a|none|nothing)`;
 const BARE_SENTINEL = new RegExp(String.raw`^${NONE_WORD}\s*[.。]?$`, 'i');
+// GLM 은 비어 있는 mustFix 항목이나 괄호 안의 한 문장으로 무소견을 적는다.
+// 괄호 전체만 검사한다. 중간에 "no blockers" 가 있어도 뒤에 지적이 이어지면 버리지 않는다.
+const BRACKETED_PLACEHOLDER = /^[（(]\s*([\s\S]*?)\s*[）)]$/;
+const PLACEHOLDER_ONLY = /^(?:없음|해당\s*없음|none|n\/a|no\s+blockers?)$/i;
+const PLACEHOLDER_END = /(?:블로커|차단)(?:\s*(?:수준의?\s*)?(?:결함|문제|이슈|지적))?\s*없음$|no\s+blockers?$/i;
+function isBracketedPlaceholder(text: string): boolean {
+  const bracketed = BRACKETED_PLACEHOLDER.exec(text);
+  if (!bracketed) return false;
+  const inside = bracketed[1]!.trim().replace(/(?:\s*(?:…|\.{2,}|[.。]))+\s*$/, '').trim();
+  return PLACEHOLDER_ONLY.test(inside) || PLACEHOLDER_END.test(inside);
+}
 const DASH_ONLY_SENTINEL = /^[([（【]\s*[-—–]\s*[)\]）】]$/;
 // 목록 항목의 바깥 `- `와 별개로, 리뷰어가 괄호 안에도 장식 대시를 둘 수 있다: `- (- 없음 -)`.
 const DASH_WRAPPED_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*(?:[-—–]+\s*)?[)\]）】]$`, 'i');
@@ -659,6 +670,8 @@ const BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}(?:\s
 // ⭐ 설명 «전체»가 「지적 없음」 한 문장일 때만 — 일부만 맞아도 접으면 `(none: no blockers are checked because …)` 같은 지적이 사라진다.
 const NO_FINDING_REMARK = new RegExp([
   String.raw`^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$`,
+  // REVIEW-MUSTFIX-NONE-PARSE — `(없음 — 이 조각 범위에서는 차단 결함 없음)` 꼬리.
+  String.raw`^(?:이\s*)?(?:조각\s*)?범위(?:에서는|에서|엔)?\s*(?:블로커|차단)(?:\s*(?:수준의?\s*)?(?:결함|문제|이슈|지적))?\s*없(?:음|다|습니다)[.。]?$`,
   String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|issues?|problems?|findings?|must-?fix(?:es)?)(?:\s+found)?\.?$`,
   String.raw`^nothing\s+(?:blocking|to\s+fix)\.?$`,
   // REVIEW-MUSTFIX-NONE-SENTINEL — `(없음 — 수용기준 충족)` · `(none — acceptance criteria met)` (GLM 실측 6건). «미충족» 은 ^ 앵커로 안 맞는다.
@@ -685,6 +698,7 @@ function isLongNoFindingBracket(text: string): boolean {
  *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
+  if (!text || isBracketedPlaceholder(text)) return true;
   if (/^[-—–]+$/.test(text)) return true;
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
   if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;

package/src/agent-substrate/self-review-cli.ts

@@ -1125,6 +1125,24 @@ function roleAcpErrorReason(error: unknown): 'acp-handshake-timeout' | 'acp-erro
 
 type AcpFallbackSkip = { backend: string; reason: string };
 
+function validateReviewDenyBackends(value: unknown, now: number): string[] | null {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) return null;
+  const denied: string[] = [];
+  for (const entry of value) {
+    if (typeof entry === 'string' && entry.trim()) { denied.push(entry); continue; }
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+    const item = entry as Record<string, unknown>;
+    if (Object.keys(item).some((key) => key !== 'backend' && key !== 'expiresAt')
+      || typeof item.backend !== 'string' || !item.backend.trim()
+      || typeof item.expiresAt !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?Z$/.test(item.expiresAt)
+      || !Number.isFinite(Date.parse(item.expiresAt)) || new Date(item.expiresAt).toISOString().slice(0, 19) !== item.expiresAt.slice(0, 19)
+      || Date.parse(item.expiresAt) <= now) return null;
+    denied.push(item.backend);
+  }
+  return denied;
+}
+
 function orderedAcpReviewFallbackBackends(configuredBackend: string | undefined, denyBackends: readonly string[] = []): {
   backends: string[];
   skipped: AcpFallbackSkip[];
@@ -1294,10 +1312,17 @@ async function runSelfReviewCliCommandPinned(
   const acpBackend = acpBackendResolution.backend;
   const requestedModel = opts.model?.trim() || undefined;
   const rawReviewDenyBackends = (getUserConfig().raw?.acp as { reviewDenyBackends?: unknown } | undefined)?.reviewDenyBackends;
-  const configuredReviewDenyBackends = Array.isArray(rawReviewDenyBackends)
-    ? rawReviewDenyBackends.filter((backend): backend is string => typeof backend === 'string')
-    : [];
-  const automaticFallbacks = orderedAcpReviewFallbackBackends(opts.configuredAcpBackend, opts.reviewDenyBackends ?? configuredReviewDenyBackends);
+  const denyCheckedAt = Date.now();
+  const configuredReviewDenyBackends = validateReviewDenyBackends(rawReviewDenyBackends, denyCheckedAt);
+  const reviewDenyBackends = validateReviewDenyBackends(opts.reviewDenyBackends, denyCheckedAt);
+  if (configuredReviewDenyBackends === null || reviewDenyBackends === null) {
+    const message = 'acp.reviewDenyBackends 설정이 유효하지 않거나 만료됐습니다 — 리뷰를 실행하지 않습니다.';
+    deps.log('review-deny-invalid', { reason: 'invalid-or-expired-review-deny-backends' }, { level: 'warn' });
+    deps.error(message);
+    return { results: opts.json ? [{ error: message }] : [], failed: 1 };
+  }
+  const automaticFallbacks = orderedAcpReviewFallbackBackends(opts.configuredAcpBackend,
+    opts.reviewDenyBackends === undefined ? configuredReviewDenyBackends : reviewDenyBackends);
   const fallbackAcpBackends = opts.acpBackend
     ? [canonicalizeBackendId(opts.acpBackend)]
     : automaticFallbacks.backends;
@@ -1632,6 +1657,7 @@ async function runSelfReviewCliCommandPinned(
     const reviewProvenance = {
       reviewRoute,
       fallbackAttempted,
+      ...(requestedModel ? { requestedModel } : {}),
       ...(fallbackBackend ? { fallbackBackend } : {}),
       ...(fallbackBackend ? { requestedModel: primaryModel, actualBackend: `acp:${fallbackBackend}` } : {}),
       ...(fallbackNotAttemptedReason ? { fallbackNotAttemptedReason } : {}),