elanous 0.2.19 → 0.2.21

package/src/seat-loop/op-decide.ts

@@ -0,0 +1,173 @@
+// OP-LOOP-DECIDE — the OP seat loop filters open decision cards instead of a Claude OP session doing it by hand.
+// Delegation = 대표 10-06 COO card filtering rule (feedback_coo_filters_decision_cards) ⊕ 10-07 scope-card default b.
+// Config `loops.seat.opDecide.mode` = shadow (default · record only) | live (decide / route).
+import { debug } from '../debug/log.js';
+import type { DecisionEntry, DecisionLedger } from '../decisions/decision-ledger.js';
+import type { SeatId } from '../seat-dispatch/seat-questions.js';
+import { releasePathHold } from '../self-dev/release-path-guard.js';
+
+export type OpDecideMode = 'shadow' | 'live';
+export type OpDecideRule = 'repeat-stop' | 'scope-expand' | 'scope-sensitive' | 'scope-release-path' | 'scope-unknown' | 'run-blocking' | 'forbidden';
+export type OpDecideVerdict =
+  | { verdict: 'auto'; rule: OpDecideRule; choice: string; reason: string }
+  | { verdict: 'route'; rule: OpDecideRule; to: SeatId | 'CEO'; reason: string };
+export type OpDecideCandidate = { kind: 'decision-filter'; id: string; mode: OpDecideMode } & OpDecideVerdict;
+
+export const OP_DECIDE_AGENT = 'seat-loop:OP';
+export const OP_DECIDE_DELEGATION = '대표 10-06 COO 카드 거르기 규칙 · 10-07 범위 카드 기본 b(돈·보안·비밀·공개 경로만 유지)';
+
+/** Categories that must reach the CEO whatever the recommendation says (rule 3). */
+const FORBIDDEN_CATEGORIES: ReadonlySet<DecisionEntry['category']> = new Set(['money', 'security', 'secret', 'publish']);
+const FORBIDDEN_WORDS = /특허|patent|외부\s*계약|계약서|contract/i;
+
+/** Path segments that keep a scope card open — money · security · secret · public (rule 2 exception). */
+const SENSITIVE_PATH: ReadonlyArray<{ kind: 'money' | 'security' | 'secret' | 'public'; pattern: RegExp }> = [
+  { kind: 'secret', pattern: /(^|[/._-])(secrets?|credentials?|\.env|keychain|apns|backup-key)([/._-]|$)|\.(pem|p8|p12|key)$/i },
+  { kind: 'security', pattern: /(^|[/._-])(auth|oauth|security|sandbox|permissions?|acl|csp|tokens?|crypto)([/._-]|$)/i },
+  { kind: 'money', pattern: /(^|[/._-])(money|finance|billing|payments?|payouts?|refunds?|revenue|pricing|stripe|invoices?|checkout|wallet|trad(e|ing)|broker|budget|quota)([/._-]|$)/i },
+  { kind: 'public', pattern: /(^|\/)(README|CHANGELOG|LICENSE|NOTICE)(\.[a-z]+)?$|(^|[/._-])(publish|public|homepage|site|npm)([/._-]|$)|^\.github\/workflows\/|^scripts\/release-loop\/release-publish/i },
+];
+
+export function sensitivePathKind(file: string): 'money' | 'security' | 'secret' | 'public' | undefined {
+  return SENSITIVE_PATH.find(({ pattern }) => pattern.test(file))?.kind;
+}
+
+const SCOPE_QUESTION = /outside the authored target paths/i;
+
+/** Outside-file names listed on a harness scope card; undefined when the card carries no complete list. */
+export function scopeOutsideFiles(card: Pick<DecisionEntry, 'pendingQuestion'>): string[] | undefined {
+  const text = card.pendingQuestion ?? '';
+  const at = text.indexOf('Outside files:');
+  if (at < 0) return undefined;
+  // «… N more outside file(s) not shown» anywhere after the list header — a hidden file cannot be vetted.
+  if (/more outside file/i.test(text.slice(at))) return undefined;
+  const lines = text.slice(at + 'Outside files:'.length).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const files: string[] = [];
+  for (const line of lines) {
+    if (!line.startsWith('- ')) break;
+    // «… N more outside file(s) not shown» — a hidden file cannot be vetted.
+    if (/more outside file/i.test(line)) return undefined;
+    const name = line.slice(2).replace(/\s+\(declared-path sibling test: [a-z]+\)$/, '').trim();
+    if (name) files.push(name);
+  }
+  return files.length ? files : undefined;
+}
+
+function optionKey(card: DecisionEntry, label: RegExp): string | undefined {
+  return card.options.find((option) => label.test(option.label))?.key;
+}
+
+export function isRepeatStopCard(card: DecisionEntry): boolean {
+  return card.raisedBy.agent === 'seat-loop' && / 반복 착지 0$/.test(card.title);
+}
+
+export function isScopeCard(card: DecisionEntry): boolean {
+  return card.raisedBy.agent === 'harness' && (card.category === 'scope' || card.category === 'irreversible')
+    && SCOPE_QUESTION.test(`${card.title}\n${card.pendingQuestion ?? ''}`) && !!card.resume;
+}
+
+/** Judge one open card. undefined = not this filter's card (left alone). */
+export function judgeOpDecision(card: DecisionEntry, runOwner: (runId: string) => SeatId | undefined = () => undefined): OpDecideVerdict | undefined {
+  if (card.status !== 'open') return undefined;
+  const repeat = isRepeatStopCard(card);
+  const scope = isScopeCard(card);
+  const runId = card.resume?.runId;
+  if (!repeat && !scope && !runId) return undefined;
+  if (FORBIDDEN_CATEGORIES.has(card.category) || FORBIDDEN_WORDS.test(`${card.title}\n${card.scqa.s}`)) {
+    return { verdict: 'route', rule: 'forbidden', to: 'CEO', reason: `${card.category} 범주·금지 낱말 — 자동 결정 금지, 대표 카드로 남김` };
+  }
+  if (repeat) {
+    const stop = optionKey(card, /^멈춘다$/);
+    const recommended = 'option' in card.recommendation ? card.recommendation.option : undefined;
+    if (stop && recommended === stop) {
+      return { verdict: 'auto', rule: 'repeat-stop', choice: stop, reason: `반복 착지 0 — 권고 ${stop}(멈춘다) · 그냥 둔 것과 같은 결과` };
+    }
+    return { verdict: 'route', rule: 'repeat-stop', to: 'CEO', reason: '반복 정지 카드인데 권고가 «멈춘다»가 아님 — 확신 없음' };
+  }
+  if (scope) {
+    const expand = optionKey(card, /^Expand scope$/i);
+    const files = scopeOutsideFiles(card);
+    const owner = runId ? runOwner(runId) : undefined;
+    const route = (rule: OpDecideRule, reason: string): OpDecideVerdict =>
+      ({ verdict: 'route', rule, to: owner && owner !== 'OP' ? owner : 'CEO', reason });
+    if (!expand) return route('scope-unknown', '범위 카드에 «Expand scope» 선택지가 없음');
+    if (!files) return route('scope-unknown', '바깥 파일 목록이 없거나 일부만 보임 — 경로를 확인 못 함');
+    const sensitive = files.map((file) => ({ file, kind: sensitivePathKind(file) })).filter((row) => row.kind);
+    if (sensitive.length) {
+      return { verdict: 'route', rule: 'scope-sensitive', to: 'CEO',
+        reason: `바깥 파일 중 ${sensitive[0]!.kind} 경로(${sensitive[0]!.file}${sensitive.length > 1 ? ` 외 ${sensitive.length - 1}` : ''}) — 유지 여부는 대표 판단` };
+    }
+    // Release/gate paths follow the release-path SSOT (src/self-dev/release-path-guard.ts) — never auto-widen; TC owns the gate.
+    // TODO(0.2.21 RELEASE-PATH-GUARD-GATE): src/task-orchestrator/surfaces/pod-command-job.ts and src/release-loop/gate-shards.ts
+    //   are gate paths not yet in RELEASE_PATH_PREFIXES; they become covered here once that list grows.
+    const release = releasePathHold(files);
+    if (release) {
+      return { verdict: 'route', rule: 'scope-release-path', to: 'TC',
+        reason: `바깥 파일 중 발행·게이트 경로(${release}) — 게이트 주인 TC 판단` };
+    }
+    return { verdict: 'auto', rule: 'scope-expand', choice: expand,
+      reason: `범위 넓힘 b — 바깥 ${files.length}개 모두 돈·보안·비밀·공개 경로 아님 · 게이트·리뷰가 가린다` };
+  }
+  const owner = runOwner(runId!);
+  return { verdict: 'route', rule: 'run-blocking', to: owner && owner !== 'OP' ? owner : 'CEO',
+    reason: owner && owner !== 'OP' ? `런 ${runId} 을 막는 카드 — 런 주인 ${owner} 자리로` : `런 ${runId} 을 막는 카드 — 주인 자리 모름, 대표 카드로 남김` };
+}
+
+export type OpDecideDeps = {
+  mode: OpDecideMode;
+  ledger: Pick<DecisionLedger, 'list' | 'decide'>;
+  runOwner?: (runId: string) => SeatId | undefined;
+  /** Route a run-blocking card to its owner seat (live only); returns false when delivery failed. */
+  routeToSeat?: (to: SeatId, card: DecisionEntry, reason: string) => boolean;
+  /** Candidates already recorded for this card (dedup across ticks). */
+  recorded?: (id: string) => readonly OpDecideCandidate[];
+  record: (candidate: OpDecideCandidate) => void;
+};
+
+/** One filtering pass over open cards. Never throws for a single card; returns what it recorded. */
+export function runOpDecide(deps: OpDecideDeps): OpDecideCandidate[] {
+  const out: OpDecideCandidate[] = [];
+  let cards: DecisionEntry[];
+  try { cards = deps.ledger.list({ status: 'open' }); }
+  catch (error) {
+    observeOpDecide({ event: 'ledger-unreadable', error: String(error).slice(0, 200) });
+    return out;
+  }
+  for (const card of cards) {
+    let judged: OpDecideVerdict | undefined;
+    try { judged = judgeOpDecision(card, deps.runOwner); }
+    catch (error) {
+      observeOpDecide({ event: 'judge-failed', id: card.id, error: String(error).slice(0, 200) });
+      continue;
+    }
+    if (!judged) continue;
+    const candidate: OpDecideCandidate = { kind: 'decision-filter', id: card.id, mode: deps.mode, ...judged };
+    const same = (row: OpDecideCandidate) => row.mode === candidate.mode && row.verdict === candidate.verdict && row.rule === candidate.rule
+      && ('to' in row ? row.to : row.choice) === ('to' in candidate ? candidate.to : candidate.choice);
+    if ((deps.recorded?.(card.id) ?? []).some(same)) continue;
+    if (deps.mode === 'live' && candidate.verdict === 'auto') {
+      try {
+        deps.ledger.decide(card.id, candidate.choice,
+          { kind: 'auto', agent: OP_DECIDE_AGENT, track: 'OP', delegation: OP_DECIDE_DELEGATION }, candidate.reason);
+      } catch (error) {
+        observeOpDecide({ event: 'decide-failed', id: card.id, rule: candidate.rule, error: String(error).slice(0, 200) });
+        continue;
+      }
+    }
+    if (deps.mode === 'live' && candidate.verdict === 'route' && candidate.to !== 'CEO' && deps.routeToSeat) {
+      let delivered = false;
+      try { delivered = deps.routeToSeat(candidate.to, card, candidate.reason); }
+      catch (error) { observeOpDecide({ event: 'route-failed', id: card.id, to: candidate.to, error: String(error).slice(0, 200) }); }
+      if (!delivered) continue;
+    }
+    deps.record(candidate);
+    out.push(candidate);
+    observeOpDecide({ event: 'op-decide', id: card.id, mode: candidate.mode, verdict: candidate.verdict, rule: candidate.rule,
+      ...(candidate.verdict === 'auto' ? { choice: candidate.choice } : { to: candidate.to }), category: card.category, reason: candidate.reason });
+  }
+  return out;
+}
+
+function observeOpDecide(data: Record<string, unknown>): void {
+  try { debug.log('seat.loop', 'op-decide', data); } catch { /* observation cannot change a decision */ }
+}

package/src/seat-loop/seat-loop.ts

@@ -26,6 +26,7 @@ import { answerCrossCheck, answerSeat, askCrossCheck, askSeat, crossCheckAnswer,
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { readSchedules, releasedVersion } from '../release-loop/feature-store.js';
+import { runOpDecide, type OpDecideCandidate } from './op-decide.js';
 
 // `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
 export type SeatItem = { source: 'request' | 'checklist' | 'hook' | 'seat-question'; kind?: 'request' | 'cell' | 'hook-task' | 'seat-question'; id: string; title: string; text: string; evidence?: string; status?: string; version?: string; seat?: string; evidenceHash?: string; asOf?: string; queuedAt?: string; createdAt?: string; from?: SeatId };
@@ -43,7 +44,7 @@ export type TcCandidate =
   | { kind: 'publication-pr-approval-wait'; pr: number; title: string; readyAt: string; approvalWaitAt: string; paths: string[] }
   | { kind: 'other-seat-cell-defect'; version: string; id: string; title: string; to: SeatId };
 export type TcPullRequest = { number: number; title: string; body?: string; state: 'OPEN' | 'MERGED' | 'CLOSED'; isDraft: boolean; createdAt: string; updatedAt?: string; mergedAt?: string | null; readyAt?: string; approvalWaitAt?: string; paths?: string[]; reviewDecision?: string };
-export type SeatEntry = { seat: string; ts?: string; at: string; modeDowngradeReason?: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'queued' | 'refused' | 'held' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'awaiting-xcheck' | 'awaiting-resolution' | 'resolved-by-neighbor' | 'resolved' | 'rejected-no-evidence' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate; action?: SeatAction; reason?: string; runId?: string; queueId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean; xcheckRequestedAt?: string; xcheckQuestionId?: number; xcheckNeighbor?: SeatId; xcheckNote?: string; xcheckJudgmentEvidence?: string; xcheckWaitMinutes?: number };
+export type SeatEntry = { seat: string; ts?: string; at: string; modeDowngradeReason?: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'queued' | 'refused' | 'held' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'awaiting-xcheck' | 'awaiting-resolution' | 'resolved-by-neighbor' | 'resolved' | 'rejected-no-evidence' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate | OpDecideCandidate; action?: SeatAction; reason?: string; runId?: string; queueId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean; xcheckRequestedAt?: string; xcheckQuestionId?: number; xcheckNeighbor?: SeatId; xcheckNote?: string; xcheckJudgmentEvidence?: string; xcheckWaitMinutes?: number };
 export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off'; modeDowngradeReason?: string };
 
 export function seatLoopTickLine(result: SeatLoopResult): string {
@@ -99,6 +100,8 @@ export type SeatDeps = {
   /** Judge a decision draft against the receiving seat's evidence; null leaves the request pending. */
   crossCheck?: (seat: SeatId, draft: string, from: SeatId) => Promise<CrossCheckJudgment | null> | CrossCheckJudgment | null;
   decisionsConfig?: UserConfig['decisions'];
+  /** OP-LOOP-DECIDE: who owns a run (for run-blocking cards). Default = today's seat ledgers' launched rows. */
+  runOwner?: (runId: string) => SeatId | undefined;
 };
 
 const repoRoot = resolve(import.meta.dir, '../..');
@@ -291,6 +294,8 @@ function personReopened(ledger: readonly SeatEntry[], seat: string, item: SeatIt
   const ref = decisionRef(seat, item);
   return new DecisionLedger({ stateDir: root }).list({ status: 'all' }).some((card) => {
     if (!card.refs?.includes(ref) || card.status !== 'decided' || !card.decidedAt) return false;
+    // «멈춘다» on a repeat-stop card keeps the cell held — only a reopen (or any other card's decision) frees it (OP-LOOP-DECIDE).
+    if (/ 반복 착지 0$/.test(card.title) && card.options.find((option) => option.key === card.choice)?.label === '멈춘다') return false;
     const decidedAt = Date.parse(card.decidedAt);
     return Number.isFinite(decidedAt) && decidedAt > heldAt;
   });
@@ -551,6 +556,40 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
   return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
 }
 
+/** OP-LOOP-DECIDE: filter open decision cards each OP turn. Shadow records; live decides/routes. A failure never blocks the turn. */
+function opDecidePass(config: SeatLoopConfig, deps: SeatDeps, now: Date, path: string, stateRoot: string, ledger: readonly SeatEntry[]): void {
+  const mode = config.opDecide?.mode === 'live' ? 'live' : 'shadow';
+  let owners: Map<string, SeatId> | undefined;
+  try {
+    const append = deps.append ?? defaultAppend;
+    const recorded = new Map<string, OpDecideCandidate[]>();
+    for (const row of ledger) {
+      if (row.candidate?.kind === 'decision-filter') recorded.set(row.candidate.id, [...(recorded.get(row.candidate.id) ?? []), row.candidate]);
+    }
+    runOpDecide({
+      mode,
+      ledger: cardLedger(stateRoot, deps, now),
+      runOwner: deps.runOwner ?? ((runId) => {
+        owners ??= new Map((['OP', 'UX', 'MK', 'TC'] as const).flatMap((owner) =>
+          readSeatLedger(owner, deps, now).filter((row) => row.runId).map((row) => [row.runId!, owner] as const)));
+        return owners.get(runId);
+      }),
+      routeToSeat: (to, card, reason) => {
+        askSeat(stateRoot, 'OP', to, `결정 카드 ${card.id} «${card.title}» — ${reason}. 런 주인이 판단해 elanous decisions decide ${card.id} 로 닫아 주세요.`,
+          `op-decide:${card.id}:${to}`);
+        return true;
+      },
+      recorded: (id) => recorded.get(id) ?? [],
+      record: (candidate) => {
+        append(path, { seat: 'OP', ts: now.toISOString(), at: now.toISOString(),
+          status: mode === 'shadow' ? 'shadow' : candidate.verdict === 'auto' ? 'resolved' : 'hitl',
+          ...(candidate.verdict === 'route' && candidate.to === 'CEO' ? { escalated: true } : {}),
+          candidate, reason: candidate.reason });
+      },
+    });
+  } catch (error) { observe('op-decide', { event: 'pass-failed', mode, error: String(error).slice(0, 200) }); }
+}
+
 const OP_CUTOFF_WINDOW_MS = 2 * 60 * 60_000;
 const RUN_REFERENCE = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
 
@@ -870,10 +909,25 @@ const SEAT_ACTION_RULES: ReadonlyArray<{ kind: 'wait' | 'harness' | 'decision';
   { kind: 'wait', signal: /실측\s*대기|(?:사람|실제)\s*기기(?!\s*(?:(?:실측|측정|확인)\s*)?완료)(?:\s*(?:실측|측정|확인|대기))?|실물\s*측정(?!\s*완료)/iu, source: 'content', resolvedBy: /(?:실측|측정|(?:사람|실제)\s*기기|실물\s*측정)\s*완료/iu },
   { kind: 'wait', signal: /\u{1F451}\s*확인\s*대기/iu, source: 'content', resolvedBy: /\u{1F451}\s*확인\s*완료/iu },
   { kind: 'decision', signal: TRACK_AGENT_FORBIDDEN_ACTION_REGEX, source: 'task' },
+  { kind: 'decision', signal: /토큰\s*(?:을|를)?\s*(?:출력|노출|공개|첨부|붙여)/iu, source: 'task' },
   { kind: 'decision', signal: /(?:마켓|레지스트리)(?:에|로)?\s*(?:게시|등록|발행)|사이트\s*운영\s*반영|SNS(?:에|로)?\s*(?:게시|발행|업로드)|공개\s*발행/iu, source: 'task' },
   { kind: 'harness', signal: /(?:마켓|레지스트리|사이트|SNS|공개)?(?:에|로)?\s*(?:게시|발행|배포|등록|운영\s*반영)(?:를?\s*위한)?\s*(?:준비|초안|원고|자료|구현|점검|테스트)|(?:마켓|레지스트리|사이트|SNS|공개)?(?:에|로)?\s*(?:게시|발행|배포|등록)(?:용|를?\s*위한)\s*(?:초안|원고|자료|코드|기능)/iu, source: 'task' },
 ];
 
+// SEAT-FORBID-NEGATION: «비밀 0» · «비밀 제외» · «no secret» name the word to exclude it, not to act on it.
+// Only a negation right next to the hit (optionally after a short noun such as 키 · 증명 and a particle) clears it;
+// «비밀 키를 붙여라» keeps its imperative and stays a decision.
+const FORBID_NEGATION = '(?:0(?![\\dx.,])|제외|없이|빼고|금지|없음|none\\b|no\\b|without\\b|excluding\\b)';
+const FORBID_NEGATION_AFTER = new RegExp(`^(?:\\s*(?:증명|정보|키|값|토큰|keys?|tokens?)(?![A-Za-z]))?\\s*(?:은|는|이|가|을|를|:)?\\s*${FORBID_NEGATION}`, 'iu');
+const FORBID_NEGATION_BEFORE = /(?:^|[\s(\[«"'·,:])(?:no|without|excluding|none|제외|금지)\s*[:·-]?\s*$/iu;
+
+export const FORBID_JUDGMENT_LINE = (word: string | undefined): string =>
+  `판정 근거: «${word ?? '?'}» 바로 앞뒤에 부정 문면(0·제외·없이·빼고·금지·없음·no·without·excluding)이 없어 실행 요청으로 봤다`;
+
+export function forbiddenHitNegated(text: string, index: number, length: number): boolean {
+  return FORBID_NEGATION_AFTER.test(text.slice(index + length)) || FORBID_NEGATION_BEFORE.test(text.slice(0, index));
+}
+
 export function planAction(item: SeatItem, seat?: string): { kind: 'decision' | 'harness' | 'wait'; text: string; reason?: string } {
   const task = `${item.id}\n${item.title}\n${item.text}`;
   const content = `${task}\n${item.evidence ?? ''}`;
@@ -884,7 +938,9 @@ export function planAction(item: SeatItem, seat?: string): { kind: 'decision' |
     if (resolvedBy?.test(item.evidence ?? '')) return null;
     const hits = [...text.matchAll(new RegExp(signal.source, `${signal.flags.replace('g', '')}g`))];
     const hit = kind === 'decision' ? hits.find((match) => !prepared.some((prep) =>
-      match.index! >= prep.index! && match.index! + match[0].length <= prep.index! + prep[0].length)) : hits[0];
+      match.index! >= prep.index! && match.index! + match[0].length <= prep.index! + prep[0].length)
+      && !(forbiddenHitNegated(text, match.index!, match[0].length)
+        && (observe('forbid-negated', { item: item.id, word: match[0] }), true))) : hits[0];
     return hit ? { kind, reason: hit[0] } : null;
   }).find((hit) => hit !== null);
   const kind = rule?.kind ?? 'harness';
@@ -1004,6 +1060,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   } catch (error) { observe('heartbeat-write-failed', { seat, error: String(error).slice(0, 200) }); }
   const recorded = readSeatLedger(seat, deps, now);
   const ledger = config.mode === 'live-safe' ? reconciledQueueLedger(recorded, stateRoot, deps) : recorded;
+  if (seat === 'OP') opDecidePass(config, deps, now, path, stateRoot, ledger);
   let turnError: unknown;
   try {
   if (config.mode === 'on' && config.questions === 'on') {
@@ -1494,7 +1551,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
             : undefined;
       } catch (error) { observe('decision-source-unreadable', { seat, item: item.id, error: String(error).slice(0, 200) }); }
       const material = decisionCardMaterial({ what: `${seat} 배정 항목: ${item.title} 역할: ${inputs.role || '역할 근거 없음'}`, soFar: `요청 내용: ${item.text}`,
-        current: `밑바탕 재측: ${currentStatus ?? '상태 미확인'}; 요청에서 금지 문면 «${action.reason}» 발견 — 실행 전 사람 승인 필요`,
+        current: `밑바탕 재측: ${currentStatus ?? '상태 미확인'}; 요청에서 금지 문면 «${action.reason}» 발견 — 실행 전 사람 승인 필요; ${FORBID_JUDGMENT_LINE(action.reason)}`,
         question: `금지 문면 «${action.reason}»이 걸린 요청을 승인할까?`, answer: '승인 전에는 집행하지 않고 보류한다',
         options, recommendation, confidence: '높음 — 요청에 금지 문면 직접 일치',
         ifUntouched: '자동 집행되지 않고 해당 칸은 보류 상태로 남는다',

package/src/seat-loop/seat-report.ts

@@ -6,6 +6,7 @@ import { promisify } from 'node:util';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { collectDraftMetrics, collectOverlapMetrics, countSalvagedToday, type DraftMetrics, type OverlapMetrics } from '../self-dev/draft-sweep.js';
 import { seatDay, seatLedgerPath, type OpCandidate, type SeatEntry } from './seat-loop.js';
 
 export type SeatReportDeps = {
@@ -16,6 +17,10 @@ export type SeatReportDeps = {
   config?: SeatLoopConfig;
   post?: boolean;
   send?: (body: string, seat: string, pr: number) => Promise<void> | void;
+  draftMetrics?: (now: Date) => Promise<DraftMetrics>;
+  overlapMetrics?: (now: Date) => Promise<OverlapMetrics>;
+  /** DRAFT-NOT-ARCHIVE salvage branches since the KST day start; null = unreadable. */
+  salvagedToday?: (dayStart: Date, now: Date) => Promise<number | null>;
 };
 export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
 const repoRoot = resolve(import.meta.dir, '../..');
@@ -36,6 +41,21 @@ function opJudgment(candidate: OpCandidate): { kind: 'card' | 'todo'; text: stri
     text: `${text} (${candidate.category ?? '범주 없음'})` };
 }
 
+/** OVERLAP-METRIC line; ⛔ an unmeasured value says so instead of printing 0. */
+function overlapLine(metrics: OverlapMetrics): string {
+  if (metrics.sourceIncomplete || metrics.launches24h === null) return ' · 겹침 발사 24h 못 잼(원천 불완전)';
+  const launched = metrics.launched === null ? '' : metrics.unmeasured
+    ? ` 이상 (발사 ${metrics.launched} 중 ${metrics.unmeasured} 못 잼)` : ` (발사 ${metrics.launched})`;
+  const rate = metrics.autoRate === null || metrics.linked === null || metrics.autoLanded === null
+    ? (metrics.linked === 0 ? '표본 없음' : '못 잼')
+    : `${(metrics.autoRate * 100).toFixed(1)}% (${metrics.autoLanded}/${metrics.linked})`;
+  const median = metrics.secondSiblingMedianHours === null ? (metrics.linked === null ? '못 잼' : '표본 없음')
+    : `${metrics.secondSiblingMedianHours.toFixed(1)}h`;
+  const salvage = (metrics.salvaged ? ` · 수확 가지 형제 ${metrics.salvaged}(미착지)` : '')
+    + (metrics.salvageUnmeasured ? ` · 수확 가지 ${metrics.salvageUnmeasured} 못 잼` : '');
+  return ` · 겹침 발사 24h ${metrics.launches24h}${launched} · 겹침 자동 착지 ${rate} · 둘째 형제 착지 중앙값 ${median}${salvage}`;
+}
+
 async function defaultSend(body: string, seat: string, pr: number, repo: string): Promise<void> {
   const dir = mkdtempSync(join(tmpdir(), 'seat-report-'));
   try {
@@ -58,8 +78,13 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
   // One line per item, its last state wins: an `attempting` row followed by `launched` is not «unconfirmed».
   const latest = new Map<string, SeatEntry>();
   const judgments = new Map<string, OpCandidate>();
+  const filtered = { auto: 0, route: 0 };
   for (const entry of entries) {
-    if (seat === 'OP' && entry.candidate) {
+    if (entry.candidate?.kind === 'decision-filter') {
+      filtered[entry.candidate.verdict] += 1;
+      continue;
+    }
+    if (seat === 'OP' && entry.candidate && 'verdict' in entry.candidate) {
       if (entry.candidate.verdict === 'none') {
         if (entry.candidate.id) {
           const key = entry.candidate.kind === 'unassigned-cell'
@@ -89,8 +114,38 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
     return `건너뜀 ${entry.status} ${label}`;
   });
   const classified = [...judgments.values()].map(opJudgment).filter((row): row is NonNullable<typeof row> => row !== null);
-  const opDetail = classified.length ? ` · 결정 카드 후보: ${classified.filter((row) => row.kind === 'card').map((row) => row.text).join(' / ') || '없음'} · OP 가 할 일: ${classified.filter((row) => row.kind === 'todo').map((row) => row.text).join(' / ') || '없음'}` : '';
-  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}`;
+  const opDetail = (classified.length ? ` · 결정 카드 후보: ${classified.filter((row) => row.kind === 'card').map((row) => row.text).join(' / ') || '없음'} · OP 가 할 일: ${classified.filter((row) => row.kind === 'todo').map((row) => row.text).join(' / ') || '없음'}` : '')
+    + (filtered.auto + filtered.route ? ` · 카드 거르기: 자동 ${filtered.auto} · 넘김 ${filtered.route}` : '');
+  let draftDetail = '';
+  if (seat === 'OP') {
+    try {
+      const metrics = await (deps.draftMetrics ?? (async (clock: Date) => {
+        const [{ resolveRepositoryName }, { githubDraftSweepAdapters }] = await Promise.all([
+          import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'),
+        ]);
+        return collectDraftMetrics(resolveRepositoryName({}), githubDraftSweepAdapters(), clock);
+      }))(now);
+      draftDetail = ` · draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`;
+    } catch { draftDetail = ' · draft 지표 못 읽음'; }
+    try {
+      const overlap = await (deps.overlapMetrics ?? (async (clock: Date) => {
+        const [{ resolveRepositoryName }, { githubDraftSweepAdapters }, { readAskPreflightRowsSince, readSalvagedRowsSince }] = await Promise.all([
+          import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'), import('../self-dev/ask-launch-io.js'),
+        ]);
+        return collectOverlapMetrics(resolveRepositoryName({}), { ...githubDraftSweepAdapters(), listPreflightRows: readAskPreflightRowsSince, listSalvagedRows: readSalvagedRowsSince }, clock);
+      }))(now);
+      draftDetail += overlapLine(overlap);
+    } catch { draftDetail += ' · 겹침 지표 못 읽음'; }
+    let salvagedToday: number | null = null;
+    try {
+      salvagedToday = await (deps.salvagedToday ?? (async (dayStart: Date, clock: Date) => {
+        const { readSalvagedRowsSince } = await import('../self-dev/ask-launch-io.js');
+        return countSalvagedToday(await readSalvagedRowsSince(dayStart), dayStart, clock);
+      }))(new Date(`${date}T00:00:00+09:00`), now);
+    } catch { salvagedToday = null; }
+    draftDetail += ` · 수확 가지 오늘 ${salvagedToday === null ? '못 잼' : salvagedToday}`;
+  }
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}${draftDetail}`;
   const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
   const posted = deps.post === true && pr !== undefined;
   if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);

package/src/self-dev/ask-launch-flow.ts

@@ -852,7 +852,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = []): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -950,6 +950,8 @@ export async function runAskLaunchFlow(
         recentChangeWindowDays: input.recentChangeWindowDays,
         openPrsLimit: OPEN_PR_LIMIT,
         ...(askOutsidePathHints.length > 0 ? { askOutsidePathHints } : {}),
+        // AUTO-TARGET: paths injected by the candidate search (not written in the ask) — a NOT-GROUNDED goal stops on them.
+        ...(machineSuggestedTargetPaths.length > 0 ? { machineSuggestedTargetPaths } : {}),
         declaredPathsRoot: deps.cwd(),
       },
       preflightDeps,
@@ -1026,12 +1028,13 @@ export async function runAskLaunchFlow(
         ...(candidates.error === undefined ? {} : { error: candidates.error }),
       }, candidates.error === undefined ? 'info' : 'warn');
     }
-    if (candidates.paths.length > 0) {
-      deps.print(`[ask] ⑴ 코드에서 후보 경로 ${candidates.paths.length}개를 찾아 넣고 다시 저작한다: ${candidates.paths.join(' · ')}`);
+    const selectedPaths = candidates.paths.slice(0, 1);
+    if (selectedPaths.length > 0) {
+      deps.print(`[ask] ⑴ 코드에서 후보 경로 ${selectedPaths.length}개를 찾아 넣고 다시 저작한다: ${selectedPaths.join(' · ')}`);
     }
-    authored = await authorAndPreflight(candidates.paths.length > 0
-      ? `대상 경로: ${candidates.paths.join(' · ')}\n${input.askText}`
-      : input.askText);
+    authored = await authorAndPreflight(selectedPaths.length > 0
+      ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
+      : input.askText, selectedPaths);
     deps.log('ask-auto-reauthor', {
       candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,

package/src/self-dev/ask-launch-io.ts

@@ -5,7 +5,7 @@
 //   72차 판이 복제를 금지했으므로 여기로 옮긴다. CLI 와 TUI 가 «같은 조회»를 쓴다.
 // ⛔ 판정은 여기 없다 — 여기는 「무엇을 조회하는가」뿐이고, 「그래서 막나」는 launch-preflight 가 정한다.
 import { execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { readFileSync, realpathSync } from 'node:fs';
 import {
   parseAskTargetPathHints,
   parseAskTargetPathHintsResult,
@@ -97,7 +97,7 @@ function inspectLaunchingTree(cwd: string): LaunchingTreeProbe {
 
 /** 발사 전 검사가 쓰는 조회 구현 — ⛔ 이 «한 벌»을 모든 표면이 공유한다. */
 export async function buildAskPreflightDeps(options: BuildAskPreflightDepsOptions = {}): Promise<AskPreflightDeps & { inspectLaunchingTree(cwd: string): LaunchingTreeProbe }> {
-  const [{ tracedPathReferences, verbatimOriginalAsk }, { loadRunLedger, queryFederatedCompletedRunLedgers, queryFederatedInterruptedRunLedgers, queryFederatedUnfinishedRunLedgers }] = await Promise.all([
+  const [{ tracedPathReferences, verbatimOriginalAsk, isNotGroundedWithoutPersistentEvidence }, { loadRunLedger, queryFederatedCompletedRunLedgers, queryFederatedInterruptedRunLedgers, queryFederatedUnfinishedRunLedgers }] = await Promise.all([
     import('../self-implement/goal-author.js'),
     import('../self-implement/run-ledger.js'),
   ]);
@@ -166,6 +166,8 @@ export async function buildAskPreflightDeps(options: BuildAskPreflightDepsOption
     //   ⛔ ask 표지가 없으면 빈 배열 — 그때는 표시가 «안 붙는다»(지어내지 않는다).
     askTargetPaths: (document: string) => parseAskTargetPathHints(verbatimOriginalAsk(document) ?? ''),
     askTargetPathRejections: (document: string) => parseAskTargetPathHintsResult(verbatimOriginalAsk(document) ?? '').rejected,
+    // AUTO-TARGET: a NOT-GROUNDED goal (no persistent evidence) is a scope card — machine-suggested paths do not launch it.
+    notGroundedWithoutPersistentEvidence: isNotGroundedWithoutPersistentEvidence,
     // ⭐ 충돌 문면이 경로마다 「대상/근거」를 말하게 한다 — 판정은 «안» 바꾼다(문면만 는다).
     //   ⛔ TRACED PATHS 는 「바꿀 파일」과 「근거로 읽은 파일」을 섞는다(실측: TRACED 8 · 변경 3).
     //     ⇒ 사람이 막혔을 때 「그게 근거였네」를 «즉시» 알 수 있어야 한다.
@@ -300,6 +302,54 @@ export async function readAskPreflightLogRows(): Promise<AskLogRow[] | null> {
   } catch { return null; }
 }
 
+/** Every `ask-preflight` row since `since`, all universes, paged past the 1000-row cap (OVERLAP-METRIC).
+ *  ⛔ Unreadable ⇒ `null` — never an empty list that reads as «no overlap launches». */
+export async function readAskPreflightRowsSince(since: Date): Promise<AskLogRow[] | null> {
+  return readLogRowsSince(since, 'dev-pipeline', 'ask-preflight');
+}
+
+/** Every DRAFT-NOT-ARCHIVE `salvaged` row since `since`, all universes (OVERLAP-METRIC salvage siblings).
+ *  ⛔ Unreadable ⇒ `null` — a salvage branch we could not see is «unmeasured», not «none». */
+export async function readSalvagedRowsSince(since: Date): Promise<AskLogRow[] | null> {
+  return readLogRowsSince(since, 'self-implement.draft-not-archive', 'salvaged');
+}
+
+async function readLogRowsSince(since: Date, category: string, event: string): Promise<AskLogRow[] | null> {
+  try {
+    const [{ resolveLogTargets }, { LogStore }] = await Promise.all([
+      import('../cli/logs-cli.js'),
+      import('../mss/logging/log-store.js'),
+    ]);
+    const { targets } = resolveLogTargets({ all: true, includeTest: true });
+    const rows: AskLogRow[] = [];
+    // ⛔ One store can be registered under two names (`~/.monad` → `~/.elanous` symlink) — read each real file once,
+    //   or every prod row is counted twice (OVERLAP-METRIC 실측: 169 행 중 69 가 같은 prod 파일의 겹침).
+    const seen = new Set<string>();
+    for (const target of targets) {
+      let real = target.dbPath;
+      try { real = realpathSync(target.dbPath); } catch { /* missing store: LogStore below decides */ }
+      if (seen.has(real)) continue;
+      seen.add(real);
+      const store = new LogStore(target.dbPath, { readonly: true });
+      try {
+        let beforeId: number | undefined;
+        for (let page = 0; page < 100; page++) {
+          const batch = store.query({ exactCategories: [category], events: [event], sinceMs: since.getTime(),
+            limit: 1_000, ...(beforeId === undefined ? {} : { beforeId }) });
+          for (const row of batch) {
+            const parsed = typeof row.data === 'string' ? JSON.parse(row.data) : row.data;
+            rows.push({ ts: row.ts, data: (parsed ?? null) as Record<string, unknown> | null });
+          }
+          if (batch.length < 1_000) break;
+          if (page === 99) return null;
+          beforeId = batch.at(-1)!.id;
+        }
+      } finally { store.close?.(); }
+    }
+    return rows;
+  } catch { return null; }
+}
+
 const stringList = (value: unknown): string[] =>
   Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
 

package/src/self-dev/ask-path-candidates.ts

@@ -14,6 +14,43 @@ export type AskPathCandidates =
 const STOP_WORDS = new Set(['the', 'and', 'test', 'src', 'scripts', 'file', 'path', 'paths', 'code', 'with', 'from', 'this', 'that', 'into', 'for', 'then', 'when', 'have', 'does', 'should', 'will', 'please', 'target', 'change']);
 const WORD = /[-/]?[A-Za-z][A-Za-z0-9_.-]*(?:\/[A-Za-z0-9_.-]+)*/g;
 
+// ⛔ AUTO-TARGET (10-08 실측 · `ask-auto-target-candidates` Pod 로그): 한글 ask 에서 영문 낱말은 거의
+//   «포장»뿐이었다 — 디스패처 머리 `[UX · 0.2.20 칸 <ID> · TASK-AGENT(OP 디스패처)]` ⊕ Pod 샤드 꼬리
+//   `## Shard identity {"shardId","totalShards","position","summary","siblings"}` ⊕ `## Working-memory handoff`.
+//   그 낱말들이 하니스 파일(orchestrate.ts · orchestrator.ts · self-implement-pod.ts · index.ts)을 끌어와
+//   네 칸이 엉뚱한 골로 저작됐다. ⇒ 포장을 «증거»에서 걷고, 남는 것이 없으면 «후보 없음»(=근거 없음)을 낸다.
+/** Machine-appended sections whose words describe the transport, not the request. */
+const WRAPPER_SECTION_HEADINGS = new Set(['shard identity', 'working-memory handoff']);
+/** Dispatcher wrapper lines that are identical for every card. */
+const WRAPPER_LINE = /^\s*(?:보존 계약|판정)\s*:/;
+/** Dispatcher header `[OWNER · <ver> 칸 <ID> · …]` — the title after it is kept. */
+const WRAPPER_HEADER = /^\s*\[[^\]\n]*칸[^\]\n]*\]\s*/;
+/** Dispatcher evidence label — the evidence itself is kept. */
+const WRAPPER_LABEL = /^\s*칸 근거 끝\(남은 것\)\s*:\s*/;
+/** Seat/role/surface words and similar labels that name the process, not the code. */
+const GENERIC_TOKENS = new Set(['task-agent', 'op', 'mk', 'tc', 'ux', 'ceo', 'coo', 'cmo', 'cto', 'cxo', 'pr', 'prs', 'pod', 'tui', 'pwa', 'cli', 'hitl', 'p0', 'p1', 'p2']);
+
+function isGenericToken(token: string): boolean {
+  const lower = token.toLowerCase().replace(/[.]+$/, '');
+  if (GENERIC_TOKENS.has(lower)) return true;
+  if (/^v?\d+(?:\.\d+)+(?:-[a-z0-9.]+)?$/i.test(lower)) return true;   // version strings
+  if (/^[0-9a-f]{7,40}$/.test(lower) && /\d/.test(lower)) return true;  // commit shas
+  return false;
+}
+
+/** Remove dispatcher/Pod wrapper text so only the request body counts as lexical evidence. */
+export function stripAskWrapper(askText: string): string {
+  const kept: string[] = [];
+  let skipping = false;
+  for (const line of askText.split(/\r?\n/)) {
+    const heading = /^##\s+(.+?)\s*$/.exec(line);
+    if (heading) skipping = WRAPPER_SECTION_HEADINGS.has(heading[1]!.toLowerCase());
+    if (skipping || WRAPPER_LINE.test(line)) continue;
+    kept.push(line.replace(WRAPPER_HEADER, '').replace(WRAPPER_LABEL, ''));
+  }
+  return kept.join('\n');
+}
+
 function existingFile(fragment: string, cwd: string): string | null {
   const path = fragment.replace(/^\.\//, '');
   if (!path.includes('/') && !/\.[A-Za-z][A-Za-z0-9]*$/.test(path)) return null;
@@ -29,7 +66,8 @@ export function findAskPathCandidates(askText: string, { cwd, run = execFileSync
   const scores = new Map<string, Set<string>>();
   const tokens: string[] = [];
   const seen = new Set<string>();
-  const chunks = [...askText.matchAll(/`([^`]+)`/g)].map((match) => match[1]!).concat([askText]);
+  const body = stripAskWrapper(askText);
+  const chunks = [...body.matchAll(/`([^`]+)`/g)].map((match) => match[1]!).concat([body]);
   for (const chunk of chunks) {
     for (const match of chunk.matchAll(WORD)) {
       const raw = match[0];
@@ -40,7 +78,7 @@ export function findAskPathCandidates(askText: string, { cwd, run = execFileSync
         hits.add(token);
         scores.set(file, hits);
       }
-      if (STOP_WORDS.has(token.toLowerCase()) || seen.has(token)) continue;
+      if (STOP_WORDS.has(token.toLowerCase()) || isGenericToken(token) || seen.has(token)) continue;
       if (!file && !token.includes('/') && !token.includes('.') && !token.includes('-') && !token.includes('_')
         && !/[a-z][A-Z]/.test(token) && token.length < 4) continue;
       seen.add(token);