elanous 0.2.29 → 0.2.31

package/src/cli/seat-cli.ts

@@ -1,12 +1,19 @@
 import type { Command } from 'commander';
-import { existsSync, lstatSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { redactSecretText } from '../debug/log.js';
 import { defaultMsgStorePath, readUnreadCount } from '../msg/msg-store.js';
+import { parseKnowhowItems, splitKnowhow } from '../seat-loop/seat-knowhow.js';
 
 export const SEAT_ROLES = ['OP', 'TC', 'MK', 'UX'] as const;
 export type SeatRole = typeof SEAT_ROLES[number];
+export const SEAT_AGENTS = ['codex', 'elanous', 'claude'] as const;
+export type SeatAgent = typeof SEAT_AGENTS[number];
+export const SEAT_QUICKSTART_MANUAL = join('docs', 'manual', 'MANUAL-seat-agent-quickstart-2026-10-12.md');
+export const SEAT_TRUST_LADDER = '신뢰 사다리: 지시 > 코드 > 문서 > 기억 — 어긋나면 앞이 이긴다';
+export const SEAT_TACIT_TOP_N = 5;
 
 const MAX_FIELD = 160;
 const MAX_ROWS = 12;
@@ -107,11 +114,138 @@ export function collectSeatBootSections(seat: string, options: { home: string; m
   return { sections, unread };
 }
 
-export function registerSeatBootCommands(command: Command, options: { home?: () => string; contextNow?: () => unknown; msgPath?: () => string } = {}): void {
+/** 표 줄을 칸으로 — 백틱 안의 `|`(예: `<pass|fail>`)는 칸 경계가 아니다. */
+const cells = (line: string): string[] => (line.replace(/^\s*\|/, '').replace(/\|\s*$/, '').match(/(?:`[^`]*`|[^|`])+|(?<=\|)(?=\|)/g) ?? []).map(cell => cell.trim());
+const backticked = (text: string): string[] => [...text.matchAll(/`([^`]+)`/g)].map(match => match[1]!);
+
+/** L1 — 빠른 길 매뉴얼의 «무엇을 하려면 → 명령» 표를 고른 에이전트용 한 줄씩으로 접는다. ⚠️ 주석은 다른 에이전트만 이름 대면 뺀다. */
+export function assembleSeatQuickPath(manual: string, agent: SeatAgent): string[] {
+  const lines = manual.split(/\r?\n/);
+  const start = lines.findIndex(line => /^##\s.*무엇.*명령/.test(line));
+  if (start < 0) return [];
+  const rows: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,2}\s/.test(line)) break;
+    if (!line.trim().startsWith('|') || /^\s*\|\s*-/.test(line)) continue;
+    const [what = '', command = '', dont = ''] = cells(line);
+    if (!what || what === '하려는 것') continue;
+    const segments = command.split(' · ').filter(segment => {
+      if (!segment.trim().startsWith('⚠️')) return true;
+      const named = SEAT_AGENTS.filter(name => new RegExp(`\\b${name}\\b`, 'i').test(segment));
+      return named.length === 0 || named.includes(agent);
+    });
+    const commands = segments.flatMap(segment => segment.trim().startsWith('⚠️') ? [segment.replace(/[`*]/g, '').trim()] : backticked(segment));
+    rows.push(`${what.replace(/\*\*/g, '')} → ${commands.join(' · ') || '미관측: 명령 없음'}${dont ? ` ⛔ ${dont.replace(/\*\*/g, '')}` : ''}`);
+  }
+  return rows;
+}
+
+export type SeatMemoryEntry = { title: string; hook: string; updated: string };
+type TacitCandidate = { label: string; details?: string[]; updated: string; hits: number; index: number };
+
+const tokens = (text: string): Set<string> => new Set(text.toLowerCase().split(/[^\p{L}\p{N}_]+/u).filter(Boolean));
+const hitsOf = (text: string, query: Set<string>): number => [...tokens(text)].filter(token => query.has(token)).length;
+/** 최근(날짜) 먼저, 같은 날이면 적중(질의 낱말 겹침) 많은 것, 그다음 원래 순서. */
+const recentThenHits = (a: TacitCandidate, b: TacitCandidate): number => b.updated.slice(0, 10).localeCompare(a.updated.slice(0, 10)) || b.hits - a.hits || a.index - b.index;
+
+/** 제목 이외의 운영 지침을 보존한다. 상태·검증은 분류에 이미 반영되어 중복 표시하지 않는다. */
+function knowhowDetails(text: string, prefix: string): string[] {
+  return text.split(/\r?\n/).slice(1)
+    .filter(line => line.trim() && !/^\s*-\s*(?:상태|검증)\s*:/.test(line))
+    .flatMap(line => (line.trim().match(/.{1,140}/gu) ?? []).map(part => `${prefix} ↳ ${part}`));
+}
+
+/** L3 — 최근 문서 상위 5개는 본문까지, 기억은 상위 N을 보인다. 절별 출력 하드 캡은 없다. */
+export function assembleSeatTacitKnowledge(input: { seat: string; agent: SeatAgent; knowhow: string; memories: readonly SeatMemoryEntry[]; now: Date; limit?: number }): string[] {
+  const limit = Math.max(0, input.limit ?? SEAT_TACIT_TOP_N);
+  const query = tokens(`${input.seat} ${input.agent}`);
+  const { facts, refs } = splitKnowhow(parseKnowhowItems(input.knowhow, input.seat), input.now);
+  const knowhow = [...facts, ...refs].map((item, index): TacitCandidate => {
+    const prefix = `[문서${facts.includes(item) ? '' : '·검증 안 됨'}]`;
+    const title = (item.text.split('\n', 1)[0] ?? '').replace(/^##\s*/, '');
+    return {
+      label: `${prefix} ${title}`,
+      details: knowhowDetails(item.text, prefix),
+      updated: item.verifiedAt?.toISOString() ?? '',
+      hits: hitsOf(item.text, query),
+      index,
+    };
+  }).sort(recentThenHits);
+  const memories = input.memories.map((entry, index): TacitCandidate => ({
+    label: `[기억] ${entry.title}${entry.hook ? ` — ${entry.hook}` : ''} (갱신 ${entry.updated.slice(0, 10) || '미상'})`,
+    updated: entry.updated,
+    hits: hitsOf(`${entry.title} ${entry.hook}`, query),
+    index,
+  })).sort(recentThenHits).slice(0, limit);
+  const visibleKnowhow = knowhow.slice(0, SEAT_TACIT_TOP_N);
+  const omittedKnowhow = knowhow.length - visibleKnowhow.length;
+  return [SEAT_TRUST_LADDER,
+    ...visibleKnowhow.flatMap(row => [row.label, ...(row.details ?? [])]),
+    ...(omittedKnowhow ? [`[문서] 나머지 ${omittedKnowhow}항목은 원문 KNOWHOW 참고`] : []),
+    ...memories.map(row => row.label)];
+}
+
+/** 저장소 안 일반 파일만 읽는다 — 링크가 저장소 밖을 가리키면 없는 것으로 친다. */
+function readRepoDoc(repoRoot: string, path: string): { updated: string; text: string } | null {
+  try {
+    const suffix = relative(realpathSync(repoRoot), realpathSync(path));
+    if (!suffix || suffix === '..' || suffix.startsWith(`..${sep}`) || suffix.startsWith(sep)) return null;
+    const stat = statSync(path);
+    if (!stat.isFile()) return null;
+    return { updated: stat.mtime.toISOString(), text: readFileSync(path, 'utf8').slice(0, 256_000) };
+  } catch { return null; }
+}
+
+function memoryEntries(home: string, root: string): { entries: SeatMemoryEntry[]; reason?: string } {
+  const dir = join(root, 'memory');
+  const index = join(dir, 'MEMORY.md');
+  try {
+    if (!existsSync(index)) return { entries: [], reason: '미관측: 기억 색인 파일 없음' };
+    if (!isRegularSeatPath(home, root, index)) return { entries: [], reason: '미관측: 기억 색인이 일반 경로가 아님' };
+    const entries = readFileSync(index, 'utf8').slice(0, 256_000).split(/\r?\n/).flatMap(line => {
+      const match = line.match(/^-\s*\[([^\]]+)\]\(([^)]+)\)\s*(?:[—-]\s*(.*))?$/);
+      if (!match) return [];
+      const file = join(dir, match[2]!);
+      try {
+        if (!existsSync(file) || !isRegularSeatPath(home, root, file)) return [];
+        return [{ title: match[1]!, hook: match[3] ?? '', updated: statSync(file).mtime.toISOString() }];
+      } catch { return []; }
+    });
+    return entries.length ? { entries } : { entries, reason: '미관측: 기억 색인에 읽을 항목 없음' };
+  } catch { return { entries: [], reason: '미관측: 기억 색인 읽기 실패' }; }
+}
+
+/** L1·L3 절 — `--agent` 를 줬을 때만 L0 카드 뒤에 붙는다. */
+export function collectSeatLadderSections(seat: string, agent: SeatAgent, options: { home: string; repoRoot: string; now: Date }): SeatBootSection[] {
+  const manualPath = join(options.repoRoot, SEAT_QUICKSTART_MANUAL);
+  const manual = readRepoDoc(options.repoRoot, manualPath);
+  const quick = manual ? assembleSeatQuickPath(manual.text, agent) : [];
+  const knowhowPath = join(options.repoRoot, 'docs', 'roles', seat, 'KNOWHOW.md');
+  const knowhow = readRepoDoc(options.repoRoot, knowhowPath);
+  const root = join(options.home, 'elanous-hq', 'seat-state');
+  const memories = memoryEntries(options.home, root);
+  const tacit = assembleSeatTacitKnowledge({ seat, agent, knowhow: knowhow?.text ?? '', memories: memories.entries, now: options.now });
+  const docs = tacit.filter(row => row.startsWith('[문서'));
+  const remembered = tacit.filter(row => row.startsWith('[기억]'));
+  const tacitRows = [
+    SEAT_TRUST_LADDER,
+    ...(docs.length ? docs : [knowhow ? '미관측: KNOWHOW 에 읽을 항목 없음' : '미관측: KNOWHOW 파일 없음']),
+    ...(remembered.length ? remembered : [memories.reason ?? '미관측: 기억 없음']),
+  ];
+  return [
+    { title: `L1 빠른 길 (${agent})`, source: manualPath, updated: manual?.updated ?? '미상', rows: quick, ...(quick.length ? {} : { reason: manual ? '미관측: «무엇→명령» 표 없음' : '미관측: 파일 없음' }) },
+    { title: `L3 암묵지 (${agent})`, source: `${knowhowPath} ⊕ ${join(root, 'memory', 'MEMORY.md')}`, updated: knowhow?.updated ?? '미상', rows: tacitRows },
+  ];
+}
+
+export function registerSeatBootCommands(command: Command, options: { home?: () => string; contextNow?: () => unknown; msgPath?: () => string; repoRoot?: () => string; now?: () => Date } = {}): void {
   command.command('boot <seat>').description('현재 자리 카드 — 허용된 메타데이터만 읽기 전용 표시')
-    .action(async (rawSeat: string) => {
+    .option('--agent <agent>', '에이전트(codex|elanous|claude) — 주면 L1 빠른 길 ⊕ L3 암묵지를 붙인다')
+    .action(async (rawSeat: string, flags: { agent?: string }) => {
       const seat = rawSeat.toUpperCase();
       if (!(SEAT_ROLES as readonly string[]).includes(seat)) { console.error(`seat boot: unknown seat ${rawSeat} (OP|TC|MK|UX)`); process.exitCode = 2; return; }
+      const agent = flags.agent?.toLowerCase();
+      if (agent !== undefined && !(SEAT_AGENTS as readonly string[]).includes(agent)) { console.error(`seat boot: unknown agent ${flags.agent} (codex|elanous|claude)`); process.exitCode = 2; return; }
       const home = options.home?.() ?? homedir();
       let facts: string[] = [];
       let contextUpdated = '미상';
@@ -125,6 +259,7 @@ export function registerSeatBootCommands(command: Command, options: { home?: ()
         facts = contextFacts(snapshot);
       } catch { facts = []; contextUpdated = '미관측: contextNow 조회 실패'; }
       const sections = collectSeatBootSections(seat, { home, msgPath: options.msgPath?.() ?? defaultMsgStorePath() }).sections;
+      if (agent !== undefined) sections.push(...collectSeatLadderSections(seat, agent as SeatAgent, { home, repoRoot: options.repoRoot?.() ?? fileURLToPath(new URL('../../', import.meta.url)), now: options.now?.() ?? new Date() }));
       console.log(renderSeatBootCard(seat as SeatRole, sections, facts, contextUpdated));
     });
 }

package/src/cli/self-update.ts

@@ -590,8 +590,11 @@ function pruneUnusedVersions(dir: string, outcome: VersionPruneOutcome, listProc
             try { owner = statSync(join('/proc', pid)).uid; stat = readFileSync(join('/proc', pid, 'stat'), 'utf8'); }
             catch (failure) { if (exited(failure) && !existsSync(join('/proc', pid))) continue; throw failure; }
             if (procStatHoldsNothing(stat)) continue;
-            // Our own links must be readable. Another UID's link failure (denied, or ENOENT from a live process) falls back to its argv.
-            if ((code === 'EACCES' || code === 'EPERM' || code === 'ENOENT') && owner !== process.getuid?.()) {
+            // A denied link falls back to argv for any owner: Linux ptrace access also refuses same-UID
+            // processes holding extra capabilities or another user namespace (systemd --user, rootless
+            // containers), so requiring them would disable pruning on every systemd host. ENOENT from a
+            // live process stays fatal for our own UID and falls back to argv only for another UID.
+            if (code === 'EACCES' || code === 'EPERM' || (code === 'ENOENT' && owner !== process.getuid?.())) {
               if (!argvRead.has(pid)) {
                 argvRead.add(pid);
                 let argv: string | undefined;

package/src/cli/tasks-cli.ts

@@ -14,7 +14,8 @@ import { assignedVersions, releasedVersion, validateVersion } from '../release-l
 import { compareVersions } from '../directives/version-at.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
-import { cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, handTask, updateTaskCard, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, handTask, updateTaskCard, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, runTagChange, taskAgentStatePath as taskStatePathDefault, taskCardLabelContext, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { RUN_TAG_KEYS, runIdentityFieldText, runPriorityClass } from '../task-agent/run-identity.js';
 import { readCardSalvageBranch, recordWiringLiveVerified, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
 import { replayRemoteCardMoves } from '../task-agent/shadow.js';
@@ -33,6 +34,9 @@ export interface TasksCliDeps {
   bearerToken?: string;
   fetch?: typeof fetch;
   output?: (line: string) => void;
+  /** green-sweep entrypoint test seam: keep the actual CLI decision chain, replace only process reads. */
+  greenSweepChecklist?: typeof listChecklist;
+  greenSweepRun?: (command: string, args: string[]) => { status: number | null; stdout: string };
   /** `task hand --live` 의 발사기(시험 주입). 기본은 운영 config-dir 로 `harness say` 를 떼어 띄운다. */
   taskLauncher?: TaskLauncher;
   /** TA-REVIEW-RESULT-CAPTURE — `tasks show` 의 리뷰 결과 회수 시각(시험 주입 · 기본 지금). */
@@ -185,6 +189,12 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     failed(targets[0]!, ['project-target-is-local']);
     return null;
   }
+  // ⛔ R7(2026-10-16): 시험 안에서 실 ssh 원격 발사는 명시 허용 없이 거부한다(가짜 ssh 주입은 통과).
+  //   ⚠️ 이 가드는 hold(launchHoldActive) 판정보다 «앞»이어야 한다 — hold 는 preflightParentHost 의 입력일 뿐이고,
+  //   preflightParentHost(parent-host.ts `preflightParentHost` 첫 줄)는 hold 와 무관하게 먼저 실 ssh 를 부른다(다중 대상이면
+  //   그 앞의 readParentHostCapacity 도 ssh). 가드를 아래로 내리면 hold 경로에서 시험이 실 ssh 를 쏜다(R7 사고 모양).
+  //   hold 경로를 재는 시험은 deps.ssh 가짜 또는 parentHost:null 을 주입한다(real-launch-guard.test 가 이 순서를 문다).
+  if (!deps.ssh) (await import('../task-agent/real-launch-guard.js')).refuseRealLaunchUnderTest('remote-parent-ssh', targets.map((target) => target.host).join(','));
   let launchHoldActive = false;
   try {
     if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
@@ -236,6 +246,8 @@ export async function defaultTaskLauncher(args: string[], cwd?: string, context?
     const remote = await tryRemoteParent(args, cwd, context, deps);
     if (remote) return remote;
   }
+  // ⛔ R7(2026-10-16): 시험 안에서 실 `elanous harness say` 를 띄우는 것은 명시 허용 없이 거부한다(가짜 spawn 주입은 통과).
+  if (!deps.spawn) (await import('../task-agent/real-launch-guard.js')).refuseRealLaunchUnderTest('local-harness-spawn', args.slice(0, 2).join(' '));
   const spawn = deps.spawn ?? ((await import('node:child_process')).spawn as unknown as DetachedSpawn);
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { prodInstanceRoot } = await import('../instance/resolve.js');
@@ -366,9 +378,26 @@ function runLinkLine(card: TaskCard): string[] {
   return [`런: ${card.runId} · 골: ${card.goalId ?? '-'} · PR: ${pr}${card.runChildId ? ` · 자식 런: ${card.runChildId}` : ''}`];
 }
 
+/** RUN-IDENTITY-TAGS — 신분 한 줄 + Pod 라벨 한 줄(원장 정본 2줄 렌더 · 신분 없는 카드는 «미기록»으로 적고 기본값 정책을 밝힌다). */
+function cardIdentityLines(card: TaskCard): string[] {
+  const identity = card.identity;
+  const { labels } = taskCardLabelContext({ id: card.id });
+  // 경계: Pod 에 실제로 붙는 라벨은 카드 id 하나뿐이다 — 신분 값은 Pod 라벨에 아직 안 실린다(RUN-IDENTITY-ADMIT 몫). 화면도 그렇게 말한다.
+  const podLine = `Pod 라벨 ${Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(' ')} (신분 값은 Pod 라벨 미탑재 — RUN-IDENTITY-ADMIT)`;
+  if (!identity) return [`신분 미기록 — 원장에 identity 없음 · 승인·선점은 기본 class=${runPriorityClass(identity)} 로 읽는다`, podLine];
+  // ⛔ 모르는 칸을 기본값으로 보이지 않는다 — 원장에 없는 칸은 «미기록»으로 적는다(확인된 칸만 값으로).
+  const identityText = RUN_TAG_KEYS.map((key) => `${key}=${runIdentityFieldText(identity, key)}`).join(' · ');
+  const originParts = [identity.origin?.checklistId, identity.origin?.version, identity.origin?.seat, identity.origin?.launcher].filter((part) => part !== undefined);
+  return [
+    `신분 ${identityText}${originParts.length > 0 ? ` — 출생 ${originParts.join(' · ')}` : ''}`,
+    podLine,
+  ];
+}
+
 function taskCardLines(card: TaskCard): string[] {
   return [
     [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
+    ...cardIdentityLines(card),
     ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
     ...runLinkLine(card),
     ...liveMoveLines(card),
@@ -786,7 +815,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .action((opts: { version: string; cell?: string; traffic?: string; json?: boolean }) => {
       try {
         validateVersion(opts.version);
-        const snapshot = listChecklist(opts.version);
+        const snapshot = (deps.greenSweepChecklist ?? listChecklist)(opts.version);
+        const run = deps.greenSweepRun ?? ((command: string, args: string[]) => spawnSync(command, args,
+          { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 }));
         const cards = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {});
         let holds: Set<string> | null = null;
         if (opts.traffic) {
@@ -800,14 +831,11 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         }
         const prCache = new Map<number, GreenSweepPr | null>();
         const ambiguousPrs = ambiguousGreenSweepPrs(snapshot.items, opts.version, cards);
-        const origin = spawnSync('git', ['remote', 'get-url', 'origin'],
-          { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 });
+        const origin = run('git', ['remote', 'get-url', 'origin']);
         const originRepo = origin.status === 0
           ? /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/i.exec(origin.stdout.trim())?.[1]?.toLowerCase() : undefined;
-        const localMain = spawnSync('git', ['rev-parse', 'origin/main'],
-          { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 });
-        const remoteMain = spawnSync('git', ['ls-remote', 'origin', 'refs/heads/main'],
-          { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 });
+        const localMain = run('git', ['rev-parse', 'origin/main']);
+        const remoteMain = run('git', ['ls-remote', 'origin', 'refs/heads/main']);
         const localMainSha = localMain.status === 0 ? localMain.stdout.trim() : '';
         const remoteMainSha = remoteMain.status === 0 ? remoteMain.stdout.trim().split(/\s+/)[0] : '';
         const mainFresh = /^[a-f0-9]{40}$/i.test(localMainSha) && localMainSha === remoteMainSha;
@@ -817,8 +845,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           return candidates.map((candidate) => {
             let pr = prCache.get(candidate.pr);
             if (pr === undefined) {
-              const view = spawnSync('gh', ['pr', 'view', String(candidate.pr), '--json', 'number,state,mergeCommit,url'],
-                { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 });
+              const view = run('gh', ['pr', 'view', String(candidate.pr), '--json', 'number,state,mergeCommit,url']);
               try {
                 if (view.status !== 0) throw new Error('gh failed');
                 const parsed = JSON.parse(view.stdout) as { number?: number; state?: string; mergeCommit?: { oid?: string }; url?: string };
@@ -827,16 +854,31 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               } catch { pr = null; }
               prCache.set(candidate.pr, pr);
             }
-            const sha = pr?.mergeSha;
+            // A component PR stays CLOSED after a merged train. Reverify the integration PR
+            // recorded on the card before using its merge commit as landing evidence.
+            let landingPr = pr;
+            const train = candidate.card?.trainLanding;
+            if (pr?.state === 'CLOSED' && train?.componentPr === candidate.pr && /^[a-f0-9]{40}$/i.test(train.mergeSha)) {
+              const view = run('gh', ['pr', 'view', String(train.integrationPr), '--json', 'number,state,mergeCommit']);
+              try {
+                if (view.status === 0) {
+                  const parsed = JSON.parse(view.stdout) as { number?: number; state?: string; mergeCommit?: { oid?: string } };
+                  if (parsed.number === train.integrationPr && parsed.state === 'MERGED'
+                    && parsed.mergeCommit?.oid?.toLowerCase() === train.mergeSha.toLowerCase()) {
+                    landingPr = { ...pr, state: 'MERGED', mergeSha: train.mergeSha, viaTrain: { integrationPr: train.integrationPr } };
+                  }
+                }
+              } catch { /* Unverified train is still a CLOSED component PR. */ }
+            }
+            const sha = landingPr?.mergeSha;
             const prRepo = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+(?:\/|$)/i.exec(pr?.url ?? '')?.[1]?.toLowerCase();
             const repositoryMatches = originRepo && prRepo ? originRepo === prRepo : null;
             const ancestor = !mainFresh || !sha || !/^[a-f0-9]{40}$/i.test(sha) ? null : (() => {
-              const check = spawnSync('git', ['merge-base', '--is-ancestor', sha, 'origin/main'],
-                { cwd: process.cwd(), encoding: 'utf8', timeout: 20_000 });
+              const check = run('git', ['merge-base', '--is-ancestor', sha, 'origin/main']);
               return check.status === 0 ? true : check.status === 1 ? false : null;
             })();
             const decision = decideGreenSweep({ item, candidate, candidateCount: candidates.length,
-              pr: pr ?? null, ancestor, hold: holds === null ? null : holds.has(item.id), repositoryMatches,
+              pr: landingPr ?? null, ancestor, hold: holds === null ? null : holds.has(item.id), repositoryMatches,
               ambiguousAcrossCells: ambiguousPrs.has(candidate.pr) });
             observeGreenSweep(decision);
             return decision;
@@ -954,9 +996,13 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--ta-land', 'TA-LIVE-LAND-2 — 호스트는 재게이트만 하고 병합은 TASK-AGENT 의 propose-land(`pr land --expected-head`)에 맡긴다 · 카드 taLand ⊕ 발사 env ELANOUS_TA_LAND=1 · taskAgent.liveMoves 에 propose-land 가 없으면 종전대로 호스트가 병합')
     .option('--child-llm <provider/model>', 'TASKS-HAND-CHILD-LLM — 구현 자식 LLM(예: grok/grok-4.7) → 발사 인자 --child-llm-provider <provider> --child-llm-model <model> · «첫» `/` 에서만 가른다(모델 id 의 `/` 는 보존) · openrouter 는 모델 id 가 openrouter/ 접두를 포함하므로 전체를 모델로(openrouter/z-ai/glm-5.3 → --child-llm-model openrouter/z-ai/glm-5.3) · 카드 childLlm · 안 주면 명령·카드 무변경')
     .option('--child-llm-effort <level>', '구현 자식 추론 노력 → 발사 인자 --child-llm-effort(검증은 하니스 · --child-llm 과 함께)')
+    .addOption(new Option('--tier <level>', '디스패처 난이도(하|중|상|특) — 카드에 보존해 수리 모델 정책에 사용').choices(['하', '중', '상', '특']))
+    .option('--tag <k=v>', 'RUN-IDENTITY-TAGS — 출생 신분을 덮는다(class|care|rights|protect 의 k=v · 반복: --tag class=gate --tag protect=true) — 카드 원장 identity 에 남는다', (value: string, previous: string[] | undefined) => [...(previous ?? []), value])
     .option('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; version?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; version?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; tier?: TaskCard['tier']; tag?: string[]; json?: boolean }) => {
       const suppliedText = text !== undefined;
+      /** RUN-IDENTITY-TAGS — 칸을 찾은 판(출생 신분이 그 판의 칸 우선순위를 읽는다 · 개발 판 밖 칸도). */
+      let birthBoardVersion: string | undefined;
       if (opts.version !== undefined && opts.checklist === undefined) {
         out('--version 은 --checklist 와 함께 준다');
         process.exitCode = 1;
@@ -1014,6 +1060,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           return;
         }
         if (matches.length > 1) console.error(`⚠ 체크리스트 칸 ${opts.checklist} 중복: ${matches.map((match) => match.version).join(', ')} — 가장 가까운 판 ${matches[0]!.version} 선택 (--version 으로 고정 가능)`);
+        birthBoardVersion = matches[0]!.version;
         if (opts.mission === undefined && text === undefined) text = title;
       }
       if (opts.checklist !== undefined && opts.mission === undefined && suppliedText && !text!.split(/\r?\n/, 1)[0]!.startsWith('대상 경로:')) {
@@ -1032,8 +1079,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         process.exitCode = 1;
         return;
       }
-      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined || opts.taLand === true || opts.childLlm !== undefined || opts.childLlmEffort !== undefined)) {
-        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm 은 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
+      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined || opts.taLand === true || opts.childLlm !== undefined || opts.childLlmEffort !== undefined || opts.tier !== undefined || opts.tag !== undefined)) {
+        out('--completion/--project/--target/--goal/--milestone/--ta-land/--child-llm/--tier/--tag 는 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
         process.exitCode = 1;
         return;
       }
@@ -1089,6 +1136,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           ...(opts.taLand === true ? { taLand: true } : {}),
           ...(opts.childLlm !== undefined ? { childLlm: opts.childLlm } : {}),
           ...(opts.childLlmEffort !== undefined ? { childLlmEffort: opts.childLlmEffort } : {}),
+          ...(opts.tier !== undefined ? { tier: opts.tier } : {}),
+          ...(opts.tag !== undefined ? { tags: opts.tag } : {}),
+          ...(birthBoardVersion !== undefined ? { checklistVersion: birthBoardVersion } : {}),
           ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}),
           ...(deps.taskCompositionRoot ? { compositionRoot: deps.taskCompositionRoot } : {}),
           launcher: deps.taskLauncher ?? defaultTaskLauncher,
@@ -1096,10 +1146,12 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         if (opts.json) out(JSON.stringify(result));
         else {
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
-          out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
+          if (result.move.command) out(`elanous ${result.move.command.map(shellQuote).join(' ')}`);
+          else out(result.move.reason);
           if (result.cwd) out(`(cwd: ${result.cwd})`);
           if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 원격 또는 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
-          if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
+          if (!result.launched && result.card.alreadyDoneCandidate) out('(main 증거 통과 — 발사 0 · green 후보만 기록, 주인 판정 대기)');
+          else if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
         out(error instanceof Error ? error.message : '과제 넘기기 실패');
@@ -1107,6 +1159,32 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
+  tasks.command('tag <id> <k=v>')
+    .description('RUN-IDENTITY-TAGS — 카드의 런 신분 태그를 바꾼다(class|care|rights|protect 의 k=v · 카드 history 에 감사 줄 run-tag-change {from, to, by, reason} 이 남는다 · 카드 상태 파일이 원장 정본 · 목록 밖 값은 거부)')
+    .option('--by <seat>', '바꾼 자리(예: OP·MK·TC·UX) — 안 주면 호출 자리 ELANOUS_TRACK, 그것도 없으면 «unknown» 으로 감사 줄에 적는다(지어내지 않는다)')
+    .option('--reason <text>', '왜 바꾸나 — 감사 줄에 남긴다')
+    .option('--json', '바뀐 카드를 JSON 으로 출력')
+    .action((id: string, kv: string, opts: { by?: string; reason?: string; json?: boolean }) => {
+      try {
+        const by = opts.by?.trim() || process.env.ELANOUS_TRACK?.trim() || 'unknown';
+        const card = runTagChange(id, { tag: kv, by, ...(opts.reason !== undefined ? { reason: opts.reason } : {}) }, deps.taskStatePath ?? taskStatePathDefault());
+        if (card === undefined) {
+          out(`카드가 없습니다: ${id}`);
+          process.exitCode = 1;
+          return;
+        }
+        if (opts.json) {
+          out(JSON.stringify(card));
+          return;
+        }
+        out(`${card.id}\t${kv}`);
+        for (const line of cardIdentityLines(card)) out(line);
+      } catch (error) {
+        out(error instanceof Error ? error.message : '태그 바꾸기 실패');
+        process.exitCode = 1;
+      }
+    });
+
   tasks.command('hand-move <id>')
     .description('HAND-MOVE-LEDGER — 자리가 손으로 마무리한 수(기존 실패 면제 · diff 재적용 · 범위 자르기 · 쪼개기 · 다른 모델 의견)를 그 카드 history 에 한 줄로 남긴다 — live-move 와 같은 원장 칸 · 기존 줄은 건드리지 않는다')
     .requiredOption('--kind <kind>', `손으로 쓴 수 (${HAND_MOVE_KINDS.join('|')})`)

package/src/context-bus/context-first.ts

@@ -69,6 +69,19 @@ export function isOperationalQuery(text: string | undefined): boolean {
   return !!text && OPERATIONAL_QUERY.test(text);
 }
 
+/** 칸 3 a59c1c24c — «맥락 먼저 판단»의 공통 게이트 결정: 개시 대기 소진 → 표면 스위치 → 운영 질문 스킵.
+ *  Telegram(maybeSendContextFirst)과 Discord(maybeSendContextFirst)가 같은 한 지점에서 판단한다. */
+export function takeContextFirstOpening(opts: {
+  gate: ReturnType<typeof createContextFirstGate>;
+  key: string;
+  text?: string;
+  enabled?: boolean;
+}): boolean {
+  if (!opts.gate.take(opts.key)) return false;
+  if (opts.enabled === false) return false;
+  return !isOperationalQuery(opts.text);
+}
+
 export function renderContextFirst(
   read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
   deps: ContextNowDeps | undefined,

package/src/context-bus/context-now.ts

@@ -2,7 +2,7 @@ import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { isMainThread, parentPort, workerData, Worker } from 'node:worker_threads';
 import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
-import { loadRunLedger } from '../self-implement/run-ledger.js';
+import { loadRunLedger, resolveFederatedRunLedgerDirectories, runLedgerDir } from '../self-implement/run-ledger.js';
 import { localLoopRows } from '../dashboard/slash-runtime/loops-table.js';
 import { checkBrand } from '../../scripts/brand/check.js';
 import { debug, redactSecretText } from '../debug/log.js';
@@ -69,7 +69,15 @@ const releaseSource = 'elanous://graph-runs/release-loop';
 const scheduleSource = 'elanous://schedules';
 const oneLine = (text: string) => redactSecretText(text.split(/\r?\n/, 1)[0] ?? '').slice(0, 120);
 
-function runningRunFacts(now: Date, queryRuns: () => QueriedRunningRunsResult = () => queryRunningRuns({ includeTest: false, caller: 'context-now' })): Extract<ContextFact, { kind: 'run' }>[] {
+// src/dashboard/slash-runtime/dashboard-handlers.ts:buildDashboardSlashRegistry /now calls contextNowInWorker;
+// contextNow → queryRunningRuns → queryFederatedUnfinishedRunLedgers → queryUnfinishedRunLedgers (persisted scan index).
+function runningRunFacts(now: Date, queryRuns: () => QueriedRunningRunsResult = () => queryRunningRuns({
+  includeTest: false,
+  caller: 'context-now',
+  noCache: false,
+}, {
+  ledgerDirectories: () => [...new Set([runLedgerDir(), ...resolveFederatedRunLedgerDirectories({ includeTest: false })])],
+})): Extract<ContextFact, { kind: 'run' }>[] {
   const observed = queryRuns();
   const unreadable = observed.completeness === 'partial' || observed.pty.unreadable.length || !!observed.phases?.unreadableTargetCount;
   const facts = observed.entries.filter(entry => observed.countedStatuses.includes(entry.status)).slice(0, 8).flatMap(entry => {
@@ -239,6 +247,7 @@ export function scanContextNowInWorker(options: Parameters<typeof contextNow>[0]
   createWorker: () => Worker = () => new Worker(new URL(import.meta.url), { workerData: { kind: 'context-now' } }),
   timeoutMs = WORKER_SCAN_TIMEOUT_MS): Promise<ContextNowAnswer> {
   const worker = createWorker();
+  const startedAt = Date.now();
   return new Promise((resolve, reject) => {
     let settled = false;
     const timeout = setTimeout(() => {
@@ -249,6 +258,8 @@ export function scanContextNowInWorker(options: Parameters<typeof contextNow>[0]
       if (settled) return;
       settled = true;
       clearTimeout(timeout);
+      // 첫 호출 지연은 색인과 무관하게 «따로» 재야 판정선과 비교할 수 있다 — 스캔 자체의 ms 를 남긴다.
+      debug.log('context.now', 'worker-answer', { topic: options?.topic ?? null, ok: !error, ms: Date.now() - startedAt });
       void worker.terminate();
       if (error) reject(error);
       else resolve(answer!);

package/src/context-bus/ops-events.ts

@@ -0,0 +1,75 @@
+import type { Database } from 'bun:sqlite';
+import { debug, redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+
+export const OPS_EVENT_KINDS = [
+  'land.start', 'land.refused', 'land.merged',
+  'review.verdict',
+  'gate.rc',
+  'cell.opened', 'cell.hold',
+  'config.set',
+] as const;
+export type OpsEventKind = typeof OPS_EVENT_KINDS[number];
+
+export interface OpsEventInput {
+  kind: OpsEventKind;
+  /** One nonempty line describing the ops fact; multi-line input keeps only the first line. */
+  text: string;
+  /** Optional locator — PR number, checklist cell id, config key, release version. */
+  ref?: string;
+  /** Optional ISO timestamp; unparseable values are dropped. */
+  at?: string;
+}
+
+export interface OpsEventDeps {
+  db?: Database;
+  /** Injection seam for tests; defaults to the surface-events recordEvent. */
+  record?: typeof recordEvent;
+}
+
+/** Persist a one-line harness ops fact (land flow · review verdict · release gate ·
+ *  checklist cell · config set) into the existing surface_events.db journal via
+ *  recordEvent (src/domains/surface-events.ts) so pr-cli / release-loop operations
+ *  become recallable observations instead of vanishing side effects.
+ *  Fail-soft contract: any write-path failure — db open error, recordEvent throw,
+ *  schema mismatch — is caught, logged to debug, and swallowed. This writer never
+ *  throws and never rejects; callers fire it as a side call without touching their
+ *  own control flow. Malformed input (non-object, unknown kind, empty text) is a
+ *  silent no-op. Returns the recorded event id, or null when nothing was recorded. */
+export function emitOpsEvent(input: OpsEventInput, deps: OpsEventDeps = {}): string | null {
+  if (!input || typeof input !== 'object') return null;
+  let db: Database | undefined = deps.db;
+  let ownDb = false;
+  try {
+    if (!(OPS_EVENT_KINDS as readonly string[]).includes(input.kind)) return null;
+    const oneLine = (value: unknown): string =>
+      redactSecretText(String(value ?? '').split(/\r?\n/, 1)[0] ?? '').trim();
+    const text = oneLine(input.text);
+    if (!text) return null;
+    const ref = oneLine(input.ref) || null;
+    const at = typeof input.at === 'string' && !Number.isNaN(Date.parse(input.at)) ? input.at : undefined;
+    if (!db) {
+      // Test runners must never fall through to the user's production memory DB
+      // (same guard as recordInboundTurn in domains/surface-events.ts).
+      const testRunner = process.env.NODE_ENV === 'test' || process.env.BUN_TEST !== undefined;
+      db = openSurfaceEventsDb(testRunner
+        ? (process.env.ELANOUS_STATE_DIR?.trim() ? surfaceEventsDbPath() : ':memory:')
+        : surfaceEventsDbPath());
+      ownDb = true;
+    }
+    const record = deps.record ?? recordEvent;
+    return record(db, {
+      surface: 'ops', direction: 'outbound', domain: 'elanous', category: 'ops',
+      kind: input.kind, text, summary: text.slice(0, 120),
+      refs: JSON.stringify({ kind: input.kind, ref, url: null }),
+      ...(at ? { ts: at } : {}),
+    });
+  } catch (error) {
+    try { debug.log('ops.event', 'record-failed', {
+      kind: input.kind, reason: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' }); } catch { /* A broken logger cannot change the caller's result. */ }
+    return null;
+  } finally {
+    if (ownDb && db) { try { db.close(); } catch { /* close failure is not the caller's problem */ } }
+  }
+}

package/src/control-plane/lease-holder.ts

@@ -8,7 +8,7 @@ export interface LeaseHolderSnapshot {
 }
 
 export interface LeaseHolderView {
-  get(): Promise<LeaseHolderSnapshot>;
+  get(options?: { fresh?: boolean }): Promise<LeaseHolderSnapshot>;
 }
 
 export function createLeaseHolderView({ machine, read, ttlMs = 10_000, now = Date.now }: {
@@ -20,17 +20,21 @@ export function createLeaseHolderView({ machine, read, ttlMs = 10_000, now = Dat
   let cached: LeaseHolderSnapshot | undefined;
   let measuredAt = 0;
   let pending: Promise<LeaseHolderSnapshot> | undefined;
+  const readSnapshot = async (): Promise<LeaseHolderSnapshot> => {
+    let result: RoleLeaseRead;
+    try { result = await read(); }
+    catch { result = { kind: 'unmeasured', why: 'read failed' }; }
+    return result.kind === 'present'
+      ? { holder: result.doc.holder, generation: result.doc.generation, iAmHolder: result.doc.holder === machine, known: true }
+      : { holder: null, generation: null, iAmHolder: false, known: false };
+  };
   return {
-    get() {
+    get(options) {
+      if (options?.fresh) return readSnapshot();
       if (cached && now() - measuredAt < ttlMs) return Promise.resolve(cached);
       if (pending) return pending;
       pending = (async () => {
-        let result: RoleLeaseRead;
-        try { result = await read(); }
-        catch { result = { kind: 'unmeasured', why: 'read failed' }; }
-        const snapshot: LeaseHolderSnapshot = result.kind === 'present'
-          ? { holder: result.doc.holder, generation: result.doc.generation, iAmHolder: result.doc.holder === machine, known: true }
-          : { holder: null, generation: null, iAmHolder: false, known: false };
+        const snapshot = await readSnapshot();
         cached = snapshot;
         measuredAt = now();
         return snapshot;