elanous 0.2.17 → 0.2.18

package/src/release-loop/rubric.ts

@@ -0,0 +1,80 @@
+import { Database } from 'bun:sqlite';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ChecklistItem } from './checklist.js';
+
+export interface Rubric {
+  A: number;
+  E: number;
+  R: number;
+  D: number;
+  M: number;
+  B: number;
+  S: number;
+  X: number;
+}
+
+const AXES = ['A', 'E', 'R', 'D', 'M', 'B', 'S', 'X'] as const;
+
+/** Read one explicit rubric line; an old score in parentheses is not an axis. */
+export function parseRubric(text: string): Rubric | null {
+  for (const line of text.split(/\r?\n/)) {
+    const match = /(?:^|\s)루브릭:\s*([^\r\n]*)/.exec(line);
+    if (!match) continue;
+    const values: Partial<Rubric> = {};
+    const body = match[1]!.replace(/\([^)]*\)/g, ' ');
+    for (const token of body.trim().split(/\s+/)) {
+      const axis = /^([AERDMBSX])([0-3])$/.exec(token);
+      if (axis) values[axis[1] as keyof Rubric] = Number(axis[2]);
+    }
+    if (AXES.every((axis) => values[axis] !== undefined)) return values as Rubric;
+  }
+  return null;
+}
+
+export function rubricScore(r: Rubric): number {
+  return 2 * r.A + 2 * r.E + 2 * r.R + 1.5 * r.D + r.M + r.B - 0.5 * r.S - 0.5 * r.X;
+}
+
+export function rubricGrade(score: number): 'P1' | 'P2' | 'P3' | 'P4' {
+  if (score >= 11) return 'P1';
+  if (score >= 8) return 'P2';
+  if (score >= 5) return 'P3';
+  return 'P4';
+}
+
+/** Inspect an existing checklist without initializing, importing, or migrating its ledger. */
+export function readRubricItems(version: string, ledgerRoot: string): Pick<ChecklistItem, 'id' | 'title' | 'evidence' | 'priority'>[] {
+  const dbPath = join(ledgerRoot, 'release', 'features.sqlite');
+  if (existsSync(dbPath)) {
+    const db = new Database(dbPath, { readonly: true, strict: true });
+    try {
+      const columns = new Set((db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>).map((row) => row.name));
+      const priority = columns.has('priority') ? 'a.priority' : 'NULL';
+      const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.evidence, ${priority} AS priority
+        FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`)
+        .all(version) as Array<{ id: string; title: string; evidence: string | null; priority: ChecklistItem['priority'] | null }>;
+      const imported = db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version);
+      if (rows.length || imported) {
+        const refs = db.query('SELECT feature_id, ref FROM evidence WHERE version = ? ORDER BY rowid')
+          .all(version) as Array<{ feature_id: string; ref: string }>;
+        const refsById = new Map<string, string[]>();
+        for (const { feature_id, ref } of refs) {
+          const list = refsById.get(feature_id) ?? [];
+          list.push(ref);
+          refsById.set(feature_id, list);
+        }
+        return rows.map((row) => {
+          const evidence = [row.evidence, ...(refsById.get(row.id) ?? [])]
+            .filter((value): value is string => value !== null).join('\n');
+          return { id: row.id, title: row.title, ...(evidence ? { evidence } : {}), ...(row.priority ? { priority: row.priority } : {}) };
+        });
+      }
+    } finally { db.close(); }
+  }
+  const path = join(ledgerRoot, 'release', version, 'checklist.json');
+  if (!existsSync(path)) return [];
+  const legacy = JSON.parse(readFileSync(path, 'utf8')) as { version: string; items: ChecklistItem[] };
+  if (legacy.version !== version || !Array.isArray(legacy.items)) throw new Error(`잘못된 체크리스트: ${path}`);
+  return legacy.items;
+}

package/src/seat-dispatch/seat-ask.ts

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { openMsgStore, type MsgStore } from '../msg/msg-store.js';
-import { dispatchCeoTask, type CeoCommandDeps } from './ceo-commands.js';
+import { CEO_SEAT_COMMANDS, dispatchCeoTask, type CeoCommandDeps } from './ceo-commands.js';
 import type { SeatId } from './seat-questions.js';
 
 export type AskOrigin =
@@ -23,7 +23,7 @@ function createTable(store: MsgStore): void {
     answer TEXT, answered_at INTEGER, asked_at INTEGER
   ); CREATE TABLE IF NOT EXISTS seat_ask_outbox (
     id TEXT PRIMARY KEY, origin TEXT NOT NULL, text TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
-    claim_until INTEGER NOT NULL DEFAULT 0, claim_token TEXT
+    claim_until INTEGER NOT NULL DEFAULT 0, claim_token TEXT, sent_at INTEGER
   )`);
   const askColumns = store.db.query('PRAGMA table_info(seat_asks)').all() as Array<{ name: string }>;
   if (!askColumns.some(({ name }) => name === 'answer')) store.db.exec('ALTER TABLE seat_asks ADD COLUMN answer TEXT');
@@ -32,6 +32,7 @@ function createTable(store: MsgStore): void {
   const columns = store.db.query('PRAGMA table_info(seat_ask_outbox)').all() as Array<{ name: string }>;
   if (!columns.some(({ name }) => name === 'claim_until')) store.db.exec('ALTER TABLE seat_ask_outbox ADD COLUMN claim_until INTEGER NOT NULL DEFAULT 0');
   if (!columns.some(({ name }) => name === 'claim_token')) store.db.exec('ALTER TABLE seat_ask_outbox ADD COLUMN claim_token TEXT');
+  if (!columns.some(({ name }) => name === 'sent_at')) store.db.exec('ALTER TABLE seat_ask_outbox ADD COLUMN sent_at INTEGER');
 }
 
 export interface SeatAskShadow {
@@ -77,10 +78,24 @@ export interface SeatAskDeps {
   botId?: string;
 }
 
-/** Persist the return address before delivering through the /cto channel and seat inbox. */
-export async function askSeat(text: string, origin: AskOrigin, command: CeoCommandDeps, deps: SeatAskDeps): Promise<string> {
+const seatTitle = (seat: SeatId): string => Object.entries(CEO_SEAT_COMMANDS)
+  .find(([, id]) => id === seat)![0]!.toUpperCase();
+
+/** Persist the return address before delivering through the coordination channel and seat inbox. */
+export function askSeatAs(seat: SeatId, body: string, origin: AskOrigin, command: CeoCommandDeps, deps: SeatAskDeps,
+  kind: 'task' | 'question' = 'task'): Promise<string> {
+  return recordAndDispatchSeatAsk(seat, body, origin, command, deps, kind);
+}
+
+/** Preserve the CTO question form and its original receipt. */
+export function askSeat(text: string, origin: AskOrigin, command: CeoCommandDeps, deps: SeatAskDeps): Promise<string> {
   const body = parseSeatAsk(text);
   if (!body) throw new Error('not a CTO ask');
+  return askSeatAs('TC', body, origin, command, deps, 'question');
+}
+
+async function recordAndDispatchSeatAsk(seat: SeatId, body: string, origin: AskOrigin, command: CeoCommandDeps, deps: SeatAskDeps,
+  kind: 'task' | 'question'): Promise<string> {
   const id = randomUUID();
   const timeout = deps.timeoutMs ?? DEFAULT_ASK_TIMEOUT_MS;
   if (!Number.isSafeInteger(timeout) || timeout < 1) throw new Error('invalid seat ask timeout');
@@ -90,13 +105,14 @@ export async function askSeat(text: string, origin: AskOrigin, command: CeoComma
     createTable(store);
     const askedAt = (deps.now ?? Date.now)();
     store.db.query('INSERT INTO seat_asks (id, seat, origin, deadline, timeout_minutes, status, asked_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
-      .run(id, 'TC', JSON.stringify(origin), askedAt + timeout, minutes, 'pending', askedAt);
+      .run(id, seat, JSON.stringify(origin), askedAt + timeout, minutes, 'pending', askedAt);
   } finally { store.close(); }
   try {
-    const result = await (deps.dispatch ?? dispatchCeoTask)('TC', `질문: ${body}\n답장 요청: ${id}\n회신: elanous seat answer ${id} "<답>"`, command,
+    const result = await (deps.dispatch ?? dispatchCeoTask)(seat, `${kind === 'question' ? '질문' : '일'}: ${body}\n답장 요청: ${id}\n회신: elanous seat answer ${id} "<답>"`, command,
       { via: origin.channel, ref: `ask:${id}` });
-    debug.log('seat.ask', 'sent', { seat: 'TC', id, via: origin.channel, channel: result.channel });
-    return `CTO에게 물었습니다. 답을 기다립니다 (최대 ${minutes}분). 요청: ${id}${result.channel === 'failed' ? ` · 조율 채널 전송 실패: ${result.channelError}` : ''}`;
+    debug.log('seat.ask', 'sent', { seat, id, via: origin.channel, channel: result.channel });
+    const title = seatTitle(seat);
+    return `${kind === 'question' ? `${title}에게 물었습니다. 답을 기다립니다` : `${title}에게 맡겼습니다. 결과를 이 대화로 돌려드립니다`} (최대 ${minutes}분). 요청: ${id}${result.channel === 'failed' ? ` · 조율 채널 전송 실패: ${result.channelError}` : ''}`;
   } catch (error) {
     const failed = (deps.open ?? openMsgStore)();
     try { createTable(failed); failed.db.query('DELETE FROM seat_asks WHERE id = ?').run(id); }
@@ -114,10 +130,11 @@ export function answerSeatAsk(id: string, text: string, deps: Pick<SeatAskDeps,
     createTable(store);
     const now = (deps.now ?? Date.now)();
     const updated = store.db.query(`UPDATE seat_asks SET answer = ?, answered_at = ?
-      WHERE id = ? AND seat = 'TC' AND status = 'pending' AND answer IS NULL AND deadline > ?`)
+      WHERE id = ? AND status = 'pending' AND answer IS NULL AND deadline > ?`)
       .run(answer, now, id, now);
     if (updated.changes !== 1) throw new Error(`seat ask not pending or deadline passed: ${id}`);
-    debug.log('seat.ask', 'reply-recorded', { seat: 'TC', id });
+    const row = store.db.query('SELECT seat FROM seat_asks WHERE id = ?').get(id) as { seat: string };
+    debug.log('seat.ask', 'reply-recorded', { seat: row.seat, id });
   } finally { store.close(); }
 }
 
@@ -133,6 +150,49 @@ export function seatAskReplyInfo(id: string, open: () => MsgStore = openMsgStore
   } finally { store.close(); }
 }
 
+export interface SeatAskRoundTrip {
+  id: string;
+  surface: AskOrigin['channel'];
+  askedAt: number | null;
+  answeredAt: number | null;
+  deliveredAt: number | null;
+  roundTripMs: number | null;
+  verdict: '10분 안' | '10분 넘음' | '미답' | '답 대기' | '전달 대기' | '시각 미상';
+}
+
+/** Read one row per CTO question, including undelivered and legacy rows. since is an epoch-millisecond lower bound. */
+export function listSeatAskRoundTrips({ since, now = Date.now(), open = openMsgStore }: {
+  since: number; now?: number; open?: () => MsgStore;
+}): SeatAskRoundTrip[] {
+  if (!Number.isFinite(since) || !Number.isFinite(now)) throw new Error('invalid seat ask time window');
+  const store = open();
+  try {
+    createTable(store);
+    const rows = store.db.query(`SELECT a.id, a.origin, a.asked_at, a.answered_at, a.deadline, a.status,
+      a.answer IS NOT NULL AS has_answer, o.status AS outbox_status, o.sent_at
+      FROM seat_asks a LEFT JOIN seat_ask_outbox o ON o.id = a.id
+      WHERE a.seat = 'TC' AND a.status != 'shadow'
+        AND COALESCE(a.asked_at, a.deadline - a.timeout_minutes * 60000) >= ?
+      ORDER BY COALESCE(a.asked_at, a.deadline - a.timeout_minutes * 60000) DESC, a.id DESC`)
+      .all(since) as Array<{ id: string; origin: string; asked_at: number | null; answered_at: number | null;
+        deadline: number; status: string; has_answer: number; outbox_status: string | null; sent_at: number | null }>;
+    return rows.map(row => {
+      const surface = (JSON.parse(row.origin) as AskOrigin).channel;
+      const deliveredAt = row.outbox_status === 'sent' ? row.sent_at : null;
+      const roundTripMs = row.answered_at === null || row.asked_at === null || deliveredAt === null ? null : deliveredAt - row.asked_at;
+      const verdict: SeatAskRoundTrip['verdict'] = row.asked_at === null ? '시각 미상'
+        : row.status === 'expired' || (!row.has_answer && row.status === 'pending' && now >= row.deadline) ? '미답'
+        : row.status === 'answered' || row.has_answer ? row.outbox_status === 'sent' && deliveredAt === null ? '시각 미상'
+          : deliveredAt === null ? '전달 대기'
+          : row.answered_at === null || roundTripMs === null ? '시각 미상'
+          : roundTripMs <= 600_000 ? '10분 안' : '10분 넘음'
+          : '답 대기';
+      return { id: row.id, surface, askedAt: row.asked_at, answeredAt: row.answered_at,
+        deliveredAt, roundTripMs, verdict };
+    });
+  } finally { store.close(); }
+}
+
 /** Deliver recorded seat answers or expiration notices via the original surface. */
 export async function deliverSeatAnswers(deps: SeatAskDeps & { askId?: string }): Promise<void> {
   const store = (deps.open ?? openMsgStore)();
@@ -150,9 +210,11 @@ export async function deliverSeatAnswers(deps: SeatAskDeps & { askId?: string })
         : reply && Date.parse(reply.created_at) < ask.deadline ? reply.body.slice(id.length + 2).trim() : '';
       const status = answer ? 'answered' : now >= ask.deadline ? 'expired' : null;
       if (!status) return null;
-      const text = status === 'answered' ? `CTO 답변 (${id}): ${answer}`
-        : `CTO 미답 (${id}): 아직 답 없음 (${ask.timeout_minutes}분 경과).`;
-      const updated = store.db.query("UPDATE seat_asks SET status = ? WHERE id = ? AND status = 'pending'").run(status, id);
+      const title = seatTitle(ask.seat as SeatId);
+      const text = status === 'answered' ? `${title} 답변 (${id}): ${answer}`
+        : `${title} 미답 (${id}): 아직 답 없음 (${ask.timeout_minutes}분 경과).`;
+      const updated = store.db.query("UPDATE seat_asks SET status = ?, answered_at = COALESCE(answered_at, ?) WHERE id = ? AND status = 'pending'")
+        .run(status, status === 'answered' && reply ? Date.parse(reply.created_at) : null, id);
       if (updated.changes !== 1) return null;
       store.db.query('INSERT INTO seat_ask_outbox (id, origin, text) VALUES (?, ?, ?)').run(id, ask.origin, text);
       return status;
@@ -184,7 +246,8 @@ export async function deliverSeatAnswers(deps: SeatAskDeps & { askId?: string })
       if (claimed.changes !== 1) continue;
       try {
         await deps.send(origin, item.text);
-        store.db.query("UPDATE seat_ask_outbox SET status = 'sent', claim_token = NULL WHERE id = ? AND claim_token = ?").run(item.id, token);
+        store.db.query("UPDATE seat_ask_outbox SET status = 'sent', sent_at = ?, claim_token = NULL WHERE id = ? AND claim_token = ?")
+          .run((deps.now ?? Date.now)(), item.id, token);
       } catch (error) {
         store.db.query('UPDATE seat_ask_outbox SET claim_until = 0, claim_token = NULL WHERE id = ? AND claim_token = ?').run(item.id, token);
         throw error;
@@ -209,7 +272,7 @@ export function acknowledgeSeatAnswers(clientId: string, ids: string[], open: ()
   const store = open();
   try {
     createTable(store);
-    const ack = store.db.query("UPDATE seat_ask_outbox SET status = 'sent' WHERE id = ? AND origin = ? AND status = 'pending'");
-    for (const id of ids) ack.run(id, JSON.stringify({ channel: 'pwa', clientId }));
+    const ack = store.db.query("UPDATE seat_ask_outbox SET status = 'sent', sent_at = ? WHERE id = ? AND origin = ? AND status = 'pending'");
+    for (const id of ids) ack.run(Date.now(), id, JSON.stringify({ channel: 'pwa', clientId }));
   } finally { store.close(); }
 }

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

@@ -6,7 +6,7 @@ import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot/track-agent.js';
 import { debug } from '../debug/log.js';
-import { surfaceEventsDbPath } from '../domains/surface-events.js';
+import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
 import { judgeNeighbor } from '../loops/neighbors.js';
 import { addHarnessQueue, harnessQueueIdForKey, harnessQueueOutcome, listHarnessQueue } from '../harness/harness-queue.js';
 import { isRescueAllowedAction } from '../steward/rescue.js';
@@ -68,7 +68,7 @@ export type SeatDeps = {
   now?: () => Date;
   read?: (path: string) => string;
   run?: (args: string[]) => Promise<string>;
-  enqueue?: (seat: string, text: string, root: string, idempotencyKey: string) => Promise<{ id: string }>;
+  enqueue?: (seat: string, text: string, root: string, idempotencyKey: string, item: SeatItem) => Promise<{ id: string }>;
   queueOutcome?: (id: string, root: string) => ReturnType<typeof harnessQueueOutcome>;
   queueItems?: (root: string) => ReturnType<typeof listHarnessQueue>;
   queueIdForKey?: (key: string, root: string) => string | undefined;
@@ -910,11 +910,11 @@ function neighborLastSeen(root: string, isolated: boolean, now: Date, wanted: Re
   if (!existsSync(path)) return last;
   const db = new Database(path, { readonly: true });
   try {
-    // Same outbound seat events and refs.seat as context day; unlike its 24h display window,
-    // look back across the whole journal so a genuinely old ACK can be judged absent.
+    // Read outbound seat context and loop heartbeats across the whole journal,
+    // unlike context day's 24h display window, so a genuinely old ACK can be judged absent.
     // Newest first and stop once every wanted seat has an ACK, so a long journal is not read and sorted in full each turn.
     const statement = db.prepare(`SELECT ts, refs FROM events
-      WHERE surface IN ('coord:channel', 'context:session') AND direction='outbound' AND ts<=? ORDER BY ts DESC`);
+      WHERE surface IN ('coord:channel', 'context:session', 'loop:heartbeat') AND direction='outbound' AND ts<=? ORDER BY ts DESC`);
     try {
       const events = statement.iterate(now.toISOString()) as Iterable<{ ts: string; refs: string | null }>;
       for (const event of events) {
@@ -996,6 +996,12 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   const directory = dirname(path);
   return withSeatLock(directory, async () => {
   const stateRoot = deps.root ?? effectiveInstanceRoot();
+  try {
+    const db = openSurfaceEventsDb(deps.root ? join(stateRoot, 'surface_events.db') : surfaceEventsDbPath());
+    try { recordEvent(db, { surface: 'loop:heartbeat', direction: 'outbound', kind: 'heartbeat',
+      text: `seat loop ${seat} heartbeat`, refs: JSON.stringify({ seat }), ts: now.toISOString() }); }
+    finally { db.close(); }
+  } 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;
   let turnError: unknown;
@@ -1556,7 +1562,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       }
       let queued: { id: string };
       try {
-        queued = await (deps.enqueue ?? ((assigned, text, root, idempotencyKey) => addHarnessQueue({ seat: assigned, say: text, idempotencyKey }, { root })))(seat, action.text, stateRoot, queueKey(seat, item));
+        queued = await (deps.enqueue ?? ((assigned, text, root, idempotencyKey) => addHarnessQueue({ seat: assigned, say: text, idempotencyKey }, { root })))(seat, action.text, stateRoot, queueKey(seat, item), item);
       } catch (error) {
         // Same key, different task body: never adopt the other work. Refuse this turn; the key frees once that item finishes.
         if (!/idempotency key collision/.test(String(error))) throw error;

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

@@ -12,6 +12,7 @@
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
 import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { recordAuthoredGoal } from './authored-goal-trace.js';
+import { findAskPathCandidates, type AskPathCandidateOptions } from './ask-path-candidates.js';
 import { retiredEntranceNotice, type EntranceDeclaration } from './entrance-registry.js';
 import {
   classifyConcurrentAuthoring,
@@ -164,6 +165,8 @@ export interface AskLaunchFlowDeps {
   /** ⛔ 못 얻으면 `null` — 같은 이유. */
   recentAuthoringSamples(): RecentAuthoringSample[] | null;
   authorGoal(args: readonly string[], options: Record<string, unknown>): Promise<AskAuthoredGoal>;
+  /** Code-search seam for the one automatic no-target-paths retry. */
+  findPathCandidates?: (askText: string, options: AskPathCandidateOptions) => ReturnType<typeof findAskPathCandidates>;
   /** AUTHOR-TRACE seam (tests). */
   recordAuthoredGoal?: typeof recordAuthoredGoal;
   /** Pod launches reserve a host slot before goal authoring begins. */
@@ -849,7 +852,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -868,7 +871,7 @@ export async function runAskLaunchFlow(
     };
     // ⭐ RFC §5 5단계 — 확인된 implement 저작만 활성 구현 그래프에 이름을 잇는다.
     observeFrontNodeEntry('author', { ...frontObservation, provenance: 'authoring-start' });
-    const authored = await deps.authorGoal([input.askText], {
+    const authored = await deps.authorGoal([authorAskText], {
       cwd: deps.cwd(),
       ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
       ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
@@ -1011,8 +1014,26 @@ export async function runAskLaunchFlow(
     const first = authored;
     reauthored = true;
     deps.print('[ask] ⑴ ⚠️ 대상 경로를 못 찾아 자동 재저작 한 번을 시도한다');
-    authored = await authorAndPreflight();
+    let candidates: ReturnType<typeof findAskPathCandidates> = { tokens: [], paths: [] };
+    if (parseAskTargetPathHintsResult(input.askText).labelMissing) {
+      try {
+        candidates = (deps.findPathCandidates ?? findAskPathCandidates)(input.askText, { cwd: deps.cwd() });
+      } catch (error) {
+        candidates = { tokens: [], paths: [], error: error instanceof Error ? error.message : String(error) };
+      }
+      deps.log('ask-auto-target-candidates', {
+        tokens: candidates.tokens, paths: candidates.paths,
+        ...(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(' · ')}`);
+    }
+    authored = await authorAndPreflight(candidates.paths.length > 0
+      ? `대상 경로: ${candidates.paths.join(' · ')}\n${input.askText}`
+      : input.askText);
     deps.log('ask-auto-reauthor', {
+      candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,
       secondGoalFile: authored.goalFile,
       firstPathCount: first.decision.result.paths.length,

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

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+
+export interface AskPathCandidateOptions {
+  readonly cwd: string;
+  readonly run?: (command: string, args: readonly string[], options: { cwd: string; encoding: 'utf8' }) => string;
+}
+
+export type AskPathCandidates =
+  | { readonly tokens: string[]; readonly paths: string[]; readonly error?: undefined }
+  | { readonly tokens: string[]; readonly paths: string[]; readonly error: string };
+
+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;
+
+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;
+  const absolute = resolve(cwd, path);
+  const rel = relative(cwd, absolute);
+  if (!rel || rel.startsWith('..') || isAbsolute(rel)) return null;
+  try { return statSync(absolute).isFile() ? rel.split('\\').join('/') : null; }
+  catch { return null; }
+}
+
+/** Find existing code paths by lexical evidence from an unmodified ask. */
+export function findAskPathCandidates(askText: string, { cwd, run = execFileSync }: AskPathCandidateOptions): AskPathCandidates {
+  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]);
+  for (const chunk of chunks) {
+    for (const match of chunk.matchAll(WORD)) {
+      const raw = match[0];
+      const token = raw.replace(/^\//, '');
+      const file = existingFile(token, cwd);
+      if (file) {
+        const hits = scores.get(file) ?? new Set<string>();
+        hits.add(token);
+        scores.set(file, hits);
+      }
+      if (STOP_WORDS.has(token.toLowerCase()) || 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);
+      tokens.push(token);
+    }
+  }
+  for (const token of tokens) {
+    let matches: string;
+    try {
+      matches = run('rg', ['-l', '-F', '--glob', '!*.test.ts', '--', token, 'src', 'scripts'], { cwd, encoding: 'utf8' });
+    } catch (error) {
+      if ((error as { status?: number }).status === 1) continue; // rg: no matches
+      return { tokens, paths: [], error: error instanceof Error ? error.message : String(error) };
+    }
+    for (const path of matches.split(/\r?\n/).filter(Boolean)) {
+      const hits = scores.get(path) ?? new Set<string>();
+      hits.add(token);
+      scores.set(path, hits);
+    }
+  }
+  return {
+    tokens,
+    paths: [...scores].sort(([a, aHits], [b, bHits]) => bHits.size - aHits.size || a.localeCompare(b, 'en')).slice(0, 5).map(([path]) => path),
+  };
+}

package/src/self-dev/dev-pipeline.ts

@@ -721,6 +721,8 @@ export function buildSelfImplementDevSpec(o: {
   ground?: boolean;
   draft: boolean;
   autoMerge?: boolean;
+  /** Pod child: stop at merge-ready so the launching host re-gates (and checks the landing freeze) before merging. */
+  mergeByHost?: boolean;
   openPr?: boolean;
   autoReview?: boolean;
   autoReviewSource?: DevSelectionSource;
@@ -755,6 +757,8 @@ export function buildSelfImplementDevSpec(o: {
     ...(o.runId ? { runId: o.runId } : {}),
     self: {
       draft: o.draft,
+      // FREEZE-POD: this flag used to be dropped here, so `self implement --merge-by-host` in a Pod merged by itself (#24478).
+      ...(o.mergeByHost === true ? { mergeByHost: true } : {}),
       ...(o.childLlm ? { childLlm: o.childLlm } : {}),
       ...(o.maxWaitSec !== undefined ? { maxWaitSec: o.maxWaitSec } : {}),
       ...(o.ground ? { ground: true } : {}),

package/src/self-dev/draft-triage-rules.ts

@@ -31,7 +31,7 @@ export type DraftDecision = { action: 'close' | 'keep'; reason: string };
 
 // Labels the sweeper must never close: an approval-waiting state and the human «keep» / release holds (R-PRK3).
 // RELGUARD's release-path hold waits for OP approval — a long wait is not «stale» (TC review #23217).
-const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
+export const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
   .filter((label) => label.sweep.action === 'exclude' || (label.sweep.action === 'none' && (label.axis === 'state' || label.axis === 'addon')))
   .map((label) => label.name), RELEASE_PATH_LABEL]);
 

package/src/self-dev/orchestrate-cli.ts

@@ -16,6 +16,7 @@ import { resolveOrchestrateConcurrency } from './orchestrate.js';
 import type { FailureClassification, SelfDevGoal, SelfDevJobResult } from './orchestrate.js';
 import { superviseRun, type SupervisorDecision } from './run-supervisor.js';
 import { readDecomposeProposals, applyDecomposeProposals } from './decompose-proposal.js';
+import { createRoundPrTracker, defaultRoundPrAdapters, type RoundPrAdapters } from './round-pr-supersede.js';
 import { createHash } from 'node:crypto';
 import { debug } from '../debug/log.js';
 
@@ -211,6 +212,8 @@ export interface OrchestrateCliDeps {
   pipelineDeps?: DevPipelineDeps;
   /** 분해 제안과 골 개정 시도 되채움 조회(테스트 주입). 기본 readDecomposeProposals(원장). */
   readProposals?: typeof readDecomposeProposals;
+  /** DRAFT-TRIAGE — gh seams for superseding the previous supervisor round's draft PR (tests). */
+  roundPrAdapters?: RoundPrAdapters;
 }
 
 /**
@@ -399,6 +402,23 @@ export async function runSelfOrchestrateCliCommand(
       };
       // ⭐ 루프는 «공용»이다(run-supervisor.superviseRun) — 단일 실행도 같은 자를 쓴다.
       //   ⛔ 여기가 아는 것은 「어떻게 다시 거나」뿐이고, 「걸까 말까」는 그 자가 안다.
+      // DRAFT-TRIAGE — a rework round of the same goal opens a new PR; the previous round's draft is superseded.
+      let roundPrTracker: ReturnType<typeof createRoundPrTracker> | undefined;
+      let supervisedRound = 0;
+      const recordRoundPrs = async (rs: readonly SelfDevJobResult[]): Promise<void> => {
+        try {
+          // Once a PR is tracked, every round runs — an unfinished supersede is retried even without a new PR.
+          if (!roundPrTracker && !rs.some((r) => r.prUrl)) return;
+          roundPrTracker ??= createRoundPrTracker({
+            runId: process.env.ELANOUS_RUN_ID ?? rs.find((r) => r.runId?.trim())?.runId ?? null,
+            adapters: deps.roundPrAdapters ?? await defaultRoundPrAdapters(),
+          });
+          roundPrTracker.record(rs, supervisedRound);
+        } catch (error) {
+          try { debug.log('self-dev.supervisor', 'round-pr-record-failed', { round: supervisedRound, error: String(error) }); } catch { /* fail-open */ }
+        }
+      };
+      await recordRoundPrs(results);
       results = await superviseRun({
         initial: results,
         limits,
@@ -467,6 +487,8 @@ export async function runSelfOrchestrateCliCommand(
           const resumeHold = currentDecision?.needsHuman ?? [];
           const next = await exec(spec, { ...baseRuntime, resumeFrom: [...previous], ...(resumeHold.length > 0 ? { resumeHold } : {}) }, pipelineDeps);
           exitCode = next.exitCode;
+          supervisedRound += 1;
+          await recordRoundPrs(next.results);
           return next.results;
         },
       });