elanous 0.2.18 → 0.2.20

package/src/cli/tasks-cli.ts

@@ -1,11 +1,16 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { closeSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
+import { join, resolve } from 'node:path';
 import { InvalidArgumentError, Option, type Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { readNexusRuntime } from '../nexus/runtime.js';
+import { checklistDevVersion } from '../release-loop/checklist.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 { handTask, nextMoveFor, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type TaskCard, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { cardPrNumber, COMPLETION_KINDS, handTask, nextMoveFor, 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 { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
 
 type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
@@ -25,6 +30,10 @@ export interface TasksCliDeps {
   missionDecompose?: MissionDecompose;
   /** `task advance` 의 착지 근거 읽기(시험 주입). 기본 = `predecessorState`(gh · 런 원장). */
   pieceEvidence?: PieceEvidenceReader;
+  /** `task board` 의 내부 팩 어댑터(시험 주입). 기본 = 현재 판(`checklistDevVersion()`)의 `releasePackBoard` — 읽기만. */
+  releaseBoard?: () => BoardNode[];
+  /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
+  cardRunEvidence?: CardRunEvidenceDeps;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -65,16 +74,103 @@ export async function registerTaskAgentSink(register?: (surface: string) => Prom
  * config-dir 은 명시(`--config-dir`/`--test`)가 있으면 그것, 없으면 운영 루트(`prodInstanceRoot()`)다.
  * (작업 트리에서 그냥 띄우면 test 우주로 가서 동결·몫·풀 상한 밖에서 돈다.)
  */
-export async function defaultTaskLauncher(args: string[]): Promise<void> {
-  const { spawn } = await import('node:child_process');
+/** This package's CLI entry — never `process.argv[1]`, which is whatever script started this process
+ *  (ORCH-LIVE-1008: the orchestrator tick runs `bun …/tick.ts delegate`, so the hand launched `tick.ts --config-dir …
+ *  harness say …`, which exited 2 with stdio ignored — the card said `launched` and no run ever started). */
+export const ELANOUS_CLI_ENTRY = resolve(import.meta.dir, '../../bin/elanous.mjs');
+
+/** argv for a detached `elanous` child that runs `args` in `configDir`. */
+export function taskLauncherArgv(configDir: string, args: readonly string[]): string[] {
+  return [ELANOUS_CLI_ENTRY, '--config-dir', configDir, ...args];
+}
+
+/** STOP-RECORD launch-failed: 발사 직후 이 창 안에 자식이 비0 으로 끝나면 «발사 실패»로 본다. */
+export const LAUNCH_EARLY_EXIT_WINDOW_MS = 3_000;
+
+export interface DefaultTaskLauncherDeps {
+  spawn?: DetachedSpawn;
+  /** 조기 종료 감시 창(ms) — context(런 id)가 있을 때만 · 0 이면 감시하지 않는다(옛 동작). */
+  earlyExitWindowMs?: number;
+  /** 자식 stderr 를 받을 디렉토리(시험 주입). 기본 = `<tmpdir>/elanous-task-launch`. */
+  stderrDir?: string;
+  /** stop 줄 기록기(시험 주입). 기본 = 런 원장. */
+  writeStop?: import('../self-implement/run-ledger.js').RunLedgerWriter;
+  /** 이미 stop 이 있나(시험 주입). 기본 = 이 우주 런 원장 ⊕ 이 프로세스 기록. */
+  hasStop?: (runId: string) => boolean;
+}
+
+/** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
+function firstStderrLine(path: string): string {
+  try {
+    const fd = openSync(path, 'r');
+    try {
+      const buf = Buffer.alloc(4096);
+      const n = readSync(fd, buf, 0, buf.length, 0);
+      return buf.subarray(0, n).toString('utf8').split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? '';
+    } finally { closeSync(fd); }
+  } catch { return ''; }
+}
+
+export async function defaultTaskLauncher(args: string[], cwd?: string, context?: TaskLaunchContext, deps: DefaultTaskLauncherDeps = {}): Promise<void | TaskLaunchReceipt> {
+  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');
   const configDir = getElanousConfigDirOverride() ?? prodInstanceRoot();
-  await spawnDetachedConfirmed(spawn as unknown as DetachedSpawn, process.execPath, [process.argv[1]!, '--config-dir', configDir, ...args]);
+  const argv = taskLauncherArgv(configDir, args);
+  const window = context ? deps.earlyExitWindowMs ?? LAUNCH_EARLY_EXIT_WINDOW_MS : 0;
+  if (!context || window <= 0) {
+    // TA-CARD-RUN-LINK: 런 id 를 자식 환경에 얹는다 — `harness say` 의 런(호스트 orchestrate)이 그 id 를 상속한다.
+    await spawnDetachedConfirmed(spawn, process.execPath, argv, SPAWN_CONFIRM_TIMEOUT_MS, cwd, context?.env);
+    return context ? { runId: context.runId } : undefined;
+  }
+  // STOP-RECORD launch-failed: stdio 를 버리면 자식이 exit 2 로 죽어도 흔적이 0 이고 카드는 «launched» 로 남는다
+  // (ORCH-LIVE-1008). stderr 만 파일로 받고(파이프는 부모가 먼저 끝나면 자식을 EPIPE 로 죽인다), 짧은 창 안의 종료를 본다.
+  const stderrDir = deps.stderrDir ?? join(tmpdir(), 'elanous-task-launch');
+  mkdirSync(stderrDir, { recursive: true });
+  const stderrPath = join(stderrDir, `${context.runId}.stderr`);
+  // 'w' — 같은 runId 재발사가 지난 시도의 stderr 를 이번 cause 로 읽지 않게(리뷰 must-fix).
+  const fd = openSync(stderrPath, 'w');
+  let exited: Promise<{ code: number | null; signal: string | null }> | undefined;
+  const watched: DetachedSpawn = (command, spawnArgs, options) => {
+    const child = (spawn as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, spawnArgs, { ...options, stdio: ['ignore', 'ignore', fd] });
+    const emitter = child as unknown as { once?: (event: 'exit', listener: (code: number | null, signal: string | null) => void) => unknown };
+    exited = new Promise((done) => { emitter.once?.('exit', (code, signal) => done({ code, signal })); });
+    return child;
+  };
+  try {
+    await spawnDetachedConfirmed(watched, process.execPath, argv, SPAWN_CONFIRM_TIMEOUT_MS, cwd, context.env);
+  } finally {
+    try { closeSync(fd); } catch { /* the child keeps its own copy */ }
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const early = exited
+    ? await Promise.race([exited, new Promise<undefined>((done) => { timer = setTimeout(() => done(undefined), window); })])
+    : undefined;
+  if (timer) clearTimeout(timer);
+  if (early && early.code !== 0) {
+    const first = firstStderrLine(stderrPath);
+    const cause = `child rc=${early.code ?? early.signal ?? 'unknown'}${first ? `: ${first}` : ''}`;
+    const { boundRunStopCause, recordRunStop, runStopRecorded, RUN_STOP_EVENT } = await import('../self-implement/run-stop.js');
+    const hasStop = deps.hasStop ?? ((id: string) => {
+      if (runStopRecorded(id)) return true;
+      try { return (loadRunLedgerSync(id) ?? []).some((entry) => entry.event === RUN_STOP_EVENT); } catch { return false; }
+    });
+    // 자식이 같은 runId 로 이미 stop 을 썼으면 더하지 않는다(런마다 한 줄 · 리뷰 must-fix).
+    if (hasStop(context.runId)) throw new Error(`발사 직후 자식이 종료했다 — ${boundRunStopCause(cause)}`);
+    const entry = recordRunStop({
+      runId: context.runId, site: 'launch-failed', class: 'launch-failed',
+      cause,
+      evidenceRef: stderrPath,
+      nextMove: 'Fix the launch argv/config from the stderr evidence, then re-hand the card',
+    }, ...(deps.writeStop ? [deps.writeStop] : []));
+    // handTask 가 이 예외로 카드를 `launch-failed` 로 적는다(«launched» 로 남지 않게).
+    throw new Error(`발사 직후 자식이 종료했다 — ${String(entry.data.cause)}`);
+  }
+  return { runId: context.runId };
 }
 
 /** `spawn` 의 필요한 면만(시험 주입). */
-export type DetachedSpawn = (command: string, args: string[], options: { detached: true; stdio: 'ignore' }) => {
+export type DetachedSpawn = (command: string, args: string[], options: { detached: true; stdio: 'ignore'; cwd?: string; env?: NodeJS.ProcessEnv }) => {
   pid?: number;
   once(event: 'spawn', listener: () => void): unknown;
   once(event: 'error', listener: (error: Error) => void): unknown;
@@ -89,10 +185,10 @@ export const SPAWN_CONFIRM_TIMEOUT_MS = 2_000;
  * 떼어 띄우고 «떴는지» 확인한다 — 'spawn' 이면 성공, 'error'(ENOENT·EACCES 등)면 던진다.
  * 확인 없이 돌려주면 비동기 error 가 처리되지 않고 카드가 `launched` 로 남는다(사후 리뷰 must-fix).
  */
-export function spawnDetachedConfirmed(spawnFn: DetachedSpawn, command: string, args: string[], timeoutMs = SPAWN_CONFIRM_TIMEOUT_MS): Promise<void> {
+export function spawnDetachedConfirmed(spawnFn: DetachedSpawn, command: string, args: string[], timeoutMs = SPAWN_CONFIRM_TIMEOUT_MS, cwd?: string, env?: Record<string, string>): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     let child: ReturnType<DetachedSpawn>;
-    try { child = spawnFn(command, args, { detached: true, stdio: 'ignore' }); } catch (error) { reject(error); return; }
+    try { child = spawnFn(command, args, { detached: true, stdio: 'ignore', ...(cwd ? { cwd } : {}), ...(env ? { env: { ...process.env, ...env } } : {}) }); } catch (error) { reject(error); return; }
     let settled = false;
     const finish = (error?: Error) => {
       if (settled) return;
@@ -122,10 +218,20 @@ function headLine(text: string): string {
   return first.length > 100 ? `${first.slice(0, 100)}…` : first;
 }
 
+/** 런 연결 한 줄 — 런 id 가 없으면 없다(옛 카드 · shadow). */
+function runLinkLine(card: TaskCard): string[] {
+  if (!card.runId) return [];
+  const number = cardPrNumber(card);
+  const url = typeof card.pr === 'object' ? card.pr.url : undefined;
+  const pr = number !== undefined ? `#${number}${url ? ` ${url}` : ''}` : '-';
+  return [`런: ${card.runId} · 골: ${card.goalId ?? '-'} · PR: ${pr}${card.runChildId ? ` · 자식 런: ${card.runChildId}` : ''}`];
+}
+
 function taskCardLines(card: TaskCard): string[] {
   return [
     [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
     ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
+    ...runLinkLine(card),
     `다음 수: ${moveLine(card)}`,
   ];
 }
@@ -135,7 +241,8 @@ function missionLines(mission: TaskCard, pieces: TaskCard[]): string[] {
   const edges = pieces.flatMap((piece) => (piece.after ?? []).map((before) => `간선: ${before} -> ${piece.id}`));
   return [
     [mission.id, 'mission', mission.seat ?? '-', mission.checklistId ?? '-', mission.createdAt, `조각 ${pieces.length} · 간선 ${edges.length} · 출처 ${mission.splitSource ?? '-'}`, headLine(mission.text)].join('\t'),
-    ...pieces.map((piece) => [`조각: ${piece.id}`, piece.status, nextMoveFor(piece).kind, `after: ${piece.after?.length ? piece.after.join(',') : '-'}`, headLine(piece.text)].join('\t')),
+    ...pieces.map((piece) => [`조각: ${piece.id}`, piece.status, nextMoveFor(piece).kind, `after: ${piece.after?.length ? piece.after.join(',') : '-'}`, headLine(piece.text),
+      ...(piece.runId ? [`런: ${piece.runId}${cardPrNumber(piece) !== undefined ? ` · PR #${cardPrNumber(piece)}` : ''}`] : [])].join('\t')),
     ...edges,
     ...(mission.greenProposal ? [`green 제안: ${mission.greenProposal.at} · 칸 ${mission.greenProposal.checklistId ?? '-'} · 근거 ${Object.entries(mission.greenProposal.evidence).map(([id, ref]) => `${id}=${ref}`).join(', ')}`] : []),
   ];
@@ -255,16 +362,31 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .description('TASK-AGENT 에 과제 한 줄을 넘긴다 — 카드를 적고 첫 수(harness say --substrate pod --merge-by-host)를 고른다 · 기본 shadow(발사 0) · `--mission` 이면 조각 카드 ⊕ 선후로 쪼개 선행 없는 조각만 넘긴다')
     .addOption(new Option('--seat <seat>', `과제 자리 (${TASK_SEATS.join('|')})`).choices([...TASK_SEATS]))
     .option('--checklist <cellId>', '릴리스 체크리스트 칸 id')
+    .addOption(new Option('--completion <kind>', `종결 종류 (${COMPLETION_KINDS.join('|')} · 기본 code-pr = PR 병합)`).choices([...COMPLETION_KINDS]))
     .option('--mission <text>', '미션 문면 — 조각(`- …`·`① …`·`1. …` ⊕ `after: 1`)으로 나열돼 있으면 결정론, 아니면 분해기로 쪼갠다')
+    .option('--project <id>', '프로젝트 id — --target 과 함께')
+    .option('--goal <id>', '보드 소속 목표 id (task board)')
+    .option('--milestone <id>', '보드 소속 이정표 id (task board)')
+    .option('--target <dir>', '프로젝트 대상 디렉터리(있어야 한다 · 상대 경로는 절대로 · git 이 아니면 --completion 이 code-pr 밖이어야 한다) — 발사기를 이 디렉터리에서 띄운다')
     .option('--live', '실제로 발사한다(기본은 shadow — 명령만 출력)')
     .option('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; mission?: string; live?: boolean; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; json?: boolean }) => {
       await registerTaskAgentSink(deps.registerSink);
       if ((text === undefined) === (opts.mission === undefined)) {
         out('과제 한 줄 «또는» --mission <문면> 중 하나만 준다');
         process.exitCode = 1;
         return;
       }
+      if ((opts.project === undefined) !== (opts.target === undefined)) {
+        out('--project <id> 와 --target <dir> 를 함께 줘야 한다');
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.mission !== undefined && (opts.completion !== undefined || opts.project !== undefined || opts.goal !== undefined || opts.milestone !== undefined)) {
+        out('--completion/--project/--target/--goal/--milestone 은 과제 한 줄에만 준다 — --mission 조각은 종전처럼 code-pr 이다');
+        process.exitCode = 1;
+        return;
+      }
       if (opts.mission !== undefined) {
         try {
           const result = await handMission({
@@ -297,8 +419,12 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       try {
         const result = await handTask({
           text: text!,
+          ...(opts.project !== undefined && opts.target !== undefined ? { project: { id: opts.project, target: opts.target } } : {}),
+          ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
+          ...(opts.milestone !== undefined ? { milestone: opts.milestone } : {}),
           ...(opts.seat ? { seat: opts.seat } : {}),
           ...(opts.checklist ? { checklistId: opts.checklist } : {}),
+          ...(opts.completion ? { completion: opts.completion } : {}),
           live: opts.live === true,
           ...(deps.taskStatePath ? { statePath: deps.taskStatePath } : {}),
           launcher: deps.taskLauncher ?? defaultTaskLauncher,
@@ -307,6 +433,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         else {
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
+          if (result.cwd) out(`(cwd: ${result.cwd})`);
           if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
@@ -315,6 +442,37 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
+  tasks.command('board')
+    .description('보드 — 프로젝트 › 목표 › 이정표 › 과제. 과제 카드(project·goal·milestone)와 내부 팩(릴리스 체크리스트 = elanous › 판 › 칸)을 합쳐 읽는다(쓰지 않는다)')
+    .option('--project <id>', '이 프로젝트만')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { project?: string; json?: boolean }) => {
+      await registerTaskAgentSink(deps.registerSink);
+      try {
+        // 내부 팩은 elanous 프로젝트만 낸다 — 다른 프로젝트로 거르면 릴리스 원장을 열지 않는다(그 원장의 오류가 카드 보드를 막지 않게).
+        const wantsPack = opts.project === undefined || opts.project === INTERNAL_PACK_PROJECT;
+        const board = mergeBoards(
+          cardsBoard(deps.taskStatePath ?? taskStatePathDefault()),
+          wantsPack ? (deps.releaseBoard ?? (() => releasePackBoard(checklistDevVersion())))() : [],
+        );
+        // 무소속(unassigned: true)은 어떤 --project 로도 고르지 않는다 — 실제 프로젝트 id 와 겹치지 않게.
+        const selected = opts.project !== undefined ? board.filter((project) => project.unassigned !== true && project.id === opts.project) : board;
+        try { debug.log('task-agent', 'board', { projects: selected.length, tasks: countBoardTasks(selected), project: opts.project ?? null }); } catch { /* fail-soft */ }
+        if (opts.json) out(JSON.stringify(selected));
+        else {
+          const show = (node: BoardNode, depth: number): void => {
+            out(`${'  '.repeat(depth)}${node.level}\t${node.id}\t${node.status}\t${headLine(node.title)}`);
+            for (const next of node.children ?? []) show(next, depth + 1);
+          };
+          if (selected.length === 0) out(opts.project !== undefined ? `프로젝트 없음: ${opts.project}` : '보드가 비어 있다');
+          for (const project of selected) show(project, 0);
+        }
+      } catch (error) {
+        out(error instanceof Error ? error.message : '보드 읽기 실패');
+        process.exitCode = 1;
+      }
+    });
+
   tasks.command('advance [missionId]')
     .description('TASK-AGENT 미션 ② — 조각의 PR 병합(근거: `--pr`/`--goal` 로 카드에 적은 PR 번호·골 id)으로 착지를 가르고 새로 준비된 조각만 한 번 넘긴다 · 모두 착지면 green «제안»만 적는다 · 기본 shadow(발사 0)')
     .option('--all', 'green 제안이 아직 없는 미션 전부')
@@ -366,6 +524,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
               ...(statePath ? { statePath } : {}),
               launcher: deps.taskLauncher ?? defaultTaskLauncher,
               ...(deps.pieceEvidence ? { readEvidence: deps.pieceEvidence } : {}),
+              ...(deps.cardRunEvidence ? { runEvidence: deps.cardRunEvidence } : {}),
             }));
           } catch (error) {
             // 미션 id 하나면 그대로 실패 · --all 이면 그 미션만 실패로 적고 다음 미션으로 간다(크론이 한 미션에 막히지 않게).
@@ -405,7 +564,18 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       if (id.startsWith(TASK_CARD_PREFIX)) {
         await registerTaskAgentSink(deps.registerSink);
         let card: TaskCard | undefined;
-        try { card = readTaskCard(id, deps.taskStatePath); } catch (error) {
+        try {
+          card = readTaskCard(id, deps.taskStatePath);
+          // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
+          const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
+          for (const cardId of bindable) {
+            try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+              // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
+              try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+            }
+          }
+          if (card) card = readTaskCard(id, deps.taskStatePath);
+        } catch (error) {
           out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
           process.exitCode = 1;
           return;
@@ -430,8 +600,17 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           }
           return;
         }
-        if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card) }));
-        else for (const line of taskCardLines(card)) out(line);
+        // DRAFT-NOT-ARCHIVE: 멈춘 런이 draft PR 대신 남긴 수확 가지(원장 `salvaged`). 못 읽었으면 «못 읽음»(⛔ 없음 아님).
+        let salvage: Awaited<ReturnType<typeof readCardSalvageBranch>> = { salvageBranch: null };
+        try { salvage = await readCardSalvageBranch(card, deps.cardRunEvidence ?? {}); }
+        catch (error) { salvage = { salvageBranch: null, readErrors: [error instanceof Error ? error.message : String(error)] }; }
+        const salvageUnread = !salvage.salvageBranch && !!salvage.readErrors?.length;
+        if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
+        else {
+          for (const line of taskCardLines(card)) out(line);
+          if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
+          else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
+        }
         return;
       }
       try {

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

@@ -72,7 +72,7 @@ export function filterPublicDemoContext(answer: ContextNowAnswer, brandCheck: ty
           id: fact.id ? (rulesMissing || privateIds.has(fact.id) ? '내부 항목' : safe(fact.id, '공개 항목')) : null,
           title: fact.title === null ? null : rulesMissing ? internalItem(1) : privateIds.has(fact.id ?? '') ? '내부 항목' : safe(fact.title, '공개 항목'),
           source: source(fact.source) });
-      } else facts.push({ ...fact, version: safe(fact.version, '공개 판'), source: source(fact.source) });
+      } else if (fact.kind === 'version') facts.push({ ...fact, version: safe(fact.version, '공개 판'), source: source(fact.source) });
     }
     for (const kind of ['cell', 'decision'] as const) {
       if (!collapsed[kind]) continue;

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

@@ -34,6 +34,9 @@ function factText(fact: ContextFact): string {
     case 'cell': return `${fact.id} ${fact.title} (${fact.status})`;
     case 'decision': return `${fact.id} ${fact.title} (${fact.status})`;
     case 'seat': return `${fact.seat} ${fact.id ?? ''} ${fact.title ?? ''} (${fact.status})`.trim();
+    case 'run': return fact.unreadable ? `못 읽음 · ${fact.unreadable}` : `${fact.goal} · ${fact.phase} · ${fact.elapsed}`;
+    case 'release': return fact.unreadable ? `못 읽음 · ${fact.unreadable}` : `${fact.version} · ${fact.node} · ${fact.status}`;
+    case 'schedule-late': return fact.unreadable ? `못 읽음 · ${fact.unreadable}` : `${fact.count}개 · ${fact.names.join(', ') || '없음'}`;
   }
 }
 
@@ -61,20 +64,27 @@ export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudien
     if (source.startsWith('elanous://release/')) return '원장';
     return Array.from(source).slice(0, 40).join('');
   };
-  const factLabels = { version: '판', cell: '칸', decision: '결정', seat: '자리' } as const;
+  const factLabels = { run: '도는 런', release: '발행 런', 'schedule-late': '지연 스케줄', version: '판', cell: '칸', decision: '결정', seat: '자리' } as const;
   const eventLabels: Record<string, string> = { report: '보고', dispatch: '발사', decision: '결정' };
   const events = answer.events.slice().sort((a, b) => Date.parse(b.at) - Date.parse(a.at));
   const rows = [
-    ...answer.facts.map(f => [factLabels[f.kind], shortText(factText(f)), shortSource(f.source)]),
+    ...answer.facts.slice().sort((a, b) => {
+      const priority = (kind: ContextFact['kind']) => ({ run: 0, release: 1, 'schedule-late': 2 } as Partial<Record<ContextFact['kind'], number>>)[kind] ?? 3;
+      return priority(a.kind) - priority(b.kind);
+    }).map(f => [factLabels[f.kind], shortText(factText(f)), shortSource(f.source)]),
     ...events.slice(0, 8).map(e => [eventLabels[e.kind] ?? '소식', shortText(e.summary), shortSource(e.source)]),
     ...answer.guide.map(guide => ['안내', guide, '']),
     ...(events.length > 8 ? [['안내', `… 사건 ${events.length - 8}개 더(/now <주제> 로 좁히기)`, '']] : []),
   ];
+  const clean = (text: string) => text.replaceAll('|', ' ').replaceAll(/\r?\n/g, ' ');
+  const width = (text: string) => Array.from(text).reduce((total, char) => total + (/[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe6f\uff01-\uff60\uffe0-\uffe6]/u.test(char) ? 2 : 1), 0);
+  const data = [['종류', '사실', '출처'], ...rows].map(row => row.map(clean));
+  const widths = [0, 1].map(i => Math.max(...data.map(row => width(row[i] ?? ''))));
+  const format = (row: string[]) => `${row[0]}${' '.repeat(widths[0]! - width(row[0]!) + 2)}${row[1]}${' '.repeat(widths[1]! - width(row[1]!) + 2)}${row[2]}`;
+  const time = new Intl.DateTimeFormat('en-GB', { timeZone: 'Asia/Seoul', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).format(new Date(answer.at));
   return [
-    `지금${answer.topic ? ` · ${answer.topic}` : ''} (${answer.at})`,
-    '| 종류 | 사실 | 출처 |',
-    '| --- | --- | --- |',
-    ...rows.map(row => `| ${row.map(cell => cell.replaceAll('|', '\\|').replaceAll(/\r?\n/g, ' ')).join(' | ')} |`),
+    `지금${answer.topic ? ` · ${answer.topic}` : ''} (${time} KST)`,
+    ...data.map(format),
   ];
 }
 

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

@@ -1,4 +1,8 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
+import { loadRunLedger } 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';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
@@ -12,7 +16,10 @@ export type ContextFact =
   | { kind: 'version'; version: string; source: string }
   | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string }
   | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
-  | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string };
+  | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string }
+  | { kind: 'run'; goal: string; phase: string; elapsed: string; source: string; unreadable?: string }
+  | { kind: 'release'; version: string; node: string; status: string; source: string; unreadable?: string }
+  | { kind: 'schedule-late'; count: number | null; names: string[]; source: string; unreadable?: string };
 export type ContextEvent = { at: string; kind: string; summary: string; source: string };
 export type ContextNowAnswer = { at: string; topic: string | null; facts: ContextFact[]; events: ContextEvent[]; guide: string[]; hiddenCount?: number };
 
@@ -23,6 +30,10 @@ export interface ContextNowDeps {
   decisions?: () => DecisionEntry[];
   seatEntries?: (now: Date) => Array<{ entry: SeatEntry; source: string }>;
   events?: (since: string) => CoordEvent[];
+  runningRuns?: (now: Date) => Extract<ContextFact, { kind: 'run' }>[];
+  queryRuns?: () => QueriedRunningRunsResult;
+  releaseRun?: () => Extract<ContextFact, { kind: 'release' }> | null;
+  lateSchedules?: (now: Date) => Extract<ContextFact, { kind: 'schedule-late' }> | null;
   brandCheck?: typeof checkBrand;
 }
 
@@ -39,6 +50,75 @@ function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }
   });
 }
 
+const runSource = 'elanous://self-implement/running-runs';
+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' }>[] {
+  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 => {
+    let ledgerReadFailure = false;
+    const starts = entry.ledgerDirectories.flatMap(directory => {
+      try { return loadRunLedger(entry.runId, directory)?.filter(record => record.event === 'start') ?? []; }
+      catch { ledgerReadFailure = true; return []; }
+    });
+    const goalRecord = starts.find(record => typeof record.data.feature === 'string' && record.data.feature.trim());
+    const goal = typeof goalRecord?.data.feature === 'string' ? goalRecord.data.feature : ledgerReadFailure ? '골 관측 불가' : '골 미기록';
+    const started = starts.map(record => record.timestamp ? Date.parse(record.timestamp) : NaN).find(Number.isFinite) ?? NaN;
+    const minutes = Number.isFinite(started)
+      ? Math.max(0, Math.floor((now.getTime() - started) / 60_000)) : null;
+    const fact = { kind: 'run' as const, goal: oneLine(goal),
+      phase: entry.lastPhase ?? '단계 미관측', elapsed: minutes === null ? ledgerReadFailure ? '경과 관측 불가' : '경과 미관측' : `${minutes}분`,
+      source: `${runSource}/${encodeURIComponent(entry.runId)}` };
+    return ledgerReadFailure
+      ? [
+          ...(goalRecord || minutes !== null ? [fact] : []),
+          { kind: 'run' as const, goal: '', phase: '', elapsed: '', source: fact.source, unreadable: '런 원장 일부 관측 불가' },
+        ] : [fact];
+  });
+  return unreadable ? [...facts, { kind: 'run', goal: '', phase: '', elapsed: '', source: runSource, unreadable: '런 원장 또는 관측 대상 일부' }] : facts;
+}
+
+function latestReleaseRun(): Extract<ContextFact, { kind: 'release' }> | null {
+  const dir = join(effectiveInstanceRoot(), 'graph-runs', 'release-loop');
+  let filenames: string[];
+  try { filenames = readdirSync(dir).filter(name => /^[A-Za-z0-9-]+\.json$/.test(name)); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+  const runs = filenames.flatMap(filename => {
+    const path = join(dir, filename);
+    let run: { startedAt?: unknown; status?: unknown; input?: { version?: unknown }; path?: unknown; nodes?: unknown };
+    try {
+      if (!lstatSync(path).isFile()) return [];
+      run = JSON.parse(readFileSync(path, 'utf8'));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT' || error instanceof SyntaxError) return [];
+      throw error;
+    }
+    if (typeof run.startedAt !== 'string' || typeof run.status !== 'string' || !Array.isArray(run.path) || !Array.isArray(run.nodes)) return [];
+    const steps = run.path.filter((step): step is string => typeof step === 'string');
+    const nodes = run.nodes.filter((node): node is { nodeId: string } => !!node && typeof node.nodeId === 'string');
+    const version = typeof run.input?.version === 'string' && /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(run.input.version) ? run.input.version : '판 미기록';
+    const index = Math.min(steps.length, nodes.length + (run.status === 'running' || run.status === 'awaiting-approval' ? 1 : 0));
+    return [{ startedAt: run.startedAt, fact: { kind: 'release' as const, version, node: `${index}/${steps.length}${steps[index - 1] ? ` ${oneLine(steps[index - 1]!)}` : ''}`,
+      status: oneLine(run.status), source: `${releaseSource}/${encodeURIComponent(filename.slice(0, -5))}` } }];
+  });
+  return runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt))[0]?.fact ?? null;
+}
+
+function lateScheduleFact(now: Date): Extract<ContextFact, { kind: 'schedule-late' }> {
+  const names = localLoopRows(now).filter(row => row.verdict === 'late').map(row => oneLine(row.name));
+  return { kind: 'schedule-late', count: names.length, names, source: scheduleSource };
+}
+
+function unreadableReason(error: unknown): string {
+  return oneLine(error instanceof Error ? error.message : String(error)) || '원천 조회 실패';
+}
+
 /** Read a bounded, source-labelled view of current ledgers, never a transcript or decision body. */
 export function contextNow(options: { topic?: string; limit?: number; audience?: 'operator' | 'user' | 'public-demo' } = {}, deps: ContextNowDeps = {}): ContextNowAnswer {
   const now = (deps.now ?? (() => new Date()))();
@@ -71,6 +151,20 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
   const rawEvents = (deps.events ?? (since => listCoordEvents({ since })))(new Date(now.getTime() - 7 * 86_400_000).toISOString());
   const chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at));
   const matches = (text: string) => !topic || text.toLocaleLowerCase().includes(topic.toLocaleLowerCase());
+  const operational: ContextFact[] = [];
+  if (options.audience !== 'public-demo') {
+    try { operational.push(...(deps.runningRuns ?? (date => runningRunFacts(date, deps.queryRuns)))(now)); }
+    catch (error) { operational.push({ kind: 'run', goal: '', phase: '', elapsed: '', source: runSource, unreadable: unreadableReason(error) }); }
+    try {
+      const release = (deps.releaseRun ?? latestReleaseRun)();
+      if (release) operational.push(release);
+    } catch (error) { operational.push({ kind: 'release', version: '', node: '', status: '', source: releaseSource, unreadable: unreadableReason(error) }); }
+    try { const schedules = (deps.lateSchedules ?? lateScheduleFact)(now); if (schedules) operational.push(schedules); }
+    catch (error) { operational.push({ kind: 'schedule-late', count: null, names: [], source: scheduleSource, unreadable: unreadableReason(error) }); }
+  }
+  const selectedOperational = operational.filter(f => !topic || ('unreadable' in f && !!f.unreadable) || (f.kind === 'run' && matches(`${f.goal} ${f.phase}`))
+    || (f.kind === 'release' && matches(`${f.version} ${f.node} ${f.status}`))
+    || (f.kind === 'schedule-late' && matches(f.names.join(' '))));
   const selectedFacts = facts.filter(f => !topic || (f.kind === 'cell' && matches(`${f.id} ${f.title}`))
     || (f.kind === 'seat' && matches(`${f.id ?? ''} ${f.title ?? ''}`)));
   const groups = (['version', 'cell', 'decision', 'seat'] as const).map(kind => selectedFacts.filter(f => f.kind === kind));
@@ -92,7 +186,7 @@ export function contextNow(options: { topic?: string; limit?: number; audience?:
     chosen[index]!.push(...extra);
     remaining -= extra.length;
   }
-  const boundedFacts = chosen.flat();
+  const boundedFacts = [...selectedOperational.slice(0, limit), ...chosen.flat()];
   const summaries = chronologicalEvents.map(event => ({
     at: event.at, kind: event.kind, summary: redactSecretText(event.summary.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
     source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}`,

package/src/core-turn/short-question.ts

@@ -0,0 +1,100 @@
+// B1(UX · 0.2.7) — 짧은 «물음»은 도구 없이 빠른 경로로(첫 글자 ≤2초 · 내부 문서 `EVAL-bot-chat-vs-grok-2026-09-30`).
+// 허용 방식(골 ASK-bot-short-question-fast-path-b1b): 아래가 «모두» 참일 때만 fast — 하나라도 거짓이면 fast 아님(보수 쪽).
+//   ⓐ 한 줄 · 80자 이하 · 첨부 없음 ⓑ 인사이거나 «물음 꼴» ⓒ 요청·작업 표지 · 경로·URL·코드 꼴 · 실시간 낱말이 없다.
+// 거부 목록으로 변형을 다 막을 수는 없다 — 오분류 비용은 «확인해 볼까요?» 한 줄로 막힌다(도구가 안 실릴 뿐 대화는 이어진다).
+// 판정 표본 = src/chat/short-question.test.ts 의 고정 표 20개(⊕ 리뷰가 든 변형).
+
+export interface ShortQuestionContext {
+  hasAttachments?: boolean;
+}
+export interface ShortQuestionVerdict {
+  fast: boolean;
+  reason: string;
+}
+
+const GREETING = /^(?:안녕(?:하세요|하십니까)?|반가워(?:요)?|고마워(?:요)?|감사합니다|하이|hi|hello|hey|thanks|thank you)[!?.~\s]*$/i;
+// «한 줄로» 같은 짧은 꼬리를 떼고 본다.
+const TAIL = /\s*(?:한\s*줄로|짧게|간단히|briefly|in one line)[.!]?\s*$/i;
+const KO_QUESTION_END = /(?:\?|까|니|나요|냐|야|어때|뭐|몇|언제|어디|누구|왜|인가|일까)[?.!~]*$/;
+const EN_QUESTION = /^(?:what|why|how|who|where|when|which|is|are|does|do)\b.*\?$/i;
+const REQUEST_KO = /(?:해\s*줘|해\s*주세요|줘(?:요)?(?=[?.!\s]|$)|주세요|줄래|할래|볼래|줄\s*수\s*있|돌려|실행|고쳐|만들어\s*줘|찾아|검색|확인해|열어|보내|올려|지워|써\s*줘|작성해|요약해|정리해|분석해)/;
+const REQUEST_EN = /\b(?:please|can you|could you|would you|run|test|tests|fix|build|open|search|check|send|create|write|deploy|install|summarize)\b/i;
+const TASK = /(?:작업|파일|폴더|디렉터리|레포|저장소|커밋|브랜치|\bPR\b|코드|스크립트|테스트|빌드|배포|설치|설정|명령어|로그|버그|이슈)/i;
+const PATH_OR_CODE = /(?:https?:\/\/|www\.|[\w.-]+\/[\w./-]+|\.(?:ts|tsx|js|py|md|json|yaml|swift|kt)\b|[`{};=<>])/i;
+const LIVE = /(?:오늘\s*(?:날짜|며칠|무슨\s*요일)|지금\s*몇\s*시|최신|뉴스|속보|주가|시세|환율|날씨|today'?s|latest|news|stock|weather|right now)/i;
+
+export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '코딩·구현';
+
+export interface TuiChatVerdict {
+  route: TuiChatRoute;
+  reason: string;
+  goalLoop: boolean;
+}
+
+/** Request verbs a quick lookup/settings/research/scheduling turn can carry out without the repository. */
+const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내)$/;
+
+/** True when the verb never appears, or each occurrence directly follows an allowed object. */
+function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
+  for (const match of text.matchAll(verb)) {
+    if (!object.test(text.slice(0, match.index))) return false;
+  }
+  return true;
+}
+
+/** Uncertain or mixed requests retain the full coding goal-loop and tool surface. */
+export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext = {}): TuiChatVerdict {
+  const q = text.trim();
+  const coding = (reason: string): TuiChatVerdict => ({ route: '코딩·구현', reason, goalLoop: true });
+  if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
+  if (/(?:하니스|구현|코딩|코드|스크립트|버그|소스|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:implement|coding|code|script|refactor|commit|patch|tests?|build|deploy|branch|server|file|repo)\b)/i.test(q)) return coding('coding');
+  // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
+  // A file path or code shape means the request touches the repository, whatever else it asks.
+  if (PATH_OR_CODE.test(q)) return coding('path-or-code');
+  // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
+  // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
+  for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {
+    if (!QUICK_REQUEST_VERBS.test(match[1]!)) return coding('request-verb');
+  }
+  // Edit and create verbs are coding requests unless every one of them takes a quick object directly
+  // («모델 설정 수정해줘» · «알림 만들어줘» stay quick; «… 그리고 화면 고쳐줘» does not).
+  if (!everyVerbTakes(q, /(?:수정|고쳐|바꿔|변경|전환|교체|\b(?:edit|fix|modify|change|switch|replace)\b)/gi, /(?:모델|설정|config|provider|예약|일정|알림|리마인더|스케줄|reminder|schedule)\s*(?:을|를|로|으로)?\s*$/i)) return coding('edit');
+  if (!everyVerbTakes(q, /(?:만들어|작성|추가해|생성|등록해|\b(?:create|write|make|add)\b)/gi, /(?:알림|일정|예약|리마인더|스케줄|reminder|schedule)\s*(?:을|를)?\s*$/i)) return coding('create');
+
+  const routes: Array<{ route: Exclude<TuiChatRoute, '코딩·구현'>; reason: string; pattern: RegExp }> = [
+    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|\b(?:status|logs?|pending decisions?)\b)/i },
+    { route: '설정 변경', reason: 'settings', pattern: /(?:(?:모델|설정|config|provider).*(?:바꿔|변경|전환|설정해|맞춰|수정|고쳐|써\s*줘|set|change|switch|edit|fix|modify)|(?:바꿔|변경|전환).*(?:모델|설정|config|provider)|답변.*빠른\s*모델)/i },
+    { route: '조사', reason: 'research', pattern: /(?:조사|검색|찾아\s*봐|뉴스|업계\s*소식|\b(?:research|search|news)\b)/i },
+    { route: '상시 일', reason: 'recurring', pattern: /(?:매일|매주|매달|매\s*아침|[가-힣]+마다|정기적|반복\s*일정|예약|리마인더|\b(?:daily|weekly|every|schedule|remind)\b)/i },
+  ];
+  const matches = routes.filter(({ pattern }) => pattern.test(q));
+  // A recurring job that looks something up or researches it is still a scheduling request.
+  if (matches.some(({ route }) => route === '상시 일')
+    && matches.every(({ route }) => route === '상시 일' || route === '조사' || route === '조회')) {
+    return { route: '상시 일', reason: matches.length > 1 ? 'recurring-research' : 'recurring', goalLoop: false };
+  }
+  if (matches.length !== 1) {
+    if (matches.length) return coding('mixed');
+    const shortQuestion = classifyShortQuestion(q, ctx);
+    return coding(shortQuestion.fast ? `short-${shortQuestion.reason}` : 'ambiguous');
+  }
+  const { route, reason } = matches[0]!;
+  return { route, reason, goalLoop: false };
+}
+
+export function classifyShortQuestion(text: string, ctx: ShortQuestionContext = {}): ShortQuestionVerdict {
+  const q = text.trim();
+  if (!q) return { fast: false, reason: 'empty' };
+  if (ctx.hasAttachments) return { fast: false, reason: 'attachment' };
+  if (/[\r\n\u2028\u2029]/.test(q)) return { fast: false, reason: 'multiline' };
+  if ([...q].length > 80) return { fast: false, reason: 'long' };
+  if (PATH_OR_CODE.test(q)) return { fast: false, reason: 'path-or-code' };
+  if (LIVE.test(q)) return { fast: false, reason: 'live' };
+  if (REQUEST_KO.test(q) || REQUEST_EN.test(q)) return { fast: false, reason: 'request' };
+  if (TASK.test(q)) return { fast: false, reason: 'task' };
+  if (GREETING.test(q)) return { fast: true, reason: 'greeting' };
+  const core = q.replace(TAIL, '').trim();
+  if (KO_QUESTION_END.test(core) || EN_QUESTION.test(core)) return { fast: true, reason: 'question' };
+  return { fast: false, reason: 'not-a-question' };
+}