elanous 0.2.20 → 0.2.22

package/src/self-dev/draft-sweep.ts

@@ -62,6 +62,9 @@ export interface DraftSweepOptions {
   adapters: DraftSweepAdapters;
   apply?: boolean;
   now?: Date;
+  /** Per-tick close cap; resolve it with resolveDraftSweepCloseCap. Absent or invalid ⇒ DRAFT_SWEEP_CLOSE_CAP. */
+  closeCap?: number;
+  closeCapSource?: DraftSweepCloseCapSource;
 }
 
 export interface DraftSweepEntry {
@@ -83,8 +86,11 @@ export interface DraftSweepResult {
   counts: Record<string, number>;
   /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
   unobserved?: number;
-  /** Closes decided this tick (at most DRAFT_SWEEP_CLOSE_CAP). */
+  /** Closes decided this tick (at most `closeCap`). */
   closed?: number;
+  /** The per-tick close cap this sweep used, and where it came from. */
+  closeCap?: number;
+  closeCapSource?: DraftSweepCloseCapSource;
   /** Fresh running claims protected this tick. */
   claimed?: number;
   /** Running claims older than the idle window, including those kept by liveness. */
@@ -420,8 +426,36 @@ const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
 const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
 const PAGE_SIZE = 100;
-/** At most this many closes per tick, so a wrong rule cannot close everything at once. */
+/** At most this many closes per tick, so a wrong rule cannot close everything at once. Default for `tools.selfImplement.draftSweepCloseCap`. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
+export const DRAFT_SWEEP_CLOSE_CAP_MIN = 1;
+export const DRAFT_SWEEP_CLOSE_CAP_MAX = 100;
+export type DraftSweepCloseCapSource = 'flag' | 'config' | 'default';
+
+export interface DraftSweepCloseCapResolution {
+  readonly closeCap: number;
+  readonly closeCapSource: DraftSweepCloseCapSource;
+  /** One line per rejected input (flag or config); each rejection falls through to the next source. */
+  readonly warnings: readonly string[];
+}
+
+function validCloseCap(value: unknown): number | undefined {
+  const parsed = typeof value === 'string' && /^\s*\d+\s*$/.test(value) ? Number(value) : value;
+  return typeof parsed === 'number' && Number.isSafeInteger(parsed)
+    && parsed >= DRAFT_SWEEP_CLOSE_CAP_MIN && parsed <= DRAFT_SWEEP_CLOSE_CAP_MAX ? parsed : undefined;
+}
+
+/** Flag over config over default; a value outside 1–100 (or not an integer) is rejected with a warning. */
+export function resolveDraftSweepCloseCap(input: { flag?: unknown; config?: unknown }): DraftSweepCloseCapResolution {
+  const warnings: string[] = [];
+  for (const [source, value, name] of [['flag', input.flag, '--close-cap'], ['config', input.config, 'tools.selfImplement.draftSweepCloseCap']] as const) {
+    if (value === undefined || value === null) continue;
+    const cap = validCloseCap(value);
+    if (cap !== undefined) return { closeCap: cap, closeCapSource: source, warnings };
+    warnings.push(`${name}=${JSON.stringify(value)} 무시 — ${DRAFT_SWEEP_CLOSE_CAP_MIN}~${DRAFT_SWEEP_CLOSE_CAP_MAX} 정수만 (기본 ${DRAFT_SWEEP_CLOSE_CAP})`);
+  }
+  return { closeCap: DRAFT_SWEEP_CLOSE_CAP, closeCapSource: 'default', warnings };
+}
 
 /** Post-merge shortcut: only the existing superseded-by decision can authorize a close. */
 export async function supersedeDraftsOnMerge(input: {
@@ -571,8 +605,11 @@ export function draftSweepDaily(
 }
 
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
-export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
-  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
+export async function runDraftSweep({ repository, adapters, apply = false, now = new Date(), closeCap: requestedCap, closeCapSource: requestedSource }: DraftSweepOptions): Promise<DraftSweepResult> {
+  const validCap = validCloseCap(requestedCap);
+  const closeCap = validCap ?? DRAFT_SWEEP_CLOSE_CAP;
+  const closeCapSource: DraftSweepCloseCapSource = validCap === undefined ? 'default' : requestedSource ?? 'flag';
+  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {}, closeCap, closeCapSource };
   const record = (entry: DraftSweepEntry): void => {
     result.entries.push(entry);
     result.counts[entry.reason] = (result.counts[entry.reason] ?? 0) + 1;
@@ -591,7 +628,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const at = Date.now();
     try {
       debug.log('self-dev.draft-sweep', 'timing', { phase, ms: at - phaseStarted, count, ...(outcome ? { outcome } : {}) });
-      if (outcome) debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: at - started, count, outcome });
+      if (outcome) debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: at - started, count, outcome, closeCap, closeCapSource });
     } catch { /* fail-soft */ }
     phaseStarted = at;
   };
@@ -706,7 +743,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         record({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
         continue;
       }
-      const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
+      const action = closes >= closeCap ? 'keep' : 'close';
       if (action === 'close') closes += 1;
       const entry: DraftSweepEntry = { number: draft.number, action,
         reason: action === 'close' ? runStatus === 'self-implement.result final'
@@ -737,7 +774,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
-      if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
+      if (closes >= closeCap) decision = { action: 'keep', reason: 'close-cap' };
       else closes += 1;
     }
     const action = contradiction ? 'report' : decision.action;
@@ -772,7 +809,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
   }
   timing('decide', drafts.length);
-  try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length }); } catch { /* fail-soft */ }
+  try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length, closed: closes, closeCap, closeCapSource }); } catch { /* fail-soft */ }
   result.unobserved = unobserved;
   result.closed = closes;
   result.claimed = claimed;

package/src/self-dev/graph-journey-nodes.ts

@@ -0,0 +1,157 @@
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { GRAPH_SPECS, GRAPH_TEMPLATES, GRAPH_TEMPLATES_SOURCE, pipelineNodeEntryPayload, templateForGoalType, type GraphTemplate } from '../self-implement/graph-templates.js';
+import type { GoalType } from '../self-implement/goal-author.js';
+
+/** ⭐ HARNESS-FULL-GRAPH (0.2.21 · 대표 10-08) — 하니스 «여정» 전 단계를 그래프 노드로 선언·관측한다.
+ *
+ *  🩸 계기: `내부 문서 `TECH-harness-map-2026-10-06`` 차트의 단계 중 «입구·대기열·발사 관문·배치·Pod 입장·
+ *    이미지 동기화·자격 선갱신·동결 검사·보류·회수·실패 쪽(결과 해석·수확·heal·다음 한 수)»이
+ *    그래프 밖의 «맨 코드»였다. 공개 문서는 「그래프 선언이 모든 걸음을 대조한다」고 말한다 — 거짓이 되지 않게.
+ *
+ *  ⛔ 이 모듈은 «관측»이다(1단계) — 흐름을 바꾸지 않는다. 진입은 기존 노드와 «같은 사건»
+ *    (`self-implement` / `pipeline-node-entry` · 같은 `pipelineNodeEntryPayload`)으로 남겨
+ *    그래프 권위의 declared/undeclared 판정과 원장 질의가 이 노드들을 «같은 자»로 본다.
+ *    출구는 `pipeline-node-exit`(결과 `outcome` 포함)로 남긴다.
+ *  ⛔ fail-soft — 관측이 발사·착지를 죽이지 않는다.
+ *
+ *  🔗 조인(런 id 가 없는 앞단): 입구에서 `ELANOUS_JOURNEY_KEY` 를 한 번 만들어 환경에 싣는다.
+ *    자식 프로세스는 그 값을 물려받고, 오케스트레이터의 모든 파이프라인 관측에도 `journeyKey` 가 실린다.
+ *    ⇒ `journeyKey` 로 「runId 없이 남은 앞단 걸음」과 「runId 가 있는 후반 걸음」을 한 질의로 묶는다.
+ *    대기열을 거친 발사는 부모·자식 프로세스가 다르다 — 그 자리는 `queueLaunchId`(=`ELANOUS_HARNESS_QUEUE_LAUNCH`)가 잇는다.
+ *    설계 = 내부 문서 `RFC-harness-full-journey-as-graph-2026-10-08` §4. */
+
+/** 여정 노드 — ⛔ id 는 원장의 조인 키이자 라이브 그래프 화면(HARNESS-RUN-LIVE-GRAPH)의 키다. 바꾸지 마라. */
+export const JOURNEY_NODE_IDS = [
+  'intake',
+  'queue',
+  'launch-gate',
+  'dispatch',
+  'pool-admit',
+  'image-sync',
+  'credential-refresh',
+  'freeze-check',
+  'hold',
+  'cleanup',
+  'result-parse',
+  'salvage',
+  'heal',
+  'next-move',
+  'stopped',
+] as const;
+export type JourneyNodeId = typeof JOURNEY_NODE_IDS[number];
+
+export const JOURNEY_KEY_ENV = 'ELANOUS_JOURNEY_KEY';
+const QUEUE_LAUNCH_ENV = 'ELANOUS_HARNESS_QUEUE_LAUNCH';
+const RUN_ID_ENV = 'ELANOUS_RUN_ID';
+
+/** 이 여정의 조인 키 — 없으면 만들어 환경에 싣는다(자식이 물려받는다). */
+export function ensureJourneyKey(env: NodeJS.ProcessEnv = process.env): string {
+  const existing = env[JOURNEY_KEY_ENV]?.trim();
+  if (existing) return existing;
+  const key = `jrn-${randomUUID()}`;
+  env[JOURNEY_KEY_ENV] = key;
+  return key;
+}
+
+/** 관측 자리마다 펼치는 조인 칸(있는 것만). */
+export function journeyJoinFields(env: NodeJS.ProcessEnv = process.env): { journeyKey?: string; queueLaunchId?: string } {
+  const journeyKey = env[JOURNEY_KEY_ENV]?.trim();
+  const queueLaunchId = env[QUEUE_LAUNCH_ENV]?.trim();
+  return {
+    ...(journeyKey ? { journeyKey } : {}),
+    ...(queueLaunchId ? { queueLaunchId } : {}),
+  };
+}
+
+/** 여정 노드를 선언한 템플릿 — 골 종류의 템플릿이 그 노드를 선언하면 그것, 아니면 구현 루프. */
+export function journeyTemplate(node: string, goalType?: GoalType | null): GraphTemplate {
+  const own = goalType ? templateForGoalType(goalType) : null;
+  if (own && own.nodes.some((n) => n.nodeId === node)) return own;
+  return GRAPH_TEMPLATES['self-implement'] as GraphTemplate;
+}
+
+export interface JourneyObservation {
+  readonly provenance: string;
+  readonly outcome?: string;
+  readonly runId?: string;
+  readonly goalType?: GoalType | null;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+function emit(entry: boolean, node: JourneyNodeId, o: JourneyObservation): void {
+  try {
+    const template = journeyTemplate(node, o.goalType);
+    const runId = o.runId ?? process.env[RUN_ID_ENV]?.trim();
+    const fields = {
+      node,
+      round: 0,
+      phase: 'journey',
+      provenance: o.provenance,
+      ...(o.outcome === undefined ? {} : { outcome: o.outcome }),
+      ...(runId ? { runId } : {}),
+      ...(o.goalType ? { goalType: o.goalType } : {}),
+      ...journeyJoinFields(),
+      ...o.data,
+      graphTemplatesSource: GRAPH_TEMPLATES_SOURCE,
+    };
+    // ⛔ 진입은 «공용 payload» 를 그 호출 안에서 펼친다 — 우회 가드(graph-templates.ts)가 행 단위로 문다.
+    if (entry) debug.log('self-implement', 'pipeline-node-entry', { ...pipelineNodeEntryPayload(template, node), ...fields });
+    else debug.log('self-implement', 'pipeline-node-exit', { ...pipelineNodeEntryPayload(template, node), ...fields });
+  } catch { /* 관측은 fail-soft */ }
+}
+
+/** 노드 진입. */
+export function enterJourneyNode(node: JourneyNodeId, o: JourneyObservation): void {
+  emit(true, node, o);
+}
+
+/** 노드 출구 — `outcome` 이 그 노드에서 나간 간선의 라벨(YAML `map` 키)이다.
+ *  ⭐ 그 라벨이 선언에서 종결 노드 `stopped` 로 가면 `stopped` 진입도 남긴다 — 거절·포기 런이 «선언된 종결점»에서 끝난다.
+ *  `outcome: 'error'` = 노드 안 작업이 예외를 던졌다(예외는 호출자에게 그대로 간다). */
+export function exitJourneyNode(node: JourneyNodeId, o: JourneyObservation & { readonly outcome: string }): void {
+  emit(false, node, o);
+  if (node !== 'stopped' && journeyEdgeTarget(node, o.outcome) === 'stopped') {
+    const { outcome: _outcome, ...rest } = o;
+    emit(true, 'stopped', { ...rest, provenance: `${node}:${o.outcome}` });
+  }
+}
+
+/** 선언(기준 YAML)에서 `from` 의 `label` 간선이 가는 노드. 없으면 undefined. */
+export function journeyEdgeTarget(from: string, label: string): string | undefined {
+  try {
+    for (const edge of GRAPH_SPECS['self-implement']?.edges ?? []) {
+      if (edge.from === from && edge.map !== undefined && Object.hasOwn(edge.map, label)) return edge.map[label];
+    }
+  } catch { /* 관측 보조 — 실패해도 출구는 이미 남았다 */ }
+  return undefined;
+}
+
+/** 노드 안 작업을 감싼다 — 예외면 출구 `error` 를 남기고 다시 던진다(진입 뒤 출구가 빠지지 않게). */
+export function withJourneyNode<T>(node: JourneyNodeId, o: JourneyObservation, work: () => Promise<T>): Promise<T> {
+  const onError = (error: unknown): void => {
+    exitJourneyNode(node, { ...o, outcome: 'error', data: { ...o.data, error: error instanceof Error ? error.message : String(error) } });
+  };
+  let pending: Promise<T>;
+  try { pending = work(); }
+  catch (error) { onError(error); throw error; }
+  // ⛔ 같은 약속을 «그대로» 돌려준다 — async/await 로 감싸면 마이크로태스크가 늘어 호출자의 순서가 밀린다
+  //   (2판에서 self-implement-pod 시험이 그 차이를 잡았다). 관측은 곁가지(.then)로만 붙인다.
+  pending.then(undefined, onError);
+  return pending;
+}
+
+/** 동기 판. */
+export function withJourneyNodeSync<T>(node: JourneyNodeId, o: JourneyObservation, work: () => T): T {
+  try { return work(); }
+  catch (error) {
+    exitJourneyNode(node, { ...o, outcome: 'error', data: { ...o.data, error: error instanceof Error ? error.message : String(error) } });
+    throw error;
+  }
+}
+
+/** 진입·출구를 한 번에 — 판정만 하는 노드(대기 없는 관문)용. */
+export function passJourneyNode(node: JourneyNodeId, o: JourneyObservation & { readonly outcome: string }): void {
+  enterJourneyNode(node, o);
+  exitJourneyNode(node, o);
+}

package/src/self-dev/graph-journey-route.ts

@@ -0,0 +1,105 @@
+import { debug } from '../debug/log.js';
+import { GRAPH_SPECS } from '../self-implement/graph-templates.js';
+import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from '../self-implement/graph-overlay-yaml.js';
+import type { GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import { journeyJoinFields } from './graph-journey-nodes.js';
+
+/** ⭐ HARNESS-FULL-GRAPH 2판 — 「다음 노드」를 코드가 아니라 «그래프»가 정한다.
+ *
+ *  대표 10-08: *«그래프에 따라 실제 경로가 바뀌어야 한다. 기본은 풀세트, 환경 셋업·운영 방법에 따라 일부만 걷거나 생략.»*
+ *  ⇒ 코드는 «상태 값»(queue=queued|direct · substrate=local|pod · freeze=open|frozen …)만 낸다.
+ *    그 값으로 «어느 간선을 타나»는 YAML 의 `on:`/`map:`(⊕ `stage: launch` 오버레이)이 정한다.
+ *  ⛔ 기본 YAML 은 오늘 코드와 «같은 길»을 낸다 — 시험이 그 동치를 문다(graph-journey-route.test.ts).
+ *  ⛔ 그래프가 답을 못 내면(간선 없음·로드 실패) 코드 기본으로 간다 — 그 사실을 `source: 'code-default'` 로 남긴다.
+ *  🔎 관측: `self-implement` / `graph-edge-taken` { from, on, label, to, source, overlays } */
+
+export interface JourneyRoute {
+  readonly from: string;
+  readonly on: string | null;
+  readonly label: string;
+  /** 그래프가 고른 다음 노드. 못 고르면 null. */
+  readonly to: string | null;
+  readonly source: 'graph' | 'code-default';
+  readonly overlays: readonly string[];
+}
+
+/** ⛔ 캐시하지 않는다 — 여러 런을 처리하는 프로세스(데몬·대기열 tick)가 다음 발사에서 오버레이 변경을 봐야 한다.
+ *  여정 판정은 발사당 몇 번뿐이라 디렉터리 한 번 읽기가 싸다. */
+let overlaysForTesting: readonly GraphOverlaySpec[] | undefined;
+function launchOverlays(): readonly GraphOverlaySpec[] {
+  if (overlaysForTesting !== undefined) return overlaysForTesting;
+  try { return loadGraphOverlays(defaultOverlaysDir()).overlays; }
+  catch { return []; }
+}
+
+/** 시험 전용 — 오버레이 묶음을 고정한다(undefined 면 디스크에서 읽는다). */
+export function setJourneyOverlaysForTesting(overlays: readonly GraphOverlaySpec[] | undefined): void {
+  overlaysForTesting = overlays;
+}
+
+/** 상태 값으로 고른 «이 런의 여정 선언» — 기준 YAML ⊕ 조건이 맞는 launch 오버레이. */
+export function journeySpec(
+  state: Readonly<Record<string, unknown>>,
+  base: GraphTemplateSpec | undefined = GRAPH_SPECS['self-implement'],
+  overlays: readonly GraphOverlaySpec[] = launchOverlays(),
+): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[] } {
+  if (base === undefined) return { spec: undefined, applied: [] };
+  try {
+    const { applied } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state });
+    if (applied.length === 0) return { spec: base, applied: [] };
+    const result = applyGraphOverlays(base, applied);
+    // ⛔ 거절된 오버레이는 길을 바꾸지 않는다 — 기준 선언으로 간다.
+    return result.ok ? { spec: result.template, applied: result.overlayIds } : { spec: base, applied: [] };
+  } catch {
+    return { spec: base, applied: [] };
+  }
+}
+
+/** `from` 노드에서 `label` 로 나가는 다음 노드를 그래프에서 «읽는다»(기록하지 않는다).
+ *  ⛔ 판독과 기록을 가른다 — 실제로 탄 간선은 전제 검사·실제 단계 경계 «뒤»에 `recordJourneyEdge` 로 남긴다. */
+export function readJourneyEdge(
+  from: string,
+  label: string,
+  state: Readonly<Record<string, unknown>> = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+): JourneyRoute {
+  const { spec, applied } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays());
+  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied };
+  for (const edge of spec?.edges ?? []) {
+    if (edge.from !== from) continue;
+    if (edge.map !== undefined && Object.hasOwn(edge.map, label)) {
+      route = { from, on: edge.on ?? null, label, to: edge.map[label]!, source: 'graph', overlays: applied };
+      break;
+    }
+  }
+  return route;
+}
+
+/** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
+export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string): void {
+  try {
+    debug.log('self-implement', 'graph-edge-taken', {
+      graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
+      ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
+    });
+  } catch { /* 관측은 fail-soft */ }
+}
+
+/** 판독 ⊕ 그 자리에서 기록 — 판독 자리가 곧 실제 단계 경계일 때만 쓴다. */
+export function routeJourneyEdge(
+  from: string,
+  label: string,
+  state: Readonly<Record<string, unknown>> = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+): JourneyRoute {
+  const route = readJourneyEdge(from, label, state, deps);
+  recordJourneyEdge(route, route.to ?? label);
+  return route;
+}
+
+/** 입구의 대기열 갈래 — 그래프가 고른 다음 노드로 정한다. 그래프가 답을 못 내면 코드 라벨을 따른다.
+ *  ⛔ `eligible`(자리 있음 · 대기열 자식 아님 · --no-queue 아님)은 그래프가 못 넘는 전제다. */
+export function intakeTakesQueue(label: 'queued' | 'direct', route: Pick<JourneyRoute, 'source' | 'to'>, eligible: boolean): boolean {
+  const graphQueues = route.source === 'graph' ? route.to === 'queue' : label === 'queued';
+  return graphQueues && eligible;
+}

package/src/self-dev/launch-preflight.ts

@@ -538,6 +538,9 @@ export interface LaunchPreflightInput {
   readonly askTargetPaths?: readonly string[];
   /** 대상 경로 라벨이 «있는데» 거부된 조각. 0건 막음 문면이 그 이유를 말하게 한다(판정은 안 바꾼다). */
   readonly askTargetPathRejections?: readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: machine-suggested target paths dropped because the goal is NOT-GROUNDED (no persistent evidence).
+   *  Non-empty = the goal is a scope card and must not launch an implementation. */
+  readonly notGroundedDroppedTargetPaths?: readonly string[];
   /** ask 원문 경로. 있으면 ask-outside-path 경고만 이 목록과 최종 대상을 비교한다. */
   readonly askOutsidePathHints?: readonly string[];
   /** 이번에 쏠 골의 브랜치 이름. 없으면 형제 PR 축의 경고를 내지 않는다. */
@@ -559,19 +562,31 @@ function emitAskMarkerObservation(result: LaunchPreflightResult): void {
   emittedAskMarkerObservations.add(result);
 }
 
+/** AUTO-TARGET: blocker name for a NOT-GROUNDED goal whose only target paths were machine-suggested (a scope card). */
+export const NOT_GROUNDED_SCOPE_CARD_BLOCKER = '(NOT-GROUNDED 범위 카드)';
+
 export function evaluateLaunchPreflight(input: LaunchPreflightInput): LaunchPreflightResult {
   const paths = [...new Set(input.paths.filter((path) => path.trim().length > 0))];
   const blockers: LaunchPreflightBlocker[] = [];
   const warnings: LaunchPreflightBlocker[] = [];
 
+  // AUTO-TARGET (10-08 canary · TSC-HEAP): a NOT-GROUNDED goal whose only target paths came from the
+  //   harness candidate search is a scope card — refuse it with that reason, not the generic «no label» text.
+  const notGroundedDropped = input.notGroundedDroppedTargetPaths ?? [];
+  const notGroundedDetail = notGroundedDropped.length > 0
+    ? `골이 NOT-GROUNDED(영속 근거 0)라 하니스 후보 검색이 넣은 대상 경로 ${notGroundedDropped.length}개(${notGroundedDropped.slice(0, 3).join(' · ')}${notGroundedDropped.length > 3 ? ' …' : ''})를 대상으로 쓰지 않는다 — 범위 카드: 구현 발사 대상이 아니다 · ask 첫 줄에 사람이 「대상 경로: <파일>」을 적거나 접지 근거를 복구한 뒤 다시 저작`
+    : undefined;
+  if (notGroundedDetail !== undefined && paths.length > 0) {
+    blockers.push({ kind: 'no-target-paths', name: NOT_GROUNDED_SCOPE_CARD_BLOCKER, detail: notGroundedDetail });
+  }
   // ① 모집단이 0이면 «통과»가 아니라 «막는 사유»다(METHOD v32 를 이 코드에도 적용).
   if (paths.length === 0) {
     blockers.push({
       kind: 'no-target-paths',
-      name: '(대상 경로 0)',
+      name: notGroundedDetail !== undefined ? NOT_GROUNDED_SCOPE_CARD_BLOCKER : '(대상 경로 0)',
       // ⛔ 2026-09-23 — 라벨이 «있는데» 조각이 거부된 경우를 「라벨을 넣어라」로 뭉개면 「거부됐다」를 「없다」로 읽게 된다
       //   (실측: `대상 경로: README.md — 설명…` 한 줄 → has-whitespace 로 통째 거부 · 문면은 「넣어라」뿐이었다).
-      detail: (input.askTargetPathRejections?.length
+      detail: notGroundedDetail !== undefined ? notGroundedDetail : (input.askTargetPathRejections?.length
         ? `대상 경로 라벨은 있는데 조각 ${input.askTargetPathRejections.length}개가 거부됐다: ${input.askTargetPathRejections.slice(0, 3).map((r) => `「${r.fragment.length > 40 ? `${r.fragment.slice(0, 40)}…` : r.fragment}」(${r.reason})`).join(' · ')} — 그 줄에는 «경로만» 둔다(설명은 다음 줄)`
         : '골에서 대상 경로를 하나도 못 뽑았다 — ask 첫 줄에 「대상 경로: <파일> · <파일>」을 넣어라')
         + ' — 이 상태의 「위반 0」은 「검사했다」가 아니다 — elanous self author --inspect-target-paths "<문면>"',
@@ -1192,6 +1207,9 @@ export interface AskPreflightDeps {
   readonly askTargetPaths?: (document: string) => readonly string[];
   /** 대상 경로 라벨 «안»에서 거부된 조각(이유 포함). 0건 막음 문면이 「라벨이 없다」와 「있는데 거부됐다」를 가르게 한다. */
   readonly askTargetPathRejections?: (document: string) => readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: true when the authored goal is NOT-GROUNDED with no persistent evidence (a scope card).
+   *  Omitted = this distinction is not made (existing behavior). Production wires `isNotGroundedWithoutPersistentEvidence`. */
+  readonly notGroundedWithoutPersistentEvidence?: (document: string) => boolean;
 }
 
 export interface AskPreflightOptions {
@@ -1212,6 +1230,10 @@ export interface AskPreflightOptions {
   readonly plannedBranch?: string;
   /** 저작 전 ask 원문. 주면 기존 ask-marker-check로 형식을 관측하되 발사를 막지 않는다. */
   readonly askText?: string;
+  /** AUTO-TARGET: target paths the harness put into the ask (candidate search), not the human.
+   *  If the authored goal is NOT-GROUNDED without persistent evidence, these paths are dropped and the
+   *  goal stops before launch (`no-target-paths` blocker naming the reason). */
+  readonly machineSuggestedTargetPaths?: readonly string[];
 }
 
 export type PlannedBranchResolution =
@@ -1539,7 +1561,24 @@ export function decideAskPreflight(
     }
   }
   // ⛔ 저작 전에는 pathsOverride 자체가 ask 대상 힌트다. 저작 뒤에는 골에서 뽑은 대상만 역할로 쓴다.
-  const askTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  const declaredAskTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  // AUTO-TARGET: a NOT-GROUNDED goal (no persistent evidence) carries no machine-suggested target path.
+  const machineSuggested = new Set((opts.machineSuggestedTargetPaths ?? []).map((path) => path.trim()).filter(Boolean));
+  let notGroundedGoal = false;
+  if (!opts.pathsOverride && goalDocument !== null && machineSuggested.size > 0 && deps.notGroundedWithoutPersistentEvidence) {
+    try { notGroundedGoal = deps.notGroundedWithoutPersistentEvidence(goalDocument); } catch { notGroundedGoal = false; }
+  }
+  const notGroundedDroppedTargetPaths = notGroundedGoal ? declaredAskTargetPaths.filter((path) => machineSuggested.has(path)) : [];
+  const askTargetPaths = notGroundedDroppedTargetPaths.length > 0
+    ? declaredAskTargetPaths.filter((path) => !machineSuggested.has(path))
+    : declaredAskTargetPaths;
+  if (notGroundedDroppedTargetPaths.length > 0) {
+    try {
+      debug.log('harness.preflight', 'not-grounded-target-paths-dropped', { goalFile: opts.goalFile, dropped: notGroundedDroppedTargetPaths });
+    } catch {
+      // Observation never changes the launch decision.
+    }
+  }
   // 저작 뒤에는 접지가 읽은 경로와 선언 대상 경로를 함께 검사한다. 저작 전 pathsOverride는 그대로 쓴다.
   const paths = opts.pathsOverride ?? [...new Set([...tracedPaths, ...askTargetPaths])];
   const askMarkerInspection = opts.askText === undefined
@@ -1677,6 +1716,7 @@ export function decideAskPreflight(
     ...(goalRulersUnknownReason ? { goalRulersUnknownReason } : {}),
     preexistingFailures,
     ...(askTargetPaths.length > 0 ? { askTargetPaths } : {}),
+    ...(notGroundedDroppedTargetPaths.length > 0 ? { notGroundedDroppedTargetPaths } : {}),
     ...(askTargetPaths.length === 0 && goalDocument && deps.askTargetPathRejections
       ? { askTargetPathRejections: deps.askTargetPathRejections(goalDocument) }
       : {}),

package/src/self-dev/orchestrate.ts

@@ -298,6 +298,8 @@ export interface SelfDevJobResult {
   providerErrors?: { count: number; provider: string; category: 'quota' | 'credential' | 'request' | 'other' };
   /** Stable child run identity used to join its run-ledger proposal. */
   runId?: string;
+  /** Self review verdict bound to the PR head observed by the child; absent if either observation is missing. */
+  selfReview?: { verdict: 'pass' | 'fail'; head: string };
   /** Whether the child review actually ran; omitted preserves legacy producers. */
   reviewed?: boolean;
   /** Why the child did not run review; omitted preserves legacy review-unobserved handling. */
@@ -1499,6 +1501,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
           ...(disp?.merged !== undefined ? { merged: disp.merged } : {}),
           ...(disp?.checkedHeadCommit ? { checkedHeadCommit: disp.checkedHeadCommit } : {}),
+          ...(disp?.selfReview ? { selfReview: disp.selfReview } : {}),
           // ⭐ `A1` — 판정 3종을 «끝까지» 옮긴다. 여기서 빠지면 트리아지가 눈을 잃는다.
           ...(disp?.mergeReason ? { mergeReason: disp.mergeReason } : {}),
           ...(!cancelling && disp?.stopReason ? { stopReason: disp.stopReason } : {}),

package/src/self-dev/release-path-guard.ts

@@ -1,6 +1,9 @@
-// Release path = what publishing reads directly: the release scripts and graph, plus the manifest, release notes and cut schedule
-// in `src/release-loop/`. The checklist store (`checklist.ts`, `feature-store.ts`) is shared ops ledger code — the gate catches its regressions (OP 10-03).
-export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule'] as const;
+// Release path = release scripts and graph, manifest, notes and cut schedule, plus gate execution modules
+// imported by scripts/release-loop/gate-node.ts (pod-command-job → pod-pool → pod-lease; pod-bun-cache; pod-install-slots; gate-shards).
+// The checklist store (`checklist.ts`, `feature-store.ts`) remains shared ops ledger code (OP 10-03).
+export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule',
+  'src/task-orchestrator/surfaces/pod-command-job.ts', 'src/task-orchestrator/surfaces/pod-pool.ts', 'src/task-orchestrator/surfaces/pod-lease.ts',
+  'src/task-orchestrator/surfaces/pod-bun-cache.ts', 'src/task-orchestrator/surfaces/pod-install-slots.ts', 'src/release-loop/gate-shards.ts'] as const;
 export const RELEASE_PATH_LABEL = 'elanous:release-path';
 
 /** Flatten every GitHub PR file page, including the source of a rename. */
@@ -35,7 +38,7 @@ export function releaseGitDiffPaths(output: string): string[] {
 
 /** Evaluate the paths from the opened PR, not the requested goal or local working tree. */
 export function releasePathHold(paths: readonly string[]): string | undefined {
-  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => path.startsWith(prefix)));
+  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => prefix.endsWith('.ts') ? path === prefix : path.startsWith(prefix)));
 }
 
 /** Fixed opening of the hold comment — also how a PR held by several merge surfaces (or polls) is recognised, so it is posted once. */

package/src/self-dev/review-provider-fallback.ts

@@ -19,6 +19,89 @@
 //     쿼터 축은 과부하에 «반응하지 않는다».
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import type { LLMProvider } from '../llm.js';
+import { spawnSync } from 'node:child_process';
+import { claudeBackend, resolveBackendSpawn } from '../agent-mission/driver.js';
+import { checkClaudeSubscription } from '../agent-mission/claude-subscription.js';
+import { getAcpBackend, type AcpBackendSpec } from '../acp/backend-registry.js';
+import type { SubscriptionReviewerSpec } from '../user-config.js';
+
+export interface SubscriptionReviewerDeps {
+  /** Returns measured Claude subscription usage; unknown usage fails closed. */
+  usedPercent?: () => number | undefined;
+  checkSubscription?: (env: Record<string, string>) => boolean;
+  runStatus?: (command: string, args: string[], env: Record<string, string>) => { status: number | null; stdout?: string | Buffer | null };
+}
+
+/** The runner and the subscription probe share the PTY backend's billing-env scrub. */
+export function subscriptionReviewerSpawn(spec: SubscriptionReviewerSpec, env: NodeJS.ProcessEnv = process.env): {
+  command: string; args: string[]; env: Record<string, string>; backendSpec: AcpBackendSpec;
+} {
+  const executor = spec.executor ?? 'cct';
+  const { env: cleanEnv } = resolveBackendSpawn(claudeBackend, env);
+  const command = executor === 'cct' ? 'teamclaude' : 'claude';
+  const args = executor === 'cct'
+    ? ['run', '--auto-fallback', '--', '--dangerously-skip-permissions']
+    : ['--dangerously-skip-permissions'];
+  return { command, args, env: cleanEnv,
+    backendSpec: { ...getAcpBackend('claude'), command, args } };
+}
+
+/** Guard the ACP review before spawning. An unmeasured quota never authorizes subscription use. */
+export function subscriptionReviewerAvailability(
+  spec: SubscriptionReviewerSpec,
+  cap: number,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): { spawn?: ReturnType<typeof subscriptionReviewerSpawn>; reason?: string } {
+  const spawn = subscriptionReviewerSpawn(spec, env);
+  const executor = spec.executor ?? 'cct';
+  const runStatus = deps.runStatus ?? ((command: string, args: string[], cleanEnv: Record<string, string>) =>
+    spawnSync(command, args, { env: { ...cleanEnv, NODE_ENV: process.env.NODE_ENV }, encoding: 'utf8', timeout: 5_000 }));
+  const usedPercent = deps.usedPercent ?? (() => {
+    const result = runStatus('teamclaude', ['status'], spawn.env);
+    if (result.status !== 0) return undefined;
+    // Only a named usage percentage is accepted; a random percentage in status is not quota evidence.
+    const match = String(result.stdout).match(/(?:usage|used)\s*[:=]?\s*(\d+(?:\.\d+)?)\s*%/i);
+    return match ? Number(match[1]) : undefined;
+  });
+  try {
+    const subscribed = deps.checkSubscription ?? ((cleanEnv: Record<string, string>) => {
+      if (executor === 'cc') return checkClaudeSubscription({ env: cleanEnv }).ok;
+      const status = runStatus('teamclaude', ['status'], cleanEnv);
+      return status.status === 0 && /(?:subscription|claude\.ai|claude\s+(?:max|pro))/i.test(String(status.stdout))
+        && !/(?:logged\s*out|not\s+logged\s+in|api[_ -]?key|not\s+authenticated)/i.test(String(status.stdout));
+    });
+    if (!subscribed(spawn.env)) return { reason: `${executor} subscription check failed` };
+    const used = usedPercent();
+    if (!Number.isFinite(cap) || cap < 0 || cap > 100 || used === undefined
+      || !Number.isFinite(used) || used < 0 || used >= cap) return { reason: `Claude subscription usage unavailable or at harness cap (${cap}%)` };
+    return { spawn };
+  } catch {
+    return { reason: `${executor} subscription check failed` };
+  }
+}
+
+/** Keep a single notice attached to the actual default review result. */
+export async function runSubscriptionReviewer(
+  spec: SubscriptionReviewerSpec | undefined,
+  cap: number,
+  prompt: string,
+  defaultReview: (prompt: string) => Promise<string>,
+  acpReview: (prompt: string, spawn: ReturnType<typeof subscriptionReviewerSpawn>) => Promise<string>,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): Promise<string> {
+  if (!spec) return defaultReview(prompt);
+  const availability = subscriptionReviewerAvailability(spec, cap, env, deps);
+  if (availability.spawn) {
+    try {
+      const text = await acpReview(prompt, availability.spawn);
+      if (text.trim()) return text;
+    } catch { /* ACP failure is not a completed review. */ }
+  }
+  const reason = availability.reason ?? 'ACP review failed';
+  return `${await defaultReview(prompt)}\n[reviewer fallback: ${reason}; default reviewer used]`;
+}
 
 export type ReviewFailureReason =
   | 'overloaded'

package/src/self-dev/run-supervisor.ts

@@ -623,7 +623,11 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       if (decision.stopReason && opts.taskAgentShadow !== false) {
         // TASK-AGENT-SHADOW — 판단부를 그림자로 부른다(실행 0). 어떤 오류도 런의 결말을 바꾸지 않는다.
         try {
-          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results });
+          const pr = results.find((result) => typeof result.prNumber === 'number' && result.prNumber > 0)?.prNumber;
+          const reviewed = results.filter((result) => result.prNumber === pr && result.selfReview && result.merged !== true);
+          const selfReview = pr && reviewed.length === 1 ? reviewed[0]!.selfReview : undefined;
+          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results,
+            ...(selfReview ? { selfReview } : {}), cycleId: `${runId ?? 'unknown'}:${decision.round}` });
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }