elanous 0.2.35 → 0.2.36

package/src/skills/tools/terminal-modal.ts

@@ -14,11 +14,13 @@
 import type { LLMToolSpec } from '../../llm.js';
 import { truncateOutput } from '../../output-truncation.js';
 import { getSessionCwd } from '../../session/working-dir.js';
-import {
-  getDashboardTerminalSessions,
-} from '../../dashboard/terminal/session.js';
 import type { TerminalSession, TerminalSessionRegistry } from '../../terminal/session-registry.js';
 
+async function getDashboardTerminalSessions(): Promise<TerminalSessionRegistry> {
+  const { getDashboardTerminalSessions: getSessions } = await import('../../dashboard/terminal/session.js');
+  return getSessions() as TerminalSessionRegistry;
+}
+
 const DEFAULT_MAX_BYTES = 64 * 1024;
 
 // ─── terminal_modal_list ────────────────────────────────────────
@@ -43,7 +45,7 @@ export async function dispatchTerminalModalList(
   rawArgs: Record<string, unknown>,
   deps?: { registry?: TerminalSessionRegistry },
 ): Promise<{ output: string }> {
-  const registry = deps?.registry ?? getDashboardTerminalSessions();
+  const registry = deps?.registry ?? await getDashboardTerminalSessions();
   const includeExited = rawArgs.include_exited === true;
   const sessions = registry.list().filter(s => includeExited || s.state !== 'exited');
   if (sessions.length === 0) {
@@ -92,7 +94,7 @@ export async function dispatchTerminalModalObserve(
   rawArgs: Record<string, unknown>,
   deps?: { registry?: TerminalSessionRegistry },
 ): Promise<{ output: string }> {
-  const registry = deps?.registry ?? getDashboardTerminalSessions();
+  const registry = deps?.registry ?? await getDashboardTerminalSessions();
   const id = String(rawArgs.id ?? '').trim();
   if (!id) throw new Error(`'id' is required`);
   const session = registry.get(id);
@@ -155,7 +157,7 @@ export async function dispatchTerminalModalFocus(
     termRows?: number;
   },
 ): Promise<{ output: string }> {
-  const registry = deps?.registry ?? getDashboardTerminalSessions();
+  const registry = deps?.registry ?? await getDashboardTerminalSessions();
   const id = String(rawArgs.id ?? '').trim();
   if (!id) throw new Error(`'id' is required`);
   const prior = registry.foreground()?.id ?? null;
@@ -191,7 +193,7 @@ export async function dispatchTerminalModalDetach(
   rawArgs: Record<string, unknown>,
   deps?: { registry?: TerminalSessionRegistry },
 ): Promise<{ output: string }> {
-  const registry = deps?.registry ?? getDashboardTerminalSessions();
+  const registry = deps?.registry ?? await getDashboardTerminalSessions();
   const id = typeof rawArgs.id === 'string' && rawArgs.id.length > 0
     ? rawArgs.id
     : registry.foreground()?.id;
@@ -227,7 +229,7 @@ export async function dispatchTerminalModalKill(
   rawArgs: Record<string, unknown>,
   deps?: { registry?: TerminalSessionRegistry },
 ): Promise<{ output: string }> {
-  const registry = deps?.registry ?? getDashboardTerminalSessions();
+  const registry = deps?.registry ?? await getDashboardTerminalSessions();
   const id = String(rawArgs.id ?? '').trim();
   if (!id) throw new Error(`'id' is required`);
   const session = registry.kill(id);

package/src/skills/url-router.ts

@@ -108,11 +108,50 @@ function containsAny(haystack: string, needles: string[]): string | null {
   return null;
 }
 
+// ── Work-context guard (URL-ROUTE-WORK-CONTEXT-GUARD · 10-22) ──
+// Observed: a long n8n work instruction carrying «RSS URL https://hnrss.org/frontpage
+// · Limit 5 …» (a value to type into a node) was rewritten into an omni-digest run.
+// The config guardKeywords did not stop it, and a user config replaces that list
+// wholesale — so this guard lives in code and always applies.
+
+/** «Put this value into a field» phrasing — the URL is data, not a digest target. */
+const FIELD_INPUT_WORDS = [
+  '입력', '넣어', '넣고', '넣기', '붙여넣', '칸에', '노드에', '필드에', '란에',
+  '로 설정', '으로 설정', '에 설정', '설정해',
+  'paste into', 'type into', 'fill in', 'into the field', 'enter it',
+];
+/** Text outside the URLs longer than this is a work instruction, not «summarize this». */
+export const WORK_INSTRUCTION_MIN_CHARS = 160;
+/** Step separators (`·` `→` `->`, numbered/bulleted lines) that mark a multi-step task. */
+const STEP_MARKER_RE = /·|→|->|^\s*(?:\d+[.)]|[-*•])\s+/gmu;
+
+/** A URL written as a labelled value — «RSS URL https://…», «Webhook URL: https://…», «endpoint=https://…».
+ *  Matched against the text with each URL replaced by a marker, so a label inside a URL
+ *  (`https://a.com/?url=https://b.com`) is never read as one. */
+const URL_MARK = '\u0000';
+/** Words that ask for a digest of the URL — they exempt the labelled-URL check (not the other guards). */
+const DIGEST_REQUEST_WORDS = ['요약', '정리', '분석', 'summar', 'digest', 'tl;dr', 'tldr'];
+const LABELLED_URL_RE = /(?:^|[^\p{L}\p{N}])(?:url|uri|endpoint)\s*[:=]?\s*\u0000/iu;
+
+/** Why this URL-bearing text must stay on the LLM path, or null when it may route. */
+export function workContextGuardReason(text: string): string | null {
+  const rest = text.replace(URL_RE, ' ').replace(/\s+/g, ' ').trim();
+  const field = containsAny(rest.toLowerCase(), FIELD_INPUT_WORDS);
+  if (field) return `field-input("${field}")`;
+  // An explicit digest request («URL https://… 요약해줘») names the URL to summarize, so the label alone does not hold it back.
+  if (LABELLED_URL_RE.test(text.replace(URL_RE, URL_MARK)) && !containsAny(rest.toLowerCase(), DIGEST_REQUEST_WORDS)) return 'labelled-url-value';
+  if (rest.length > WORK_INSTRUCTION_MIN_CHARS) return `long-instruction(${rest.length})`;
+  const steps = text.replace(URL_RE, ' ').match(STEP_MARKER_RE)?.length ?? 0;
+  if (steps >= 2) return `multi-step(${steps})`;
+  return null;
+}
+
 /** Main entry. Returns a routing decision when the text contains a URL
  *  that should be auto-processed, or null when:
  *   - routing disabled,
  *   - no URL present,
- *   - a guard keyword is present (defer to the LLM — R5/R8).
+ *   - a guard keyword is present (defer to the LLM — R5/R8),
+ *   - the URL sits inside a work instruction (`workContextGuardReason`).
  *
  *  Callers (TUI dashboard / Telegram agent) then decide auto-fire vs
  *  suggest, and run the mapped skill (two-stage per P4). */
@@ -132,6 +171,7 @@ export function detectUrlRoute(
   // "반박해봐", "구현해줘") is NOT a digest request — defer to the LLM.
   const guardHit = containsAny(haystack, cfg.guardKeywords);
   if (guardHit) return null;
+  if (workContextGuardReason(text)) return null;
 
   const url = urls[0]!;
   const kind = classifyUrl(url);

package/src/smart-wizard/run.ts

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
+import type { WorkflowDeps } from '../workflow-runtime/types.js';
+
+const WIZARD_GRAPH = resolve(import.meta.dir, '../../graphs/wizard/wizard-loop.yaml');
+const FIRST_RESEARCH_PATH = ['intake', 'classify', 'ground'] as const;
+
+export interface WizardRequestRunOptions {
+  /** Stable caller-supplied identity, or generated for this request. */
+  runId?: string;
+  /** Isolated graph-run ledger root. */
+  stateRoot?: string;
+  /** Injected for controlled runs; omitted to use the graph runner's production LLM. */
+  callLLM?: (prompt: string) => Promise<string>;
+  /** Injected command runner for isolated execution and deterministic verification. */
+  runBash?: WorkflowDeps['runBash'];
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface WizardRequestRun {
+  runId: string;
+  status: GraphRunState['status'];
+  path: string[];
+  /** Observed graph edges; every record is stamped with the enclosing run identity. */
+  transitions: Array<{ from: string; to: string; runId: string }>;
+  state: GraphRunState;
+}
+
+/** Run one request through the wizard graph and expose its first research transition. */
+export async function runWizardRequest(
+  request: string,
+  options: WizardRequestRunOptions = {},
+): Promise<WizardRequestRun> {
+  const normalizedRequest = request.trim();
+  if (!normalizedRequest) throw new TypeError('wizard request must not be empty');
+  if (!existsSync(WIZARD_GRAPH)) throw new Error(`wizard-loop graph is missing: ${WIZARD_GRAPH}`);
+
+  const runId = options.runId ?? randomUUID();
+  const state = await runGraph(WIZARD_GRAPH, {
+    runId,
+    input: { request: normalizedRequest },
+    quiet: true,
+    deps: {
+      ...(options.stateRoot ? { root: options.stateRoot } : {}),
+      ...(options.callLLM ? { callLLM: options.callLLM } : {}),
+      ...(options.runBash ? { runBash: options.runBash } : {}),
+      ...(options.log ? { log: options.log } : {}),
+    },
+  });
+
+  if (state.runId !== runId) throw new Error(`wizard run identity changed: expected ${runId}, got ${state.runId}`);
+  const transitions = state.path.slice(1).map((to, index) => ({
+    from: state.path[index]!,
+    to,
+    runId: state.runId,
+  }));
+  const firstResearchPath = state.path.slice(0, Math.min(state.path.length, FIRST_RESEARCH_PATH.length));
+  if (!firstResearchPath.every((nodeId, index) => nodeId === FIRST_RESEARCH_PATH[index]) ||
+      (state.status === 'awaiting-approval' && firstResearchPath.length !== FIRST_RESEARCH_PATH.length)) {
+    throw new Error(`wizard request did not reach the first research steps: ${firstResearchPath.join(' → ')}`);
+  }
+
+  return { runId: state.runId, status: state.status, path: [...state.path], transitions, state };
+}

package/src/status/bar.ts

@@ -290,6 +290,25 @@ export function runningBuildSegment(state: RunningBuildState | null | undefined,
   return strongText(`${label} ⟳ 재기동 필요${target}`, 'yellow', opts);
 }
 
+/** 이번 턴 «실제로» 응답한 공급자·모델 (TUI-MODEL-BADGE-ACTUAL · 10-16 · #24·#66).
+ *
+ *  턴 «시작»에 고른 결정(`RouteDecision`)과 실제 응답은 다를 수 있다 — 폴백 체인이
+ *  다른 공급자로 넘기면(예 codex → grok) 배지가 «지금» 으로 보여야 하는 것은 이쪽이다.
+ *  완료 배지(`src/tui/chat/execution-badge.ts`)와 같은 원천(`src/llm/route-decision.ts`)을 쓴다. */
+export interface ModelExecutionActual {
+  provider?: string;
+  /** 실제로 응답한 모델 id — 있으면 배지의 «지금» 은 이 값이다. */
+  model: string;
+  /** 폴백이면 턴이 «고른» 모델 — 배지가 `고른 → 실제` 로 드러낸다(폴백 아니면 없음/null). */
+  fallbackFrom?: string | null;
+}
+
+/** 상태줄 배지 입력 — 설정/런타임 값 ⊕ (있으면) 이번 턴 실제 실행.
+ *  `actual` 이 없는 호출자는 종전과 완전히 같은 배지를 얻는다(추가 필드는 선택). */
+export interface StatusModelInfo extends Pick<ActiveProviderInfo, 'provider' | 'model'> {
+  actual?: ModelExecutionActual | null;
+}
+
 /** Truncate a model id at the first parameter-size marker (e.g.
  *  `qwen3.6-35b-a3b-ud-mlx` → `qwen3.6-35b`). The marker pattern
  *  matches one or more digits followed by `b`/`B` (e.g. `7b`, `35b`,
@@ -319,19 +338,22 @@ function truncateAtParamSize(model: string): string {
  *   - `local:qwen3.6-35b-a3b-ud-mlx` → `local:qwen3.6-35b`
  *   - `node-b:qwen2.5-72b-instruct`    → `node-b:qwen2.5-72b`
  *   - `claude-opus-4-6`              → unchanged (no `\d+b` marker) */
-export function modelSegment(info: Pick<ActiveProviderInfo, 'provider' | 'model'>, opts: StatusBarRenderOptions = {}): string {
-  if (!info.model || info.model === '(none)') {
-    return strongText(info.provider, 'pink', opts);
+export function modelSegment(info: StatusModelInfo, opts: StatusBarRenderOptions = {}): string {
+  // 이번 턴 실제 실행이 있으면 그 값이 «지금» 이다 — 설정/런타임 값은 실행 전 기본값일 뿐.
+  const actual = info.actual?.model && info.actual.model !== '(none)' ? info.actual : null;
+  const provider = actual?.provider?.trim() || info.provider;
+  const model = actual?.model ?? info.model;
+  if (!model || model === '(none)') {
+    return strongText(provider, 'pink', opts);
   }
   // Step 1 — derive the display string with node prefix when local.
   let display: string;
-  let model = info.model;
   if (model.startsWith('local-llm:')) {
     const rest = model.slice('local-llm:'.length);
     display = rest.includes(':') ? rest : `local:${rest}`;
   } else if (model.startsWith('local:')) {
     display = model;
-  } else if (info.provider === 'local') {
+  } else if (provider === 'local') {
     display = `local:${model}`;
   } else {
     display = model;
@@ -349,6 +371,11 @@ export function modelSegment(info: Pick<ActiveProviderInfo, 'provider' | 'model'
       display = truncateAtParamSize(display);
     }
   }
+  // Step 3 — 폴백이면 «처음 → 실제». 고른 값과 실제가 같으면 화살표를 꾸미지 않는다.
+  const from = actual?.fallbackFrom?.trim();
+  if (from && from !== model) {
+    display = `${opts.compact ? truncateAtParamSize(from) : from} → ${display}`;
+  }
   return strongText(display, 'pink', opts);
 }
 
@@ -798,7 +825,8 @@ function dockStripDetail(dockedCount: number, dormantCount: number): string {
 
 export interface StatusBarState {
   cwd: string;
-  providerInfo: ActiveProviderInfo;
+  /** 설정/런타임 공급자·모델 ⊕ (있으면) 이번 턴 실제 실행 — 배지는 실제를 «지금» 으로 쓴다. */
+  providerInfo: StatusModelInfo;
   gitBranch?: string;
   contextUsedTokens?: number;
   tmuxLabel?: string | null;

package/src/status/status-provider-info.ts

@@ -10,8 +10,29 @@
 
 import { inspectActiveProvider, type ActiveProviderInfo } from '../provider-summary.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
+import { currentRouteDecision, currentRouteExecution } from '../llm/route-decision.js';
+import type { ModelExecutionActual } from './bar.js';
 
-export type StatusProviderInfo = Pick<ActiveProviderInfo, 'provider' | 'model'>;
+export type StatusProviderInfo = Pick<ActiveProviderInfo, 'provider' | 'model'> & {
+  /** TUI-MODEL-BADGE-ACTUAL (10-16) — 이번 턴 «실제» 실행. 있으면 배지는 이 값을 «지금» 으로 쓴다. */
+  actual?: ModelExecutionActual | null;
+};
+
+/** 표면의 이번 턴 «실제» 실행을 배지 입력 꼴로 옮긴다 — 결정(턴 시작에 고른 값)과 다르면
+ *  `fallbackFrom` 이 채워져 배지가 `고른 → 실제` 를 보인다. 실행 기록이 없으면 null(꾸미지 않는다).
+ *  원천은 완료 배지와 «같은» 맵(`src/llm/route-decision.ts`)이다 — 두 표면이 다른 말을 하지 않게. */
+export function statusModelActual(surface = 'dashboard'): ModelExecutionActual | null {
+  const execution = currentRouteExecution(surface);
+  const model = execution?.model?.trim();
+  if (!model) return null;
+  const provider = execution?.provider?.trim();
+  const planned = currentRouteDecision(surface)?.model?.trim();
+  return {
+    model,
+    ...(provider ? { provider } : {}),
+    ...(planned && planned !== model ? { fallbackFrom: planned } : {}),
+  };
+}
 
 export interface StatusProviderInfoReaderDeps {
   readConfig?: () => UserConfig;
@@ -23,9 +44,15 @@ export interface StatusProviderInfoReaderDeps {
   maxAgeMs?: number;
 }
 
+/** 상태줄이 매 렌더 부르는 리더 — `actual`(이번 턴 실제 실행)은 선택이라 종전 호출 그대로도 된다. */
+export type StatusProviderInfoReader = (
+  runtimeModel?: string,
+  actual?: ModelExecutionActual | null,
+) => StatusProviderInfo;
+
 export function createStatusProviderInfoReader(
   deps: StatusProviderInfoReaderDeps = {},
-): (runtimeModel?: string) => StatusProviderInfo {
+): StatusProviderInfoReader {
   const readConfig = deps.readConfig ?? (() => getUserConfig());
   const inspect = deps.inspect ?? ((cfg, runtimeModel) => inspectActiveProvider(cfg, runtimeModel));
   const now = deps.now ?? Date.now;
@@ -39,20 +66,24 @@ export function createStatusProviderInfoReader(
     inspectedAt: number;
   } | null = null;
 
-  return (runtimeModel?: string): StatusProviderInfo => {
+  /** `actual` — 이번 턴 실제 실행(있으면). 기억은 설정/런타임 값만 하고, 실행은 «매 렌더»
+   *  달라지므로 기억 밖에서 덧씌운다(낡은 실행이 굳지 않게). */
+  return (runtimeModel?: string, actual?: ModelExecutionActual | null): StatusProviderInfo => {
     const t = now();
     // ⛔ 조기 반환에도 최대 수명을 건다 — TTL 만 보면 «29초에 설정 확인 → 30.001초 렌더»가 재판정 없이 지나간다.
     const fresh = memo !== null && t - memo.inspectedAt < maxAgeMs;
-    if (memo && fresh && memo.runtimeModel === runtimeModel && t - memo.checkedAt < ttlMs) return memo.info;
+    if (memo && fresh && memo.runtimeModel === runtimeModel && t - memo.checkedAt < ttlMs) {
+      return actual ? { ...memo.info, actual } : memo.info;
+    }
     // getUserConfig() 는 파일 mtime 이 같으면 «같은 객체»를, 바뀌면 새 객체를 돌려준다(user-config.ts getUserConfig).
     const cfg = readConfig();
     if (memo && fresh && memo.cfg === cfg && memo.runtimeModel === runtimeModel) {
       memo.checkedAt = t;
-      return memo.info;
+      return actual ? { ...memo.info, actual } : memo.info;
     }
     const full = inspect(cfg, runtimeModel);
     const info: StatusProviderInfo = { provider: full.provider, model: full.model };
     memo = { info, cfg, runtimeModel, checkedAt: t, inspectedAt: t };
-    return info;
+    return actual ? { ...info, actual } : info;
   };
 }

package/src/steward/rejudge-tick.ts

@@ -63,8 +63,16 @@ function defaultStampPath(): string {
 function readStamp(path: string): string | null {
   try {
     const value = (JSON.parse(readFileSync(path, 'utf8')) as { startedAt?: unknown }).startedAt;
-    return typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
-  } catch { return null; }
+    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) {
+      throw new Error(`invalid steward stamp startedAt: ${path}`);
+    }
+    return value;
+  } catch (error) {
+    // A missing stamp is the first tick. A corrupt or unreadable existing stamp is not:
+    // claiming it would overwrite the evidence and could launch an overlapping rejudge.
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
 }
 
 /** Same universe as this process (env inherited) · same installed version (entry next to this module). */

package/src/steward/ta-repair-event-collect.ts

@@ -7,6 +7,7 @@ import { acquireLockSync } from '../storage/file-lock.js';
 import { subscribeInsideEvent, type InsideLiveEvent } from '../nexus/api/inside-events.js';
 import type { NexusEventBus } from '../nexus/api/event-bus.js';
 import { parseRepairWorkerResult } from '../task-agent/repair-worker.js';
+import { pairMoveId } from '../task-agent/repair-next-move.js';
 import { readTaskCard, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 const SHA40 = /^[0-9a-f]{40}$/i;
@@ -17,6 +18,8 @@ const OUTPUT_LIMIT = 1024 * 1024;
 export interface TaRepairCompleted {
   kind: 'ta.repair.completed'; schema: 1; card: string; pr: number; head: string;
   runId: string; resultPath: string; completedAt: string;
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — worker 가 받은 수 id(옛 worker 는 없다 · 꼴이 틀려도 사건을 버리지 않고 짝짓기에서 «못 짝지음»으로 남긴다). */
+  moveId?: string;
 }
 
 export function parseTaRepairCompleted(value: unknown): TaRepairCompleted | null {
@@ -102,14 +105,22 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
   let card;
   try { card = readTaskCard(event.card, statePath); } catch { emit('deferred', { reason: 'card unreadable' }); return 'deferred'; }
   const repair = Array.isArray(card?.repairs) ? card.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
+  // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 사건의 수 id 를 카드(발사 순간 적은 값)와 짝짓는다. 결과는 관측 칸에만 싣는다(fail-soft · 수거 판단은 그대로).
+  const observedMoveId: unknown = (event as { moveId?: unknown }).moveId;
+  const pairing = pairMoveId(repair?.moveId, observedMoveId);
+  const moveFields: Record<string, unknown> = pairing.kind === 'legacy' ? {}
+    : { moveId: pairing.kind === 'paired' ? pairing.moveId : typeof observedMoveId === 'string' ? observedMoveId : null,
+      moveIdPaired: pairing.kind === 'paired', ...(pairing.kind === 'unpaired' ? { expectedMoveId: pairing.expected } : {}) };
+  const emitPaired = (outcome: string, extra: Record<string, unknown> = {}) => emit(outcome, { ...moveFields, ...extra });
   if (!repair || repair.pr !== event.pr || typeof repair.head !== 'string' || repair.head.toLowerCase() !== event.head.toLowerCase()
     || typeof repair.resultPath !== 'string' || !repair.resultPath.startsWith('/')
+    // 카드 귀속이 안 맞는 사건엔 짝짓기 칸을 싣지 않는다 — 남의 수리와 대조한 값이 관측에 섞이지 않게(r1 should-fix).
     || resolve(repair.resultPath) !== resolve(event.resultPath)) { emit('invalid', { reason: 'event differs from card binding' }); return 'invalid'; }
-  if (repair.status !== 'requested') { emit('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
+  if (repair.status !== 'requested') { emitPaired('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
   let result;
   try { result = parseRepairWorkerResult((deps.read ?? ((path) => readFileSync(path, 'utf8')))(repair.resultPath), event.pr, event.head, event.runId); }
   catch { /* periodic tick can recover a missing result */ }
-  if (!result) { emit('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
+  if (!result) { emitPaired('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
 
   // Existing PID-aware lock recovers a dead daemon without making later events wait forever.
   // A live holder keeps the lock through the child process; the card CAS covers periodic-tick races.
@@ -119,25 +130,25 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
     mkdirSync(dirname(lock), { recursive: true });
     release = acquireLockSync(lock, { breakDeadHolder: true, staleMs: TIMEOUT_MS + 60_000, maxTries: 2 });
   }
-  catch { emit('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
+  catch { emitPaired('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
   try {
     // Recheck after claiming: another collector or the periodic tick may have consumed the file.
     const current = readTaskCard(event.card, statePath);
     const latest = Array.isArray(current?.repairs) ? current.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
     if (!latest || latest.status !== 'requested' || latest.pr !== event.pr || typeof latest.head !== 'string'
       || latest.head.toLowerCase() !== event.head.toLowerCase() || typeof latest.resultPath !== 'string'
-      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emit('duplicate'); return 'duplicate'; }
+      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emitPaired('duplicate'); return 'duplicate'; }
     const child = await (deps.run ?? ((card) => defaultRun(card, statePath, deps.cliBin)))(event.card);
     const after = readTaskCard(event.card, statePath)?.repairs?.find(entry => entry.runId === event.runId);
     const consumed = child.code === 0 && !child.truncated && after?.status !== 'requested' && after !== undefined
       && childConsumedRepair(child.output, event);
     const outcome = consumed ? 'collected' : child.truncated ? 'deferred' : after && after.status !== 'requested' ? 'duplicate' : 'deferred';
-    emit(outcome, { rc: child.code, repairStatus: after?.status,
+    emitPaired(outcome, { rc: child.code, repairStatus: after?.status,
       ...(child.truncated ? { reason: 'rejudge output exceeded 1 MiB; event attribution unmeasured' } : {}),
       detail: child.output.slice(-300) });
     return consumed ? 'collected' : outcome === 'duplicate' ? 'duplicate' : 'deferred';
   } catch (error) {
-    emit('deferred', { reason: String(error).slice(-300) });
+    emitPaired('deferred', { reason: String(error).slice(-300) });
     return 'deferred';
   } finally { release(); }
 }

package/src/task-agent/actions.ts

@@ -48,6 +48,8 @@ export interface NextAction {
   cwd?: string;
   risk?: 'money' | 'security' | 'irreversible-publication';
   delivery?: { kind: DeliveryKind; worktreePath: string; projectTarget: string; files: string[] };
+  /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 재발사를 고른 next-move 결정의 수 id(결정 순간 한 번 · 다시 만들지 않는다). 있으면 `harness say --move-id` 로 싣는다. */
+  moveId?: string;
 }
 export interface ActionDeps {
   command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
@@ -273,7 +275,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     return card('review verdict or must-fix unavailable');
   }
   // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
-  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action)];
+  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action), ...(action.moveId ? ['--move-id', action.moveId] : [])];
   const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
   if (action.kind === 'retry' && deps.retryLaunches) deps.retryLaunches.count++;
   const outcome = await deps.command(args);

package/src/task-agent/land-queue.ts

@@ -4,6 +4,7 @@ import { mkdirSync, readFileSync } from 'node:fs';
 import { dirname, isAbsolute, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parseReviewResultOutput } from './review-result-capture.js';
+import { executeBoundPrLandRecover, PR_LAND_CARD_ID_ENV } from '../cli/pr-land-recovery.js';
 
 type CommandResult = { status: number; stdout: string; stderr: string };
 export interface QueueLandingInput {
@@ -13,6 +14,8 @@ export interface QueueLandingInput {
 export interface QueueLandingDeps {
   run?: (command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv) => Promise<CommandResult>;
   read?: (path: string) => string;
+  /** LAND-REFUSAL-EXEC — observe a refusal on the recover@1 edge and run that unit once (never an effect). */
+  recover?: typeof executeBoundPrLandRecover;
 }
 
 async function run(command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<CommandResult> {
@@ -31,14 +34,24 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   const invoke = deps.run ?? run;
   const read = deps.read ?? ((path: string) => readFileSync(path, 'utf8'));
   const fail = (stage: string, reason: string): CommandResult => ({ status: 1, stdout: '', stderr: `${stage}: ${reason.slice(-500)}` });
+  // LAND-REFUSAL-EXEC — a judged refusal (not an unmeasured prerequisite) is bound to recover@1 with this card
+  // and that unit runs once. The returned refusal is unchanged; recovery observation never replaces it.
+  const refuse = async (stage: string, reason: string): Promise<CommandResult> => {
+    const refused = fail(stage, reason);
+    try { await (deps.recover ?? executeBoundPrLandRecover)({ refusal: refused.stderr, pr: input.pr, head: input.head, cardId: input.card }, { root: dirname(input.statePath) }); }
+    catch { /* fail-soft */ }
+    return refused;
+  };
+  // The card rides along to every child that may land or record this PR (same env as TA defaultLand).
+  const cardEnv = (extra: Record<string, string> = {}): NodeJS.ProcessEnv => ({ ...process.env, ...extra, [PR_LAND_CARD_ID_ENV]: input.card });
   if (!/^[a-f0-9]{40}$/i.test(input.head) || !Number.isSafeInteger(input.pr) || input.pr < 1) return fail('input', 'invalid PR/head');
   if (!isAbsolute(input.command) || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(input.remote)) return fail('config', 'land queue command/remote invalid');
   let review: ReturnType<typeof parseReviewResultOutput>;
   try { review = parseReviewResultOutput(read(input.reviewResult)); }
-  catch (error) { return fail('review', String(error)); }
+  catch (error) { return refuse('review', String(error)); }
   if (!review || review.pr !== input.pr || review.head?.toLowerCase() !== input.head.toLowerCase()
     || review.reviewed !== true || !['pass', 'warn'].includes(review.verdict ?? '') || review.mustFix !== 0 || review.error) {
-    return fail('review', `exact head #${input.pr} ${input.head.slice(0, 12)} PASS/WARN mf0 not proven`);
+    return refuse('review', `exact head #${input.pr} ${input.head.slice(0, 12)} PASS/WARN mf0 not proven`);
   }
   const git = async (args: string[]) => invoke(process.execPath, [input.entry, '--config-dir', input.configDir, 'git', ...args], input.cwd);
   const fetched = await git(['fetch', '--quiet', 'origin', 'main']);
@@ -52,15 +65,15 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   const artifact = join(dirname(input.statePath), 'land-queue-gates', `${safeCard}-${input.pr}-${input.head.slice(0, 12)}-${randomUUID()}`);
   mkdirSync(artifact, { recursive: true });
   const gate = await invoke(process.execPath, [input.entry, '--config-dir', input.configDir,
-    'self', 'gate', '--changed', '--base', baseHead!, '--remote', input.remote, '--shards', '4', '--artifact-dir', artifact], input.cwd);
-  if (gate.status !== 0) return fail('remote-changed-gate', gate.stderr || gate.stdout || `exit ${gate.status}`);
+    'self', 'gate', '--changed', '--base', baseHead!, '--remote', input.remote, '--shards', '4', '--artifact-dir', artifact], input.cwd, cardEnv());
+  if (gate.status !== 0) return refuse('remote-changed-gate', gate.stderr || gate.stdout || `exit ${gate.status}`);
   let summary: Record<string, unknown>;
   try { summary = JSON.parse(read(join(artifact, 'summary.json'))) as Record<string, unknown>; }
   catch (error) { return fail('remote-changed-gate', `summary unreadable: ${String(error)}`); }
   if (summary.head40 !== input.head || summary.base40 !== baseHead || summary.remoteHost !== input.remote
     || summary.verdict !== 'passed' || summary.exitCode !== 0 || summary.introduced !== 0
     || summary.unknown !== 0 || summary.preconditionUnmet !== 0) {
-    return fail('remote-changed-gate', 'summary does not prove this head/base/remote passed with zero unknown');
+    return refuse('remote-changed-gate', 'summary does not prove this head/base/remote passed with zero unknown');
   }
   const fresh = await invoke('gh', ['pr', 'view', String(input.pr), '--json', 'headRefOid,state,isDraft'], input.cwd);
   let latest: { headRefOid?: unknown; state?: unknown; isDraft?: unknown };
@@ -68,12 +81,12 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   catch { return fail('pr-head', `current PR state unreadable: ${fresh.stderr || fresh.stdout || fresh.status}`); }
   if (fresh.status !== 0 || latest.state !== 'OPEN' || latest.isDraft !== false
     || typeof latest.headRefOid !== 'string' || latest.headRefOid.toLowerCase() !== input.head.toLowerCase()) {
-    return fail('pr-head', `PR #${input.pr} changed after gate or is not ready`);
+    return refuse('pr-head', `PR #${input.pr} changed after gate or is not ready`);
   }
   const enrolled = await invoke(input.command, [String(input.pr), input.cwd, '--review', input.reviewResult, '--expected-head', input.head], input.cwd,
-    { ...process.env, LAND_RR_DIR: dirname(input.reviewResult) });
+    cardEnv({ LAND_RR_DIR: dirname(input.reviewResult) }));
   if (enrolled.status !== 0 || !new RegExp(`^OK #${input.pr} head=${input.head.slice(0, 12)}(?:\\s|$)`, 'm').test(enrolled.stdout)) {
-    return fail('land-enqueue-refused', enrolled.stdout || enrolled.stderr || `exit ${enrolled.status}`);
+    return refuse('land-enqueue-refused', enrolled.stdout || enrolled.stderr || `exit ${enrolled.status}`);
   }
   return { status: 0, stdout: `queued #${input.pr} head ${input.head.slice(0, 12)} gate ${artifact} · ${enrolled.stdout.slice(-250)}`, stderr: '' };
 }

package/src/task-agent/live-moves.ts

@@ -28,6 +28,7 @@ import { getUserConfig, userConfigPath } from '../user-config.js';
 import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { LIVE_MOVE_HISTORY_EVENT, shellQuote, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 import { reconcileHandMergedCard } from './postland-card.js';
+import { advanceLandedPieceMission } from './mission.js';
 import { resolveParentHosts, type ParentHostConfig } from './parent-host.js';
 import { LIVE_RETRY_MOVES } from './judge.js';
 import { decisionCardGrounds, decisionRaiseArgs, type DecisionCardEvidence, type NextAction } from './actions.js';
@@ -93,7 +94,7 @@ export interface LiveMoveDeps {
   handMergePr?: (pr: number, cwd: string) => Promise<HandMergePrView | null>;
   /** One existing pr land operation; inject in tests instead of invoking the CLI. */
   /** TA-REJUDGE-ON-HEAD — `opts.overlapEvidence` 가 있으면 `pr land --overlap-evidence <file>` 로 넘긴다(없으면 종전 인자). */
-  land?: (pr: number, head: string, cwd: string, opts?: { overlapEvidence?: string }) => Promise<{ status: number; stdout: string; stderr?: string }>;
+  land?: (pr: number, head: string, cwd: string, opts?: { overlapEvidence?: string; cardId?: string }) => Promise<{ status: number; stdout: string; stderr?: string }>;
   /** `decision-card` — `decisions raise` 한 번(시험 주입 · 기본 = 같은 우주의 CLI 자식). */
   raiseDecision?: (args: string[]) => Promise<{ status: number; stdout: string; stderr?: string }>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
@@ -102,6 +103,8 @@ export interface LiveMoveDeps {
   /** TA-LAND-AFTER-REVIEW — injected queue adapter; absent uses configured command after a remote changed gate. */
   queueLanding?: (input: QueueLandingInput) => Promise<{ status: number; stdout: string; stderr?: string }>;
   landQueueConfig?: { command: string; remote: string } | null;
+  /** Confirmed direct landing wakes successor pieces; tests inject an observation-only seam. */
+  advanceLandedPiece?: (pieceId: string, statePath: string) => Promise<unknown>;
 }
 
 /** `executed` = 부작용을 실제로 냈다(리뷰를 띄웠다 · 제안을 적었다). ok 이지만 이미 한 수(같은 머리·이미 제안)면 false. */
@@ -280,13 +283,16 @@ export function liveLandArgs(entry: string, configDir: string, pr: number, head:
 }
 
 /** The CLI owns the freeze, gate and merge checks; no direct gh merge or bypass flags. */
-export async function defaultLand(pr: number, head: string, cwd: string, opts: { overlapEvidence?: string } = {}): Promise<{ status: number; stdout: string; stderr?: string }> {
+export async function defaultLand(pr: number, head: string, cwd: string, opts: { overlapEvidence?: string; cardId?: string } = {}): Promise<{ status: number; stdout: string; stderr?: string }> {
   const { ELANOUS_CLI_ENTRY } = await import('../cli/tasks-cli.js');
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const args = liveLandArgs(ELANOUS_CLI_ENTRY, getElanousConfigDirOverride() ?? effectiveInstanceRoot(), pr, head, cwd, opts.overlapEvidence);
+  const cardEnv = opts.cardId ? { [(await import('../cli/pr-land-recovery.js')).PR_LAND_CARD_ID_ENV]: opts.cardId } : undefined;
   return new Promise((resolveResult, reject) => {
-    const child = spawn(process.execPath, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    // LAND-REFUSAL-EDGES — the card rides along so a refusal row can be bound to this card (observation only).
+    const env = cardEnv ? { ...process.env, ...cardEnv } : undefined;
+    const child = spawn(process.execPath, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], ...(env ? { env } : {}) });
     let stdout = '';
     let stderr = '';
     child.stdout.on('data', (chunk: Buffer) => { stdout = (stdout + chunk.toString()).slice(-300); });
@@ -660,8 +666,13 @@ export async function executeLiveLand(
         const settled = reconcileHandMergedCard({ number: pr, url: hand.url ?? view.url ?? '', headRefOid: view.head, state: 'MERGED',
           baseRefName: hand.baseRefName ?? 'main', mergedAt: hand.mergedAt ?? '', mergeCommit: hand.mergeCommit },
           cwd, deps.statePath ? { statePath: deps.statePath } : {});
-        if (settled.outcome === 'reconciled')
+        if (settled.outcome === 'reconciled') {
+          const path = deps.statePath ?? taskAgentStatePath();
+          try { await (deps.advanceLandedPiece ?? ((pieceId, statePath) => advanceLandedPieceMission(pieceId, { statePath })))(card.id, path); }
+          catch (error) { try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'mission-auto-advance-error',
+            { card: card.id, pr, error: String(error).slice(0, 250) }); } catch { /* fail-soft */ } }
           return withRepo(observe(deps, { kind, card: card.id, ok: true, executed: true, detail: `PR #${pr} 손 병합 정산 — card ${settled.status} (merge ${settled.mergeSha.slice(0, 12)})` }));
+        }
       }
     }
     return reject(card.id, `PR #${pr} is ${view.state}`, reviewRepo);
@@ -802,8 +813,8 @@ export async function executeLiveLand(
         entry: (await import('../cli/tasks-cli.js')).ELANOUS_CLI_ENTRY,
         configDir: (await import('../elanous-config-dir.js')).getElanousConfigDirOverride() ?? (await import('../instance/resolve.js')).effectiveInstanceRoot() })
       : overlapEvidence
-        ? await (deps.land ?? defaultLand)(pr, view.head, landCwd, { overlapEvidence })
-        : await (deps.land ?? defaultLand)(pr, view.head, landCwd);
+        ? await (deps.land ?? defaultLand)(pr, view.head, landCwd, { overlapEvidence, cardId: card.id })
+        : await (deps.land ?? defaultLand)(pr, view.head, landCwd, { cardId: card.id });
     ok = outcome.status === 0;
     detail = (ok ? outcome.stdout || `${queueConfig ? 'queued' : 'land merged'} #${pr} head ${view.head.slice(0, 12)}` : outcome.stderr || outcome.stdout || `exit ${outcome.status}`).slice(-300);
     if (!ok) failure = classifyLandFailure(outcome);
@@ -857,6 +868,11 @@ export async function executeLiveLand(
     return observe(deps, withRepo({ kind, card: card.id, ok: false, executed: true, landAttempt,
       detail: `land ${ok ? 'succeeded' : 'failed'} but card update failed: ${String(error).slice(-230)}` }));
   }
+  if (ok && !queueConfig) {
+    try { await (deps.advanceLandedPiece ?? ((pieceId, statePath) => advanceLandedPieceMission(pieceId, { statePath })))(card.id, path); }
+    catch (error) { try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'mission-auto-advance-error',
+      { card: card.id, pr, error: String(error).slice(0, 250) }); } catch { /* fail-soft */ } }
+  }
   return observe(deps, withRepo({ kind, card: card.id, ok, executed: true, detail, landAttempt, ...(queueConfig && ok ? { queued: true } : {}) }));
 }