elanous 0.2.12 → 0.2.13

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

@@ -1,5 +1,5 @@
 import { execFile } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
 import { dirname, join, resolve } from 'node:path';
@@ -8,13 +8,15 @@ import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot
 import { debug } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
+import { loopEvent } from '../loops/observe.js';
 import { getUserConfig, type PersonaLoopConfig, type SeatLoopConfig, type UserConfig } from '../user-config.js';
 import { checkSeatBudget, type RunningSeatPod } from '../org/seat-budget.js';
 import { DEFAULT_STALL_PARENTS, findStalls } from '../org/stall-escalation.js';
 import { openMsgStore, type MessageEnvelope } from '../msg/msg-store.js';
 import { loadLayeredPersonaDirs, resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
-import { nextPersonaTodo, personaTodoPath, readPersonaTodos, type PersonaTodo } from '../persona/persona-todo.js';
+import { orderedPersonaTodos, personaTodoPath, readPersonaTodos, type PersonaTodo } from '../persona/persona-todo.js';
 import { PersonaRegistry } from '../persona/registry.js';
+import { recordSeatAskShadow } from '../seat-dispatch/seat-ask.js';
 import { answerSeat, askSeat, deliveredSeatQuestion, hasSeatAnswer, isSeatId, seatQuestions, type SeatId } from '../seat-dispatch/seat-questions.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
@@ -33,11 +35,12 @@ export type OpCandidate =
   | { kind: 'decision-delegation'; id: string | null; title?: string; category?: DecisionEntry['category']; dueAt?: string; verdict: 'review-delegation' | 'none' };
 export type TcCandidate =
   | { kind: 'merged-pr-yellow-cell'; version: string; id: string; title: string; pr: number; mergedAt: string }
-  | { kind: 'publication-pr-approval-wait'; pr: number; title: string; readyAt: string; approvalWaitAt: string; paths: string[] };
+  | { 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; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate; action?: SeatAction; reason?: string; runId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean };
 export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off' };
-export type PersonaShadowEntry = { personaId: string; ts: string; status: 'shadow' | 'skipped-empty'; todo: PersonaTodo | null };
+export type PersonaShadowEntry = { personaId: string; ts: string; status: 'shadow' | 'skipped-empty'; todo: PersonaTodo | null; action?: 'decision' | 'harness' | 'wait'; what?: string };
 export type SeatDeps = {
   personaConfig?: PersonaLoopConfig;
   personaRegistry?: PersonaRegistry;
@@ -134,8 +137,17 @@ export function personaShadowLedgerPath(personaId: string, root: string, now: Da
   return join(root, 'persona-loop', personaId, `${seatDay(now)}.jsonl`);
 }
 
+export async function runPersonaLoopOnce(name: string, deps: SeatDeps = {}): Promise<PersonaShadowEntry> {
+  const entries = await pickPersonaShadows(deps, name);
+  return entries[0]!;
+}
+
 export async function runPersonaShadowOnce(deps: SeatDeps = {}): Promise<PersonaShadowEntry[]> {
   if ((deps.personaConfig ?? getUserConfig().loops?.persona)?.enabled !== true) return [];
+  return pickPersonaShadows(deps);
+}
+
+async function pickPersonaShadows(deps: SeatDeps, name?: string): Promise<PersonaShadowEntry[]> {
   const root = deps.root ?? effectiveInstanceRoot();
   const dir = deps.personaDir ?? (deps.root ? join(root, 'personas') : resolveStatePersonaDir());
   const registry = deps.personaRegistry ?? new PersonaRegistry();
@@ -145,19 +157,31 @@ export async function runPersonaShadowOnce(deps: SeatDeps = {}): Promise<Persona
   }
   const now = (deps.now ?? (() => new Date()))();
   const entries: PersonaShadowEntry[] = [];
-  for (const profile of registry.list().sort((a, b) => a.personaId.localeCompare(b.personaId))) {
+  const profiles = registry.list().sort((a, b) => a.personaId.localeCompare(b.personaId));
+  const selected = name === undefined ? profiles : profiles.filter((profile) => profile.personaId.toLowerCase() === name.trim().toLowerCase()
+    || profile.displayName.toLowerCase() === name.trim().toLowerCase());
+  if (name !== undefined && selected.length !== 1) throw new Error(selected.length ? `ambiguous persona name: ${name}` : `persona not found: ${name}`);
+  for (const profile of selected) {
     const personaId = profile.personaId;
-    const { todos, errors } = readPersonaTodos(dir, personaId);
+    const todoFile = profile.todo ?? `${personaId}.todo.jsonl`;
+    const { todos, errors } = readPersonaTodos(dir, todoFile.slice(0, -'.todo.jsonl'.length));
     for (const error of errors) observe('persona-todo-error', { personaId, error });
-    const todo = nextPersonaTodo(todos);
-    const entry: PersonaShadowEntry = { personaId, ts: now.toISOString(), status: todo ? 'shadow' : 'skipped-empty', todo };
+    const candidates = orderedPersonaTodos(todos);
+    const picked = pickNext({ requests: candidates.map((candidate) => ({
+      source: 'request', id: candidate.id, title: candidate.title, text: candidate.title, createdAt: candidate.createdAt,
+    })), checklist: [], role: '' }, [], { shadow: true });
+    const todo = picked ? candidates.find((candidate) => candidate.id === picked.id) ?? null : null;
+    const planned = name !== undefined && todo && picked ? planAction(picked, profile.seat) : undefined;
+    const entry: PersonaShadowEntry = { personaId, ts: now.toISOString(), status: todo ? 'shadow' : 'skipped-empty', todo,
+      ...(planned ? { action: planned.kind, what: planned.text } : {}) };
     const path = personaShadowLedgerPath(personaId, root, now);
     if (deps.appendPersona) deps.appendPersona(path, entry);
     else {
       mkdirSync(dirname(path), { recursive: true });
       appendFileSync(path, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
     }
-    observe('persona-shadow', { personaId, status: entry.status, todoId: todo?.id ?? null });
+    try { debug.log('persona.loop', 'picked', { personaId, status: entry.status, todoId: todo?.id ?? null, title: todo?.title ?? null, action: entry.action ?? null }); }
+    catch { /* observation cannot alter the shadow ledger */ }
     entries.push(entry);
   }
   return entries;
@@ -167,6 +191,25 @@ export async function runSeatLoopTurn(seat: string, deps: SeatDeps = {}): Promis
   const result = await runSeatLoopOnce(seat, deps);
   try { await runPersonaShadowOnce(deps); }
   catch (error) { observe('persona-shadow-error', { error: String(error).slice(0, 200) }); }
+  try {
+    const config = deps.config ?? getUserConfig().loops?.seat ?? { mode: 'off' };
+    const profile = result.status === 'skipped-off' ? 'off' : config.mode;
+    const context = { runId: 'runId' in result && result.runId ? result.runId : `seat-turn-${randomUUID()}`,
+      profile, sourceRef: `docs/roles/${seat}.md` };
+    const loopId = `${seat.toLowerCase()}-seat`;
+    loopEvent(loopId, 'tick', { ...context, outcome: result.status, reason: result.status });
+    if ('inquiry' in result && result.inquiry && (result.status === 'asked' || result.status === 'hitl')) {
+      loopEvent(loopId, 'exchange', { ...context, outcome: result.status, reason: 'delegation',
+        from: seat, to: result.inquiry.to, itemId: result.item?.id });
+    }
+    if ('escalated' in result && result.escalated && result.status === 'skipped-budget') {
+      loopEvent(loopId, 'exchange', { ...context, outcome: result.status, reason: 'delegation',
+        from: seat, to: (config.stall?.parents ?? {})[seat] ?? DEFAULT_STALL_PARENTS[seat], itemId: result.item?.id });
+    } else if (result.status === 'skipped-budget') {
+      loopEvent(loopId, 'exchange', { ...context, outcome: result.status, reason: 'requeue',
+        itemId: result.item?.id });
+    }
+  } catch { /* observation cannot change a completed seat turn */ }
   return result;
 }
 
@@ -198,6 +241,8 @@ function decisionReceipt(root: string, seat: string, item: SeatItem): DecisionEn
 function handledKeys(ledger: readonly SeatEntry[], shadow: boolean, root?: string): Set<string> {
   const inquiryRow = (entry: SeatEntry) => entry.action === 'seat-question' || entry.action === 'seat-answer' || !!entry.inquiry;
   return new Set(ledger.filter((entry, index) => entry.status === 'asked' || entry.status === 'answered'
+    // RM3a: only TC's other-seat defect ask-shadows are deduplicated here — an ordinary inquiry recorded in shadow must still be delivered once questions turn on.
+    || (entry.status === 'shadow' && entry.candidate?.kind === 'other-seat-cell-defect')
     || (entry.status === 'hitl' && (!entry.inquiry || (!!root && !!entry.item && !!decisionReceipt(root, entry.seat, entry.item))))
     || (entry.inquiry?.to === 'CEO' && !!root && !!entry.item && !!decisionReceipt(root, entry.seat, entry.item))
     || (!inquiryRow(entry) && entry.status === 'outcome-unknown')
@@ -303,9 +348,10 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
     debug.log('seat.loop', 'schedule-unreadable', { seat, error: String(error).slice(0, 200) });
   }
   const checklist: SeatItem[] = [];
+  const closed: string[] = [];
   for (const version of open === null ? [] : versions().sort(versionOrder)) {
     if (!open!.has(version)) {
-      debug.log('seat.loop', 'skip-closed-version', { seat, version });
+      closed.push(version);
       continue;
     }
     let items: ReturnType<typeof itemsOf>;
@@ -325,6 +371,9 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
       }
     }
   }
+  if (closed.length > 0) {
+    debug.log('seat.loop', 'skip-closed-versions', { seat, count: closed.length, newest: closed.at(-1)!, oldest: closed[0]! });
+  }
   checklist.sort((a, b) => versionOrder(a.version!, b.version!) || a.id.localeCompare(b.id));
   return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
 }
@@ -375,7 +424,7 @@ function readTcChecklist(root: string): Array<{ version: string; id: string; tit
   const db = new Database(path, { readonly: true, strict: true });
   try {
     return db.query(`SELECT a.version, f.id, COALESCE(a.title_override, f.title) AS title, a.status, a.owner
-      FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.status = 'yellow' AND a.owner = 'TC'
+      FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.status IN ('yellow', 'red') AND a.owner IN ('OP', 'TC', 'MK', 'UX')
       ORDER BY a.version, f.id`).all() as Array<{ version: string; id: string; title: string; status: string; owner: string | null }>;
   } finally { db.close(); }
 }
@@ -461,16 +510,27 @@ async function tcCandidates(deps: SeatDeps, now: Date): Promise<TcCandidate[]> {
   const candidates: TcCandidate[] = [];
   const releaseRoot = deps.root ?? releaseLedgerRoot();
   try {
-    const cells = merged.length === 0 ? [] : deps.checklistItems && deps.schedules
+    const cells = deps.checklistItems && deps.schedules
       ? deps.schedules().flatMap(({ version }) => deps.checklistItems!(version).map((cell) => ({ ...cell, version })))
       : readTcChecklist(releaseRoot);
+    let shipped: string | undefined;
+    try { shipped = releasedVersion(releaseRoot); }
+    catch (error) { observe('tc-release-unreadable', { seat: 'TC', error: String(error).slice(0, 200) }); }
+    const openVersions = deps.schedules ? new Set(deps.schedules().filter(({ cutAt }) => Number.isFinite(Date.parse(cutAt))
+      && Date.parse(cutAt) > now.getTime()).map(({ version }) => version)) : null;
     for (const cell of cells) {
-      if (cell.owner !== 'TC' || cell.status !== 'yellow') continue;
+      if (cell.owner !== 'TC' && ((shipped && versionOrder(cell.version, shipped) <= 0) || (openVersions && !openVersions.has(cell.version)))) continue;
+      if (cell.status !== 'yellow' && cell.status !== 'red') continue;
+      if (!cell.owner || !isSeatId(cell.owner)) continue;
+      if (cell.owner !== 'TC') {
+        if (cell.status === 'red') candidates.push({ kind: 'other-seat-cell-defect', version: cell.version, id: cell.id, title: cell.title, to: cell.owner });
+        continue;
+      }
       for (const pr of merged) {
         const id = cell.id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const reference = new RegExp(`(?<![A-Za-z0-9])${id}(?![A-Za-z0-9])`);
         if (reference.test(pr.title) || reference.test(pr.body ?? '')) {
-          candidates.push({ kind: 'merged-pr-yellow-cell', version: cell.version, id: cell.id, title: cell.title, pr: pr.number, mergedAt: pr.mergedAt! });
+          if (cell.owner === 'TC' && cell.status === 'yellow') candidates.push({ kind: 'merged-pr-yellow-cell', version: cell.version, id: cell.id, title: cell.title, pr: pr.number, mergedAt: pr.mergedAt! });
         }
       }
     }
@@ -624,6 +684,20 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   if (seat === 'TC') {
     const candidates = await tcCandidates(deps, now);
     for (const candidate of candidates) {
+      if (candidate.kind === 'other-seat-cell-defect') {
+        const question = `${candidate.version} 체크리스트 ${candidate.id} · ${candidate.title}: ${candidate.to} 칸 결함을 확인해 주세요.`;
+        const recorded = recordSeatAskShadow(stateRoot, { from: 'TC', to: candidate.to, itemId: candidate.id, version: candidate.version, question }, now.getTime());
+        const inLedger = ledger.some((row) => row.status === 'shadow' && row.candidate?.kind === 'other-seat-cell-defect'
+          && row.candidate.version === candidate.version && row.candidate.id === candidate.id && row.candidate.to === candidate.to);
+        if (!inLedger) {
+          const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate,
+            item: { source: 'checklist', kind: 'cell', id: candidate.id, title: candidate.title, text: candidate.title, version: candidate.version, seat: candidate.to },
+            action: 'seat-question', inquiry: { to: candidate.to, question } };
+          (deps.append ?? defaultAppend)(path, entry);
+        }
+        if (!inLedger || recorded) observe('ask-shadow', { from: seat, to: candidate.to, itemId: candidate.id });
+        continue;
+      }
       if (ledger.some((row) => row.status === 'shadow' && JSON.stringify(row.candidate) === JSON.stringify(candidate))) continue;
       const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate };
       (deps.append ?? defaultAppend)(path, entry);
@@ -761,7 +835,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
               await run(['decisions', 'raise', '--title', `${seat}: ${ask.question}`, '--category', 'other',
                 '--s', `${seat} 질문 · ${item.title}`, '--c', '판단 근거 부족 — 사람의 결정이 필요하다',
                 '--option', 'a=승인:사람 판단으로 진행', '--option', 'b=보류:진행하지 않음',
-                '--skip-recommend', '근거가 부족하다', '--agent', 'seat-loop', '--ref', decisionRef(seat, item), '--json']);
+                '--skip-recommend', '근거가 부족하다', '--no-xcheck', '자리 루프 · 이웃 교환은 DEC-XCHECK ②', '--agent', 'seat-loop', '--ref', decisionRef(seat, item), '--json']);
             }
             if (!decisionReceipt(root, seat, item)) throw new Error('decisions raise did not deliver a matching card');
             entry.status = 'hitl';
@@ -866,7 +940,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       const raised = await run(['decisions', 'raise', '--title', title, '--category', 'other',
         '--s', `${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')}\n역할: ${inputs.role}`, '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
         '--option', 'a=사람 승인:승인 후 별도로 집행', '--option', 'b=보류:집행하지 않음',
-        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--agent', 'seat-loop', '--json']);
+        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--no-xcheck', '자리 루프 · 이웃 교환은 DEC-XCHECK ②', '--agent', 'seat-loop', '--json']);
       const decision: unknown = JSON.parse(raised.trim());
       if (!decision || typeof decision !== 'object' || typeof (decision as { id?: unknown }).id !== 'string') {
         throw new Error('decisions raise returned no decision id');

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

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { userInfo } from 'node:os';
+import { DEFAULT_CONCURRENT_PODS, DEFAULT_DAILY_GOALS } from '../org/seat-budget.js';
+
+export interface SeatPackManifest {
+  name: string;
+  version: string;
+  files: Array<{ path: string; sha256: string }>;
+}
+
+export class SeatPackLeakError extends Error {
+  constructor(file: string, line: number, marker: string) {
+    super(`${file}:${line}: public leak (${marker})`);
+  }
+}
+
+function regularFile(path: string): boolean {
+  return lstatSync(path).isFile();
+}
+
+function walk(directory: string, root: string): string[] {
+  if (!existsSync(directory)) return [];
+  if (!lstatSync(directory).isDirectory()) throw new Error(`not a directory: ${relative(root, directory)}`);
+  return readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+    .flatMap((entry) => {
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`symlink in seat pack: ${relative(root, path)}`);
+      return entry.isDirectory() ? walk(path, root) : entry.isFile() ? [relative(root, path)] : [];
+    });
+}
+
+function scan(file: string, body: string): void {
+  const usernames = new Set([userInfo().username, process.env.ELANOUS_LEAK_HOME_USER].filter((name): name is string => Boolean(name)));
+  const accountPatterns = [...usernames].map((name) => new RegExp(`(?<![A-Za-z0-9._-])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9._-])`, 'iu'));
+  const patterns: Array<[string, RegExp]> = [
+    ['royal marker', /\u{1F451}/u],
+    ['track marker', /(?:🅞|🅣|🅢|🅕|\*\*\[(?:OP|TC|MK|UX|S|T|O|F)\]\*\*|\[(?:OP|TC|MK|UX|S|T|O|F)\])/u],
+    ['absolute user path', /\/Users\/[A-Za-z0-9._-]+/u],
+    ...accountPatterns.map((pattern): [string, RegExp] => ['account name', pattern]),
+  ];
+  for (const [index, line] of body.split(/\r?\n/u).entries()) {
+    for (const [marker, pattern] of patterns) {
+      if (pattern.test(line)) throw new SeatPackLeakError(file, index + 1, marker);
+    }
+  }
+}
+
+/** Build from charters, explicitly referenced seat graphs and the seat's own `graphs/<seat>/` folder; never copy an entire shared graph directory by default. */
+export function exportSeatPack(seat: string, out: string, root = resolve(import.meta.dir, '../..')): SeatPackManifest {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/u.test(seat)) throw new Error(`invalid seat: ${seat}`);
+  const repo = resolve(root);
+  const output = resolve(out);
+  const roles = join(repo, 'docs', 'roles');
+  const charter = join(roles, `${seat}.md`);
+  if (!existsSync(charter) || !regularFile(charter)) throw new Error(`seat charter not found: docs/roles/${seat}.md`);
+  const roleFiles = [`docs/roles/${seat}.md`, ...walk(join(roles, seat), repo).filter((file) => file.endsWith('.md'))];
+  const graphFiles = new Set<string>();
+  const contents = new Map<string, Buffer>();
+  for (const file of roleFiles) {
+    const body = readFileSync(join(repo, file));
+    contents.set(file, body);
+    for (const match of body.toString('utf8').matchAll(/graphs\/([A-Za-z0-9_./-]+(?:\.ya?ml|\/\*\*))/gu)) {
+      const ref = `graphs/${match[1]!}`;
+      if (ref.split('/').includes('..')) throw new Error(`invalid seat graph: ${ref}`);
+      if (ref.endsWith('/**')) {
+        if (!existsSync(join(repo, ref.slice(0, -3)))) throw new Error(`seat graph not found: ${ref}`);
+        for (const graph of walk(join(repo, ref.slice(0, -3)), repo)) {
+          if (/\.ya?ml$/u.test(graph)) graphFiles.add(graph);
+        }
+      } else graphFiles.add(ref);
+    }
+  }
+  // A seat's own graph folder (`graphs/<seat in lower case>/`) belongs to the seat even when the
+  // charter no longer mentions it — inclusion must not hinge on a text reference that can be edited away.
+  const ownGraphs = join(repo, 'graphs', seat.toLowerCase());
+  if (existsSync(ownGraphs)) {
+    for (const graph of walk(ownGraphs, repo)) if (/\.ya?ml$/u.test(graph)) graphFiles.add(graph);
+  }
+  for (const file of graphFiles) {
+    const path = join(repo, file);
+    if (!existsSync(path) || !regularFile(path)) throw new Error(`seat graph not found: ${file}`);
+    contents.set(file, readFileSync(path));
+  }
+  const verdicts = roleFiles.flatMap((file) => contents.get(file)!.toString('utf8').split(/\r?\n/u)
+    .filter((line) => /\|\s*판정선\s*\|/u.test(line)).map((line) => ({ source: file, text: line.split('|').slice(2, -1).join('|').trim() })));
+  for (const file of roleFiles) {
+    const charter = contents.get(file)!.toString('utf8');
+    for (const match of charter.matchAll(/(?:^|\n)\s*[-*]\s*\*\*(?:관문|판정선)\*\*\s*[—:-]\s*([^\n]+)/gu)) {
+      verdicts.push({ source: file, text: match[1]!.trim() });
+    }
+    let inGateSection = false;
+    for (const line of charter.split(/\r?\n/u)) {
+      if (/^##\s+\d+\.\s+관문(?:\s|\(|$)/u.test(line)) { inGateSection = true; continue; }
+      if (/^##\s/u.test(line)) inGateSection = false;
+      if (!inGateSection) continue;
+      const bullet = line.match(/^\s*[-*]\s+(.+)$/u);
+      if (bullet) verdicts.push({ source: file, text: bullet[1]!.trim() });
+    }
+  }
+  if (verdicts.length === 0) throw new Error(`seat verdict not found for ${seat}`);
+  contents.set('verdicts.json', Buffer.from(`${JSON.stringify(verdicts, null, 2)}\n`));
+  contents.set('budget.json', Buffer.from(`${JSON.stringify({ dailyGoals: DEFAULT_DAILY_GOALS, concurrentPods: DEFAULT_CONCURRENT_PODS }, null, 2)}\n`));
+  const version = (JSON.parse(readFileSync(join(repo, 'package.json'), 'utf8')) as { version: string }).version;
+  const files = [...contents].sort(([a], [b]) => a.localeCompare(b)).map(([path, body]) => ({
+    path, sha256: createHash('sha256').update(body).digest('hex'),
+  }));
+  const manifest: SeatPackManifest = { name: seat, version, files };
+  const manifestBody = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
+  for (const [file, body] of [...contents, ['manifest.json', manifestBody] as [string, Buffer]]) scan(file, body.toString('utf8'));
+  if (existsSync(output)) {
+    if (!lstatSync(output).isDirectory() || readdirSync(output).length > 0) throw new Error(`output must be an empty directory: ${output}`);
+  }
+  const sources = [roles, join(repo, 'graphs')];
+  if (output === repo || sources.some((source) => output === source || source.startsWith(`${output}${sep}`) || output.startsWith(`${source}${sep}`))) {
+    throw new Error('output overlaps seat pack sources');
+  }
+  mkdirSync(output, { recursive: true });
+  for (const [file, body] of contents) {
+    const dest = join(output, file);
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, body);
+  }
+  writeFileSync(join(output, 'manifest.json'), manifestBody);
+  return manifest;
+}

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

@@ -158,6 +158,8 @@ export interface AskLaunchFlowDeps {
   /** ⛔ 못 얻으면 `null` — 같은 이유. */
   recentAuthoringSamples(): RecentAuthoringSample[] | null;
   authorGoal(args: readonly string[], options: Record<string, unknown>): Promise<AskAuthoredGoal>;
+  /** Pod launches reserve a host slot before goal authoring begins. */
+  beforeAuthoring?(): Promise<void>;
   /** 발사 전 권고용 분해 seam. 생략하면 전용 관측명을 준 기존 분해기를 쓴다. */
   decomposeGoal?(goal: string): Promise<SelfDevDecomposition>;
   /**
@@ -825,6 +827,7 @@ export async function runAskLaunchFlow(
   const launchPreflight = await runPrePreflight(input, deps);
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
+  await deps.beforeAuthoring?.();
   const authorAndPreflight = async (): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;

package/src/self-implement/l8-merge-queue.ts

@@ -1,8 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { NEXT_MD_PATH, resolveNextMdConflict } from '../release-loop/next-md-merge.js';
+import { getDefaultLogStore } from '../mss/logging/log-store.js';
 
 type Command = (bin: string, args: readonly string[], cwd: string) => { status: number | null; stdout: string; stderr: string };
 export type L8MergeQueueInput = { number: number; cwd: string; matchHeadCommit: string };
@@ -13,6 +14,161 @@ export type L8MergeQueueDeps = {
   acquire?: (cwd: string) => Promise<() => void>;
 };
 
+export type L8ShadowVerdict = { number: number; head: string; base?: string; verdict: 'pass' | 'conflict' | 'fail'; detail?: string; tests: string[]; at: string };
+export type L8ShadowQueueState = { pending: { number: number; head: string }[]; verdicts: L8ShadowVerdict[] };
+export type L8ShadowQueueDeps = L8MergeQueueDeps & { observe?: (verdict: L8ShadowVerdict) => void | Promise<void> };
+
+function shadowCommand(execute: Command, bin: string, args: string[], cwd: string): string {
+  const result = execute(bin, args, cwd);
+  if (result.status !== 0) throw new Error(`${bin} ${args.join(' ')}: ${(result.stderr || result.stdout || `exit ${result.status}`).trim().slice(0, 500)}`);
+  return args.includes('-z') ? result.stdout : result.stdout.trim();
+}
+
+function shadowQueuePath(cwd: string, execute: Command): string {
+  const dir = shadowCommand(execute, 'git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd);
+  if (!dir) throw new Error('merge queue common git directory unavailable');
+  return join(dir, 'elanous-l8-shadow-queue.json');
+}
+
+function readShadowQueue(path: string): L8ShadowQueueState {
+  if (!existsSync(path)) return { pending: [], verdicts: [] };
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!value || typeof value !== 'object' || !('pending' in value) || !Array.isArray(value.pending)
+    || !value.pending.every((p: { number?: number; head?: string }) => Number.isSafeInteger(p?.number) && p.number! > 0 && typeof p.head === 'string' && /^[0-9a-f]{40}$/i.test(p.head))
+    || !('verdicts' in value) || !Array.isArray(value.verdicts)) throw new Error('invalid shadow queue ledger');
+  return value as L8ShadowQueueState;
+}
+
+function writeShadowQueue(path: string, state: L8ShadowQueueState): void {
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(state, null, 2) + '\n', { flag: 'wx' });
+    renameSync(temp, path);
+  } finally { rmSync(temp, { force: true }); }
+}
+
+async function withShadowQueue<T>(cwd: string, deps: L8ShadowQueueDeps, fn: (state: L8ShadowQueueState, path: string) => Promise<T>): Promise<T> {
+  const release = await (deps.acquire ?? acquireL8MergeQueue)(cwd);
+  try {
+    const path = shadowQueuePath(cwd, deps.command ?? command);
+    return await fn(readShadowQueue(path), path);
+  } finally { release(); }
+}
+
+export function shadowPrNumber(raw: string): number {
+  const text = raw.replace(/^#/, '');
+  const number = Number(text);
+  if (!/^[1-9]\d*$/.test(text) || !Number.isSafeInteger(number)) throw new Error('expected a positive PR number');
+  return number;
+}
+
+export async function statusL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowQueueState> {
+  return withShadowQueue(cwd, deps, async (state) => state);
+}
+
+export async function enqueueL8ShadowQueue(cwd: string, number: number, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowQueueState> {
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error('expected a positive PR number');
+  return withShadowQueue(cwd, deps, async (state, path) => {
+    const execute = deps.command ?? command;
+    const view = JSON.parse(shadowCommand(execute, 'gh', ['pr', 'view', String(number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'], cwd)) as {
+      headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+    };
+    if (!view.headRefOid || !/^[0-9a-f]{40}$/i.test(view.headRefOid) || view.baseRefName !== 'main'
+      || view.state !== 'OPEN' || view.isDraft !== false || view.isCrossRepository !== false) throw new Error('PR is not an open, ready, same-repository main PR');
+    if (state.pending.some((p) => p.number === number)) throw new Error(`PR #${number} already queued`);
+    state.pending.push({ number, head: view.headRefOid });
+    writeShadowQueue(path, state);
+    return state;
+  });
+}
+
+/** Evaluate one pinned queue head against freshly fetched main. Never push or call a merge API. */
+export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowVerdict | null> {
+  return withShadowQueue(cwd, deps, async (state, path) => {
+    const item = state.pending[0];
+    if (!item) return null;
+    const execute = deps.command ?? command;
+    const run = (bin: string, args: string[], where = cwd) => shadowCommand(execute, bin, args, where);
+    const verdict: L8ShadowVerdict = { number: item.number, head: item.head, verdict: 'fail', tests: [], at: new Date().toISOString() };
+    const view = JSON.parse(run('gh', ['pr', 'view', String(item.number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'])) as {
+      headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+    };
+    if (view.headRefOid !== item.head || view.baseRefName !== 'main' || view.state !== 'OPEN'
+      || view.isDraft !== false || view.isCrossRepository !== false) throw new Error('queued PR changed or is not ready');
+    run('git', ['fetch', 'origin', 'refs/heads/main']);
+    const base = run('git', ['rev-parse', 'FETCH_HEAD']);
+    if (!/^[0-9a-f]{40}$/i.test(base)) throw new Error('main commit unavailable');
+    verdict.base = base;
+    run('git', ['fetch', 'origin', `refs/pull/${item.number}/head`]);
+    if (run('git', ['rev-parse', 'FETCH_HEAD']) !== item.head) throw new Error('fetched PR head changed');
+    let temp: string | undefined;
+    let attached = false;
+    try {
+      temp = mkdtempSync(join(tmpdir(), 'elanous-l8-shadow-'));
+      run('git', ['worktree', 'add', '--detach', temp, base]);
+      attached = true;
+      const fork = run('git', ['merge-base', base, item.head], temp);
+      const changed = run('git', ['diff', '--name-only', '-z', fork, item.head], temp).split('\0').filter(Boolean);
+      if (!changed.length) throw new Error('PR changed-file paths unavailable');
+      const diff = run('git', ['diff', '--name-only', '-z', '--diff-filter=ACMRT', fork, item.head], temp);
+      const files = diff.split('\0').filter(Boolean);
+      if (changed.some((file) => file.startsWith('-') || file.startsWith('/') || file.split('/').includes('..') || file.includes('\\'))) throw new Error('unsafe changed-file path');
+      verdict.tests = files.filter((file) => /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/.test(file));
+      const merge = execute('git', ['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'merge', '--no-ff', '--no-edit', item.head], temp);
+      if (merge.status !== 0) {
+        const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp);
+        if (!unresolved) throw new Error(`git merge failed: ${merge.stderr.trim() || `exit ${merge.status}`}`);
+        verdict.verdict = 'conflict';
+        verdict.detail = unresolved;
+      } else {
+        if (verdict.tests.length) {
+          if (verdict.tests.some((file) => !existsSync(join(temp!, file)))) throw new Error('changed test path unavailable');
+          run('bun', ['install', '--frozen-lockfile'], temp);
+          const result = execute('bun', ['run', 'test:deterministic', ...verdict.tests], temp);
+          const output = `${result.stdout}\n${result.stderr}`;
+          const counts = /\b(\d+) pass\b[\s\S]*?\b(\d+) fail\b[\s\S]*?Ran ([1-9]\d*) tests? across ([1-9]\d*) files?/.exec(output);
+          if (!counts || Number(counts[1]) + Number(counts[2]) !== Number(counts[3])
+            || Number(counts[4]) !== verdict.tests.length || (result.status !== 0 && Number(counts[2]) === 0)) {
+            throw new Error(`changed tests unmeasured: ${output.slice(-400)}`);
+          }
+          if (Number(counts[2]) > 0 || Number(counts[1]) === 0) {
+            verdict.detail = `changed tests failed: ${output.slice(-400)}`;
+          } else {
+            verdict.verdict = 'pass';
+          }
+        } else {
+          verdict.verdict = 'pass';
+        }
+      }
+    } finally {
+      try {
+        if (attached && temp) run('git', ['worktree', 'remove', '--force', temp]);
+      } finally {
+        if (temp) rmSync(temp, { recursive: true, force: true });
+      }
+    }
+    if (verdict.verdict === 'pass') {
+      run('git', ['fetch', 'origin', 'refs/heads/main']);
+      if (run('git', ['rev-parse', 'FETCH_HEAD']) !== verdict.base) throw new Error('main advanced during shadow verification');
+      const current = JSON.parse(run('gh', ['pr', 'view', String(item.number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'])) as {
+        headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+      };
+      if (current.headRefOid !== item.head || current.baseRefName !== 'main' || current.state !== 'OPEN'
+        || current.isDraft !== false || current.isCrossRepository !== false) throw new Error('PR changed during shadow verification');
+    }
+    // A rejected insert leaves the pinned item queued for a later evaluation.
+    await (deps.observe ?? ((entry) => {
+      const store = getDefaultLogStore();
+      if (!store) throw new Error('merge-queue observation store unavailable');
+      store.insertBatch([{ rec: { ts: new Date().toISOString(), category: 'merge-queue', event: 'shadow-verdict', data: entry }, surface: 'merge-queue' }]);
+    }))(verdict);
+    state.pending.shift();
+    state.verdicts.push(verdict);
+    writeShadowQueue(path, state);
+    return verdict;
+  });
+}
+
 const command: Command = (bin, args, cwd) => {
   const r = spawnSync(bin, [...args], { cwd, encoding: 'utf8', timeout: 600_000, maxBuffer: 32 * 1024 * 1024 });
   return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error?.message ?? '') };

package/src/steward/launch.ts

@@ -7,6 +7,7 @@ import { redactSecrets } from '../task-cards/card-store.js';
 import { preLaunchGate, type PreLaunchGateDecision } from '../execution-loop/launch-gate.js';
 import type { BudgetDecision } from '../self-implement/budget-gate.js';
 import type { ScheduledDecision, StewardSettings, TriageIssue } from './triage.js';
+import { launchModeOf, rescueAllows } from './rescue.js';
 
 /** `completed` = the run finished without a merge (a non-code artifact, or nothing to deliver) — never reported as a failure. */
 export type LaunchStatus = 'shadow' | 'launched' | 'skipped-budget' | 'blocked-duplicate' | 'blocked-location' | 'failed' | 'running' | 'merged' | 'completed';
@@ -50,7 +51,7 @@ const RUN_ID = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 const DEFAULT_POOL = 'pool-node-b@node-b:8';
 // `harness budget --json` outcomes: proceed | next-provider | wait-reset | stop. next-provider still runs (the harness switches provider itself).
 const BUDGET_PROCEED: readonly string[] = ['proceed', 'next-provider'];
-const launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => settings.mode ?? settings.launch ?? 'shadow';
+const launchMode = (settings: StewardSettings): 'off' | 'shadow' | 'live' => launchModeOf(settings.mode ?? settings.launch ?? 'shadow');
 const cli = (args: string[]) => ['bun', 'bin/elanous.mjs', ...(process.env.NODE_ENV === 'test' ? ['--test'] : []), ...args];
 const sourceOf = (issue: TriageIssue): string => /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1] ?? `linear:${issue.identifier}`;
 const promptOf = (issue: TriageIssue): string => `${issue.title}\n${issue.body.slice(0, 1500)}`;
@@ -125,6 +126,7 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
   const { ledger, settings, root } = deps;
   if (item.row.rung !== 4 || item.row.hitlReason || item.row.disposition !== 'now' || (ledger.launches[item.issue.identifier] && !['skipped-budget', 'blocked-duplicate', 'blocked-location'].includes(ledger.launches[item.issue.identifier].status) && !(launchMode(settings) === 'live' && ledger.launches[item.issue.identifier].status === 'shadow'))) throw new Error('steward launch is not eligible');
   if (launchMode(settings) === 'off') throw new Error('steward launch is off');
+  if (!rescueAllows(settings.mode, 'launch', { issue: item.issue.identifier })) throw new Error('steward rescue refused launch');
   const key = item.issue.identifier;
   const entry: LaunchEntry = { issue: key, title: redactSecrets(item.issue.title), source: item.source, command: redactSecrets(item.command), status: 'shadow' };
   if (launchMode(settings) !== 'live') {
@@ -187,6 +189,7 @@ export function launch(item: LaunchItem, deps: LaunchDeps): LaunchEntry {
 export function raiseHitl(issue: TriageIssue, row: ScheduledDecision, deps: LaunchDeps): HitlEntry {
   const old = deps.ledger.hitl[issue.identifier];
   if (old && (old.attempted || launchMode(deps.settings) !== 'live')) return old;
+  if (!rescueAllows(deps.settings.mode, 'decision-card', { issue: issue.identifier })) return old ?? { issue: issue.identifier, reason: redactSecrets(row.hitlReason ?? row.why), raised: false };
   const entry: HitlEntry = old ?? { issue: issue.identifier, reason: redactSecrets(row.hitlReason ?? row.why), raised: false };
   deps.ledger.hitl[issue.identifier] = entry;
   if (launchMode(deps.settings) !== 'live') {
@@ -215,6 +218,7 @@ function alive(pid: number | undefined): boolean {
 
 export function collectOutcomes(ledger: LaunchLedger, deps: LaunchDeps): LaunchEntry[] {
   if (launchMode(deps.settings) !== 'live') return [];
+  if (!rescueAllows(deps.settings.mode, 'harvest')) return [];
   const done: LaunchEntry[] = [];
   for (const entry of Object.values(ledger.launches)) {
     if (entry.reported || entry.status === 'shadow' || entry.status === 'skipped-budget' || entry.status === 'blocked-duplicate' || entry.status === 'blocked-location') continue;