elanous 0.2.29 → 0.2.32

package/src/chat/pickers/modals.ts

@@ -108,6 +108,10 @@ export interface ChatPickerModalBindings {
   getInputZoneHeight: () => number;
   width: number;
   getWidth?: () => number;
+  /** Live prompt anchor (input bottom row + col). When present it wins
+   *  over the mount-time `bounds` snapshot, so a terminal resize moves
+   *  an already-open picker with the prompt (TUI-PICKER-RESIZE-SHRINK). */
+  getAnchor?: () => { row: number; col: number };
   onKey?: PickerOnKey;
   onRowClick?: PickerOnRowClick;
 }
@@ -124,6 +128,7 @@ type FramedPickerSpec<T> = {
   getInputZoneHeight: () => number;
   width: number;
   getWidth?: () => number;
+  getAnchor?: () => { row: number; col: number };
   onKey?: PickerOnKey;
   onRowClick?: PickerOnRowClick;
 };
@@ -132,7 +137,8 @@ function createFramedPickerModal<T>(spec: FramedPickerSpec<T>): ModalSurface {
   const computeBounds = (): (ModalBounds & { startIdx: number; visibleCount: number }) | null => {
     const rows = spec.getRows();
     const inputZoneHeight = spec.getInputZoneHeight();
-    const bottomRow = spec.bounds.row - inputZoneHeight;
+    const anchor = spec.getAnchor?.() ?? spec.bounds;
+    const bottomRow = anchor.row - inputZoneHeight;
     if (rows.length === 0 || bottomRow < 4) return null;
     const { visibleCount, startIdx } = pickerWindow(
       rows.length,
@@ -142,7 +148,7 @@ function createFramedPickerModal<T>(spec: FramedPickerSpec<T>): ModalSurface {
     if (visibleCount <= 0) return null;
     const height = visibleCount + 3;
     const row = bottomRow - height + 1;
-    return { row, col: spec.bounds.col, width: spec.getWidth?.() ?? spec.width, height, startIdx, visibleCount };
+    return { row, col: anchor.col, width: spec.getWidth?.() ?? spec.width, height, startIdx, visibleCount };
   };
 
   /** Phase 4.5a (substrate Occam · §4-pre.7 · 2026-05-03) — update

package/src/chat/tool-interrupt-behavior.ts

@@ -0,0 +1,38 @@
+// ── 도구별 «제출로 끊어도 되나» 선언 (10-14 · 대표 «지금 밀어 넣기») ─────────────────
+//
+// 턴 중에 사용자가 «지금 밀어 넣기»를 하면, 도는 도구가 «전부» `cancel` 일 때만 턴을 끊고 그 발화로
+// 바로 이어 간다. 하나라도 `block` 이면 끊지 않고 다음 도구 경계에 최우선으로 넣는다.
+// ⭐ 기본은 `block` 이다 — 모르는 도구(쓰기·실행·자식 띄우기)를 «끊어도 된다»로 읽지 않는다.
+// ⭐ `cancel` 은 부작용 없는 읽기·대기 도구만 — 끊으면 결과를 버릴 뿐 바깥 상태가 안 바뀐다.
+//   (Claude Code `Tool.interruptBehavior()` 계약과 같은 축 · 기본 block)
+// ⚠️ 이 표가 «도구 선언 칸»이다. TUI 는 도는 도구의 «이름»만 알아서 스펙 객체가 아니라 이름으로 선언한다.
+//   새 읽기 전용 도구를 더하면 여기 한 줄을 더한다.
+
+export type ToolInterruptBehavior = 'cancel' | 'block';
+
+const DECLARED: ReadonlyMap<string, ToolInterruptBehavior> = new Map<string, ToolInterruptBehavior>([
+  ['Read', 'cancel'],
+  ['Grep', 'cancel'],
+  ['Glob', 'cancel'],
+  ['ListDir', 'cancel'],
+  ['WebSearch', 'cancel'],
+  ['WebFetch', 'cancel'],
+  // 대기·조회 — 끊어도 자식은 산다(턴만 끊는다).
+  ['AgentOutput', 'cancel'],
+  ['AgentList', 'cancel'],
+  ['TaskGet', 'cancel'],
+  ['TaskList', 'cancel'],
+]);
+
+export function toolInterruptBehavior(name: string): ToolInterruptBehavior {
+  return DECLARED.get(name) ?? 'block';
+}
+
+/**
+ * 도는 도구가 «전부» 끊어도 되는가. 도는 도구가 없으면(모델이 글을 쓰는 중) 참이다.
+ * 막는 도구 이름을 함께 낸다(안내 줄용).
+ */
+export function canInterruptRunningTools(names: readonly string[]): { ok: boolean; blocking: string[] } {
+  const blocking = [...new Set(names.filter(name => toolInterruptBehavior(name) === 'block'))].sort();
+  return { ok: blocking.length === 0, blocking };
+}

package/src/chat/tool-render/dispatch.ts

@@ -361,7 +361,11 @@ function extractSyntheticGuardSummary(result: unknown): string | null {
     return 'inspect budget exhausted — summarize inspected files';
   }
   if (text.includes('TOOL CALL REJECTED')) {
-    return 'tool budget exhausted — final answer required';
+    // Only the turn-budget stub is a budget; phase guards (VERIFY/REPAIR/INSPECT ACTION
+    // REQUIRED …) reject a tool for the current phase and must not read as «budget» (#67).
+    if (text.includes('tool-loop budget exhausted')) return 'tool budget exhausted — final answer required';
+    const reason = /\b([A-Z][A-Z]+(?: [A-Z]+)* (?:REQUIRED|EXHAUSTED))\b/.exec(text)?.[1];
+    return reason ? `tool call rejected — ${reason.toLowerCase()}` : 'tool call rejected';
   }
   if (text.includes('RUNTIME BLOCKED')) {
     return 'reuse current candidates';

package/src/chat/turn-typeahead.ts

@@ -19,6 +19,10 @@ export interface TurnTypeaheadState {
    * «짝지어» 떨어낸다 — 위치·문자열로 짝지으면 같은 발화가 두 번 들어간다(10-14 중복 수리).
    */
   queuedPendingIds?: (string | null)[];
+  /** «지금 밀어 넣기»가 «다음 도구 경계 최우선»으로 떨어졌다(도는 도구가 취소 불가). 큐가 비거나 턴이 끝나면 지운다. */
+  steerPriority?: boolean;
+  /** 이번 턴에 도구 경계로 들어간 수 — 큐가 비었을 때 «✓ 넣음» 줄로 보인다. 턴이 끝나면 지운다. */
+  injectedCount?: number;
 }
 
 /** 큐 길이에 맞춘 id 짝(모자라면 null 로 채운다). 순수. */
@@ -89,16 +93,31 @@ export type TurnTypeaheadKeyResult = {
   submissionDisposition?: 'immediate' | 'fifo';
   /** 큐에서 «다른 길»로 빠진 항목의 레지스트리 id — 호출측이 레지스트리에서도 떨어낸다(되꺼내기). */
   releasedPendingIds?: string[];
+  /** 빈 입력에서 Enter(대기 항목이 있을 때) = «지금 밀어 넣기» 요청. 판정·실행은 호출측의 책임이다. */
+  pushNowRequested?: boolean;
 };
 
 /** 등록소 소유의 관측용 표시 조회. 이름·문법·실행 정책은 이 순수 판정기에 두지 않는다. */
 export type TurnTypeaheadImmediateSubmissionLookup = (text: string) => boolean;
 
+/** 줄바꿈 키 — Shift+Enter · Alt+Enter · Ctrl+J(`input-control-key.ts` 와 같은 꼴). */
+export function isTypeaheadNewlineKey(key: { name: string; ctrl?: boolean; alt?: boolean; shift?: boolean; meta?: boolean }): boolean {
+  if (key.name === 'enter') return !key.ctrl && !key.meta && (!!key.shift || !!key.alt);
+  return key.name === 'j' && !!key.ctrl && !key.alt && !key.shift && !key.meta;
+}
+
+/** 에코·큐 행은 한 줄로 그린다 — 버퍼 속 줄바꿈은 `↵` 로 보여 준다(행을 깨지 않는다). */
+function oneLine(text: string): string {
+  return text.replace(/\n/g, '↵');
+}
+
 /** 스트리밍 중 키 1개 판정(순수). mouse/비-press/수정키는 소유하지 않는다.
  *  - printable → buffer 누적
  *  - backspace → 마지막 코드포인트 제거(빈 버퍼면 미소유 — 기존 semantics 보존)
+ *  - shift/alt+enter · ctrl+j → buffer 에 줄바꿈(빈 buffer 면 소유만)
  *  - enter → 비어 있지 않은 buffer를 FIFO 제출 큐에 넣고 다음 문장을 위한 buffer를 비운다
- *  - ctrl+up → 마지막 제출 큐 항목을 buffer 끝으로 되꺼낸다
+ *  - 빈 buffer 에서 enter(대기 항목이 있을 때) → «지금 밀어 넣기» 요청(`pushNowRequested`)
+ *  - ctrl+up → 대기 항목 «전부»를 입력 순서대로 buffer 앞으로 되꺼낸다(편집 가능한 것만 이 큐에 든다)
  *  - escape 등 나머지 → 미소유(턴 중단 등 기존 경로 그대로) */
 export function applyTurnTypeaheadKey(
   state: TurnTypeaheadState,
@@ -117,8 +136,20 @@ export function applyTurnTypeaheadKey(
     return { state: { ...state, buffer: cps.join('') }, consumed: true, changed: true };
   }
 
-  if (key.name === 'enter' && !key.ctrl && !key.alt) {
-    if (!state.buffer.trim()) return { state, consumed: false, changed: false };
+  // ⭐ 턴 중에도 Shift+Enter(⊕ Alt+Enter · Ctrl+J)는 «줄바꿈»이다 — 유휴 입력창과 같은 계약.
+  //    종전엔 수식자를 안 보고 «제출»(FIFO 대기)로 떨어져, 도는 턴 위에 쓰던 여러 줄이 반토막으로 나갔다.
+  //    빈 버퍼의 줄바꿈은 소유만 하고 버퍼는 안 바꾼다(맨 앞 빈 줄을 만들지 않는다).
+  if (isTypeaheadNewlineKey(key)) {
+    if (!state.buffer) return { state, consumed: true, changed: false };
+    return { state: { ...state, buffer: `${state.buffer}\n` }, consumed: true, changed: true };
+  }
+
+  if (key.name === 'enter' && !key.ctrl && !key.alt && !key.shift) {
+    if (!state.buffer.trim()) {
+      // ⭐ 「한 번 더 Enter = 지금」 — 큐가 비면 옛 계약 그대로 소유하지 않는다.
+      if (state.queuedSubmissions.length === 0) return { state, consumed: false, changed: false };
+      return { state, consumed: true, changed: false, pushNowRequested: true };
+    }
     try {
       if (state.buffer.startsWith('/') && isImmediateSubmission?.(state.buffer)) {
         return {
@@ -147,18 +178,16 @@ export function applyTurnTypeaheadKey(
   // ⛔ 정확한 조합만 소유한다 — 수식자를 덜 보면 `ctrl+shift+up` 같은 조합까지 삼켜
   //    다른 층이 쓸 키를 조용히 먹는다.
   if (key.name === 'up' && key.ctrl && !key.alt && !key.shift && !key.meta) {
-    const recalled = state.queuedSubmissions.at(-1);
-    if (recalled === undefined) return { state, consumed: false, changed: false };
-    const ids = turnTypeaheadPendingIds(state);
+    if (state.queuedSubmissions.length === 0) return { state, consumed: false, changed: false };
+    // ⭐ 전부 꺼낸다(Claude Code 동형) — 한 건씩이면 여러 건을 고칠 때 순서가 뒤집힌다.
+    //   입력 순서를 지키고, 치던 초안은 맨 뒤에 둔다.
+    const recalled = [...state.queuedSubmissions, ...(state.buffer ? [state.buffer] : [])].join('\n');
+    const released = presentIds(turnTypeaheadPendingIds(state));
     return {
-      state: {
-        buffer: state.buffer + recalled,
-        queuedSubmissions: state.queuedSubmissions.slice(0, -1),
-        ...idsField(ids.slice(0, -1)),
-      },
+      state: { ...withoutIds(state), buffer: recalled, queuedSubmissions: [], steerPriority: undefined },
       consumed: true,
       changed: true,
-      ...(ids.at(-1) ? { releasedPendingIds: presentIds(ids.slice(-1)) } : {}),
+      ...(released.length > 0 ? { releasedPendingIds: released } : {}),
     };
   }
 
@@ -203,6 +232,18 @@ export function dequeueTurnTypeaheadHandoff(
   return { handoff: { kind: 'prefill', text: state.buffer }, state: createTurnTypeaheadState() };
 }
 
+/** 턴 범위 표시(최우선·넣음 수)를 지운다 — 다음 턴으로 넘기지 않는다. 순수. */
+function clearTurnScopedMarks(state: TurnTypeaheadState): TurnTypeaheadState {
+  if (state.steerPriority === undefined && state.injectedCount === undefined) return state;
+  const { steerPriority: _p, injectedCount: _n, ...rest } = state;
+  return rest;
+}
+
+/** «지금 밀어 넣기»가 다음 경계 최우선으로 떨어졌음을 적는다. 레지스트리에 든 항목이 없으면 그대로. 순수. */
+export function markTurnTypeaheadPriority(state: TurnTypeaheadState): TurnTypeaheadState {
+  return presentIds(turnTypeaheadPendingIds(state)).length > 0 ? { ...state, steerPriority: true } : state;
+}
+
 /** ⭐ 턴 종료 드레인 **한 걸음** — `src/dashboard/index.ts` 의 inner-loop 가 반복마다 이걸 부른다.
  *  ⛔ 종전엔 그 순서(dequeue → state 교체 → nextInitial 누적 → submit 이면 enter 주입)가
  *     `index.ts` 안에만 있어서, 테스트가 그 순서를 **베껴 모사**할 수밖에 없었다. 베낀 테스트는
@@ -223,6 +264,7 @@ export function drainTurnTypeaheadOnce(
    */
   releasedPendingIds: string[];
 } {
+  state = clearTurnScopedMarks(state);
   if (opts?.interrupted && state.queuedSubmissions.length > 0) {
     const restored = [...state.queuedSubmissions, ...(state.buffer ? [state.buffer] : [])].join('\n');
     return {
@@ -308,6 +350,8 @@ export function drainedIntoTurn(
     };
   }
   if (matched.length === 0) return { state: next, sentence: null, matched };
+  next = { ...next, injectedCount: (next.injectedCount ?? 0) + matched.length };
+  if (presentIds(turnTypeaheadPendingIds(next)).length === 0) delete next.steerPriority;
   const count = matched.length;
   const label = count === 1 ? '⏳ 턴 안 1건' : `⏳ 턴 안 ${count}건`;
   const quoted = matched.map(text => `"${text}"`).join(' · ');
@@ -333,8 +377,9 @@ export function renderTurnTypeaheadEcho(
   const count = state.queuedSubmissions.length;
   const suffix = opts?.includeQueueSuffix && count > 0 ? `  ⏎ ${count}건 대기 · 턴 종료 시 전송` : '';
   const budget = Math.max(8, width - 2 - [...suffix].length);
-  const cps = [...state.buffer];
-  const shown = cps.length > budget ? cps.slice(cps.length - budget).join('') : state.buffer;
+  const buffer = oneLine(state.buffer);
+  const cps = [...buffer];
+  const shown = cps.length > budget ? cps.slice(cps.length - budget).join('') : buffer;
   return `${shown}${suffix}`;
 }
 
@@ -351,13 +396,23 @@ export function renderTurnTypeaheadQueueRow(
   width: number,
 ): string | null {
   const count = state.queuedSubmissions.length;
-  if (count === 0) return null;
-  const head = state.queuedSubmissions[0] ?? '';
-  const label = count === 1 ? '⏳ 대기 1건' : `⏳ 대기 ${count}건`;
-  // 되꺼내기 키를 화면에 적는다 — 안내가 없어 대기 발화를 취소·수정할 길을 몰랐다(2026-09-26 베어 VM 실측 · UX 12).
-  const tail = ' · 턴 종료 시 전송 · Ctrl+↑ 되꺼내기';
+  if (count === 0) {
+    // ✓ 넣음 — 도구 경계로 들어간 뒤 큐가 비었다(턴이 끝나면 지워진다).
+    const injected = state.injectedCount ?? 0;
+    return injected > 0 ? `✓ 넣음 ${injected}건 · 도는 턴에 이어서 반영` : null;
+  }
+  const head = oneLine(state.queuedSubmissions[0] ?? '');
+  // ⭐ 항목 상태를 보인다 — 레지스트리에 든 것은 다음 도구 경계에, 안 든 것(슬래시·세션 없음)은 응답 뒤에 나간다.
+  const steerable = presentIds(turnTypeaheadPendingIds(state)).length;
+  const waiting = count - steerable;
+  const parts: string[] = [];
+  if (steerable > 0) parts.push(`${state.steerPriority ? '⚡ 최우선 · 다음 도구 경계에 넣음' : '↳ 다음 도구 경계에 넣음'} ${steerable}건`);
+  if (waiting > 0) parts.push(`⏳ 대기(응답 뒤) ${waiting}건`);
+  const label = parts.join(' · ');
+  // 되꺼내기·밀어 넣기 키를 화면에 적는다 — 안내가 없어 대기 발화를 취소·수정할 길을 몰랐다(2026-09-26 베어 VM 실측 · UX 12).
+  const tail = ' · Ctrl+↑ 되꺼내기 · 빈 Enter 지금 밀어 넣기';
   const budget = Math.max(8, width - [...label].length - [...tail].length - 5);
   const cps = [...head];
-  const shown = cps.length > budget ? `${cps.slice(0, budget).join('')}…` : head;
+  const shown = cps.length > budget ? `${cps.slice(0, budget).join('')}…` : cps.join('');
   return `${label} · "${shown}"${tail}`;
 }

package/src/cli/__fixtures__/agent-help-before/agent.txt

@@ -8,8 +8,10 @@ Arguments:
   text                                            Prompt text for the single-turn agent.
 
 Options:
-  --new                                           Force a new session instead of using the active one
-  --session <id>                                  Continue an explicit session (id or unique prefix). Overrides --new and active session.
+  --new                                           Start a new session (the default since 0.2.31 — kept for compatibility)
+  --continue                                      Continue the active session instead of starting a new one
+  --resume [id]                                   Continue a session: the given id (or unique prefix), or the active session when no id is given. A word after --resume that is not session-id shaped (hex uuid) is read as the prompt, not the id.
+  --session <id>                                  Continue an explicit session (id or unique prefix). Overrides --new, --continue and --resume.
   --json                                          Emit a single JSON line {sessionId, provider, model, reply, logPath, budget} instead of streaming text + ui.info trailer. Stable shape for LLM self-spawn.
   --no-tools                                      Disable the tool loop and fall back to text-only chat (for benchmarking / parity with `chat`).
   -h, --help                                      display help for command

package/src/cli/agent-cli.ts

@@ -5,7 +5,8 @@ import { handleOnboardingRefusal, needsOnboarding, runOnboarding } from '../onbo
 import { runTurn, ensureCliSession, sessionBudget } from '../session/chat.js';
 import { suggestProjectForFolder } from '../project/project-store.js';
 import { NoLlmProviderAvailableError, noProviderAvailableMessage } from '../llm.js';
-import { resolveSessionId, getActiveSessionId, setActiveSessionId } from '../session/index.js';
+import { resolveSessionId, getActiveSessionId, setActiveSessionId, loadSession, listSessions } from '../session/index.js';
+import { decideSessionStart, observeSessionStart, splitResumeArgument } from '../session/session-start.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
 import { encodeDetachedProgressFrame } from '../harness/dispatch-detached.js';
 import type { FeedbackEnvelope } from '../feedback/envelope.js';
@@ -65,12 +66,18 @@ export function registerAgentCommands(program: Command): void {
   .command('agent')
   .argument('[text...]', 'Prompt text for the single-turn agent.')
   .description('Single-turn agent — same as `chat` but with the tool loop on by default (Read/Grep/Glob/ListDir/Edit/Write + Bash). Use this when the LLM needs to inspect files / run commands / debug itself.')
-  .option('--new', 'Force a new session instead of using the active one')
-  .option('--session <id>', 'Continue an explicit session (id or unique prefix). Overrides --new and active session.')
+  .option('--new', 'Start a new session (the default since 0.2.31 — kept for compatibility)')
+  .option('--continue', 'Continue the active session instead of starting a new one')
+  .option('--resume [id]', 'Continue a session: the given id (or unique prefix), or the active session when no id is given. A word after --resume that is not session-id shaped (hex uuid) is read as the prompt, not the id.')
+  .option('--session <id>', 'Continue an explicit session (id or unique prefix). Overrides --new, --continue and --resume.')
   .option('--json', 'Emit a single JSON line {sessionId, provider, model, reply, logPath, budget} instead of streaming text + ui.info trailer. Stable shape for LLM self-spawn.')
   .option('--no-tools', 'Disable the tool loop and fall back to text-only chat (for benchmarking / parity with `chat`).')
-  .action(async (parts: string[], opts: { new?: boolean; session?: string; json?: boolean; tools?: boolean }) => {
-    if (!parts || parts.length === 0) {
+  .action(async (rawParts: string[], opts: { new?: boolean; continue?: boolean; resume?: string | boolean; session?: string; json?: boolean; tools?: boolean }) => {
+    // TUI-H8-FOLLOW ② — `agent --resume "질문"` 에서 Commander 가 질문 첫 낱말을 세션 id 로 먹지 않게.
+    const split = splitResumeArgument(opts.resume, rawParts ?? [], 'agent', process.argv.slice(2));
+    opts.resume = split.resume;
+    const parts = split.parts;
+    if (parts.length === 0) {
       console.error("error: missing required argument 'text'");
       process.exit(1);
     }
@@ -105,10 +112,12 @@ export function registerAgentCommands(program: Command): void {
     await runChatTurnCli({
       cfg: refreshed,
       userText: parts.join(' '),
-      explicitSessionId: opts.session,
-      reuseActive: opts.new !== true,
+      explicitSessionId: opts.session ?? (typeof opts.resume === 'string' ? opts.resume : undefined),
+      // 대표 #73 — 인자 없음 = 새 세션. 이어하기는 `--continue`/`--resume` 명시일 때만.
+      reuseActive: opts.continue === true || opts.resume === true,
       forceNew: opts.new === true,
       json: opts.json === true,
+      surface: 'agent',
       // commander stores --no-tools as `tools: false`, plain absence as undefined → default true here.
       enableTools: opts.tools !== false,
     });
@@ -385,11 +394,13 @@ tierCmd
 
 /** Single-turn CLI driver shared by `elanous ask` and `elanous chat`.
  *
- *  Resolution order for sessionId:
- *    1. opts.explicitSessionId (`--session`)  — wins, validates against
+ *  Resolution order for sessionId (`decideSessionStart` · 대표 #73 기본 = 새 세션):
+ *    1. opts.explicitSessionId (`--session`/`--resume <id>`) — wins, validates against
  *       resolveSessionId so a 6-char prefix works
- *    2. active session                         — when reuseActive
- *    3. fresh session                          — otherwise
+ *    2. fresh session                          — when forceNew
+ *    3. active session                         — only when reuseActive (`--continue`/`--resume`)
+ *    4. fresh session                          — otherwise (the default)
+ *  Every decision emits `session`/`start` {surface, origin, reason}.
  *
  *  When `json` is true, the function suppresses the streaming text +
  *  ui.info trailer and instead emits exactly ONE JSON line on stdout
@@ -402,9 +413,12 @@ export async function runChatTurnCli(opts: {
   cfg: ReturnType<typeof reloadUserConfig>;
   userText: string;
   explicitSessionId: string | undefined;
+  /** 활성 세션 이어하기를 «명시로» 요청했나(`--continue`/`--resume`). 기본 false = 새 세션. */
   reuseActive: boolean;
   forceNew: boolean;
   json: boolean;
+  /** 관측용 표면 이름(`session`/`start`). 기본 'chat'. */
+  surface?: 'chat' | 'agent' | 'ask';
   /** When true, build a CORE-native + Bash tool catalog and route
    *  through streamLLMWithTools so the LLM can drive multi-turn
    *  exploration (file reads, grep, shell). Default false — CLI
@@ -429,11 +443,25 @@ export async function runChatTurnCli(opts: {
       process.exit(1);
     }
     resolvedSessionIdHint = id;
-  } else if (opts.reuseActive && !opts.forceNew) {
-    resolvedSessionIdHint = getActiveSessionId() ?? undefined;
   }
+  const startDecision = decideSessionStart({
+    ...(resolvedSessionIdHint ? { explicitSessionId: resolvedSessionIdHint } : {}),
+    continueActive: opts.reuseActive,
+    forceNew: opts.forceNew,
+    activeSessionId: () => getActiveSessionId(),
+    // TUI-H8-FOLLOW ① — 활성 표지가 사라진 세션이면 최신 세션으로.
+    sessionExists: (id) => loadSession(id) !== null,
+    latestSessionId: () => listSessions({ limit: 1 })[0]?.id ?? null,
+  });
+  resolvedSessionIdHint = startDecision.sessionIdHint;
   const session = ensureCliSession(opts.cfg, resolvedSessionIdHint);
   setActiveSessionId(session.id);
+  observeSessionStart({
+    surface: opts.surface ?? 'chat',
+    origin: resolvedSessionIdHint && session.id === resolvedSessionIdHint ? startDecision.origin : 'new',
+    reason: resolvedSessionIdHint && session.id !== resolvedSessionIdHint ? 'resume-target-missing' : startDecision.reason,
+    sessionId: session.id,
+  });
   if (!opts.json && (!resolvedSessionIdHint || session.id !== resolvedSessionIdHint)) {
     try {
       const project = suggestProjectForFolder(process.cwd());

package/src/cli/ask-bare.ts

@@ -37,6 +37,7 @@ export async function askBare({ text, provider, model, deps }: {
     ...(provider === undefined ? { initialProvider: chosenProvider } : { provider: chosenProvider }),
     ...(selected.model === '(none)' ? {} : { model: selected.model }),
     onResolvedProvider: (name, activeModel) => { resolvedProvider = name; resolvedModel = activeModel; },
+    usageSite: 'cli.ask-bare',
   });
   return { provider: resolvedProvider, model: resolvedModel, reply };
 }

package/src/cli/config-audit.ts

@@ -0,0 +1,123 @@
+// ── CFG-STORE2 · config 감사 이력 첫 칸 (0.2.29 · 2026-10-14) ──
+//
+// RFC-universe-by-house-not-tree-and-config-store-2026-10-06 §2 — 겹 저장소의 첫 칸은 «감사 이력».
+// CFG-STORE1(config-drift.ts · 읽기 전용 드리프트) 위에 «쓰기» 축 하나를 더한다:
+// `config set` · `config unset` 이 저장에 성공하면 바꾼 키·이전 값·다음 값·by·why 를 한 행으로 남긴다.
+//
+// ⛔ 불변식
+//   • 비밀은 «저장 전에» 가린다 — config-drift.ts 의 가림 원형(isSecretPath·isSecretValue·MASK·maskDeep)을
+//     그대로 재사용한다: 비밀 경로(마디 하나라도 token/secret/key/…) ⊕ 비밀 모양 값(웹훅·토큰 접두·URL userinfo)
+//     ⊕ 객체 속 비밀 키(botToken 같은 자리) → '<masked>'. config-drift.ts 는 손대지 않는다(읽기 전용 그대로).
+//   • 감사 기록은 명령의 부속이다 — 호출부(src/index.ts config set/unset)가 fail-open 으로 감싼다(실패해도 경고만).
+//   • by 는 자리(ELANOUS_TRACK) ⊕ 런 id 환경 변수에서 푼다 — 명시 by > ELANOUS_TRACK > 런 id > 'cli'.
+//   • 읽기(readConfigHistory)는 없는 db 파일을 만들지 않는다.
+
+import { Database } from 'bun:sqlite';
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { isSecretPath, isSecretValue, maskDeep, MASK } from './config-drift.js';
+
+// CFG-STORE1 가림 자(MASK) — 테스트 계약(config-audit.test.ts)이 이 경로로 소비한다.
+export { MASK };
+
+/** 한 번의 config 변경 — prev/next 는 저장 «전» 값과 저장 «후» 값(undefined = 그 자리에 키가 없다). */
+export interface ConfigChange {
+  key: string;
+  prev?: unknown;
+  next?: unknown;
+  by?: string;
+  why?: string;
+}
+
+/** config_changes 표의 한 행 — prev/next 는 가려 직렬화한 값(null = 그 자리에 값이 없었다). */
+export interface ConfigChangeRow {
+  at: string;
+  key: string;
+  prev: string | null;
+  next: string | null;
+  by: string;
+  why: string | null;
+}
+
+/** 감사 db 기본 자리 — 활성 config 뿌리(~/.elanous · --config-dir 격리 존중) 바로 옆 config-changes.db. */
+function configAuditDbPath(dbPath?: string): string {
+  return dbPath ?? join(getElanousConfigDir(), 'config-changes.db');
+}
+
+/** by 해석 — 명시 by > 자리(ELANOUS_TRACK) > 런 id 환경 변수 > 'cli'. */
+function resolveConfigChangeBy(by?: string): string {
+  const explicit = by?.trim();
+  if (explicit) return explicit;
+  const track = process.env.ELANOUS_TRACK?.trim();
+  if (track) return track;
+  for (const name of ['ELANOUS_RUN_ID', 'HARNESS_RUN_ID', 'RUN_ID']) {
+    const runId = process.env[name]?.trim();
+    if (runId) return runId;
+  }
+  return 'cli';
+}
+
+/** 저장용 값 — undefined → SQL NULL · 비밀(경로 마디 ⊕ 값 모양) → MASK · 나머지는 maskDeep 후 JSON 직렬화. */
+function serializeConfigValue(key: string, value: unknown): string | null {
+  if (value === undefined) return null;
+  if (isSecretPath(key) || isSecretValue(value)) return MASK;
+  return JSON.stringify(maskDeep(value)) ?? 'null';
+}
+
+// Anonymous SQLite memory databases are private to each connection. Keep one
+// connection for this process so record/read share the same audit history.
+// File-backed stores keep their existing open/close-per-call lifetime.
+let memoryDb: Database | undefined;
+
+function openConfigChangesDb(dbPath: string): Database {
+  if (dbPath !== ':memory:') mkdirSync(dirname(dbPath), { recursive: true });
+  const db = dbPath === ':memory:'
+    ? (memoryDb ??= new Database(':memory:'))
+    : new Database(dbPath);
+  db.exec(`CREATE TABLE IF NOT EXISTS config_changes (
+    at  TEXT NOT NULL,
+    key TEXT NOT NULL,
+    prev TEXT,
+    next TEXT,
+    by  TEXT NOT NULL,
+    why TEXT
+  )`);
+  db.exec('CREATE INDEX IF NOT EXISTS config_changes_key_at ON config_changes(key, at)');
+  return db;
+}
+
+/** 한 번의 config 변경을 감사 이력에 «한 행»으로 남긴다. 비밀 값은 가려 쓴다. */
+export function recordConfigChange(change: ConfigChange, dbPath?: string): ConfigChangeRow {
+  const path = configAuditDbPath(dbPath);
+  const db = openConfigChangesDb(path);
+  try {
+    const row: ConfigChangeRow = {
+      at: new Date().toISOString(),
+      key: change.key,
+      prev: serializeConfigValue(change.key, change.prev),
+      next: serializeConfigValue(change.key, change.next),
+      by: resolveConfigChangeBy(change.by),
+      why: change.why?.trim() ? change.why.trim() : null,
+    };
+    db.run(
+      'INSERT INTO config_changes (at, key, prev, next, by, why) VALUES (?, ?, ?, ?, ?, ?)',
+      [row.at, row.key, row.prev, row.next, row.by, row.why],
+    );
+    return row;
+  } finally {
+    if (path !== ':memory:') db.close();
+  }
+}
+
+/** 한 키의 감사 이력 — 시간 오름차순. db 파일이 없으면 빈 배열(읽기가 파일을 만들지 않는다). */
+export function readConfigHistory(key: string, dbPath?: string): ConfigChangeRow[] {
+  const path = configAuditDbPath(dbPath);
+  if (path !== ':memory:' && !existsSync(path)) return [];
+  const db = path === ':memory:' ? openConfigChangesDb(path) : new Database(path, { readonly: true });
+  try {
+    return db.query('SELECT at, key, prev, next, by, why FROM config_changes WHERE key = ? ORDER BY at ASC, rowid ASC').all(key) as ConfigChangeRow[];
+  } finally {
+    if (path !== ':memory:') db.close();
+  }
+}

package/src/cli/decisions-cli.ts

@@ -11,6 +11,7 @@ import { getUserConfig } from '../user-config.js';
 import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry, type Seat, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { formatProactMeter, readProactMeter } from '../decisions/proact-meter.js';
+import { CROWN_MARK, CROWN_THRESHOLD_CATEGORIES, CONSENSUS_CATEGORIES, ConsensusEngine, MAX_REVIEW_ROUND_TRIPS, categoryLabel, representativeLabel, type ConsensusCategory, type ConsensusRepresentative, type CrownCard, type ProposalCard } from '../loops/consensus.js';
 import { writeStdoutFully } from './stdout-flush.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
@@ -62,6 +63,14 @@ export function formatSeatDecisionRow(e: SeatDecisionRecord): string {
   return `${e.id} · 결정: ${e.decidedAt ? kst(e.decidedAt) : '시각 미상'} · 기록: ${e.recordedAt ? kst(e.recordedAt) : '시각 미상'} · ${e.seat} 결정 · 사후 보고 · ${e.title} → ${e.decision} · 위임: ${e.delegation}${e.refs?.length ? ` · 참조: ${e.refs.join(' · ')}` : ''}`;
 }
 
+export function formatProposalRow(p: ProposalCard): string {
+  return `${p.id} · ${categoryLabel(p.category)} · ${p.title} · 사실 ${p.factId} · 비용 ${p.cost} · 되돌리기 ${p.undo}${p.thresholds.length ? ` · ${CROWN_MARK} 몫 ${p.thresholds.join('|')}` : ''} · 제안 ${representativeLabel(p.proposedBy)} · ${kst(p.proposedAt)} · 왕복 ${p.roundTrips}/${MAX_REVIEW_ROUND_TRIPS} · ${p.status === 'open' ? '검토 중' : p.status === 'agreed' ? '합의·실행·기록' : '불합의'}`;
+}
+
+export function formatCrownCardRow(c: CrownCard): string {
+  return `${c.id} · ${CROWN_MARK} ${c.reason === 'disagreement' ? '불합의' : '임계 승인'} · 제안 ${c.proposalId} · 조율자 주장: ${c.coordinatorClaim} | 수호자 주장: ${c.guardianClaim}${c.decisionId ? ` · 결정 카드 ${c.decisionId}` : ''}`;
+}
+
 export function registerDecisionsCommands(program: Command, config: DecisionLedgerOptions = {}, out: Pick<Console, 'log'> = console, hqDeps: HqDeps = {}): void {
   const noXcheck = new Option('--no-xcheck <이유>', '교차 확인 생략 이유');
   // This flag takes a reason, not Commander's negated boolean default.
@@ -176,14 +185,24 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (!o.auto && (o.delegation || o.track || o.agent)) throw new Error('delegation/track/agent require --auto');
       const by = o.auto ? { kind: 'auto' as const, agent: agent(o.agent), delegation: o.delegation!, ...(o.track ? { track: o.track } : {}) } : { kind: 'human' as const };
       if (!mayWrite('decide', o.hqOverride)) return;
-      const { entry, delivery } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
-      if (delivery && !delivery.ok) {
-        // The decision is recorded; only the answer to the waiting run failed — say so and how to retry, never «success».
-        const hint = `⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`;
+      const { entry, delivery, notice } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
+      const failures = [
+        ...(delivery && !delivery.ok ? [`⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`] : []),
+        ...(notice.status === 'failed' ? [`⚠ 자리 우편 실패(${notice.seat} · ${notice.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-notify ${entry.id}`] : []),
+      ];
+      if (failures.length) {
         process.exitCode = 3;
-        return emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
+        return emit({ ...entry, ...(delivery ? { delivery } : {}), notice }, o.json, `결정: ${formatDecisionDetail(entry)}\n${failures.join('\n')}`);
       }
-      return emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+      const sent = notice.status === 'sent' ? `\n자리 우편: ${notice.seat} #${notice.messageId}` : '';
+      return emit({ ...entry, ...(delivery ? { delivery } : {}), notice }, o.json, `결정: ${formatDecisionDetail(entry)}${sent}`);
+    }));
+  root.command('retry-notify <id>').description('기록된 결정의 올린 자리 우편만 중복 없이 재시도한다').option('--json').option('--hq-override')
+    .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('retry-notify', o.hqOverride)) return;
+      const notice = new DecisionLedger(config).retryNotice(id);
+      if (notice.status === 'failed') process.exitCode = 3;
+      return emit(notice, o.json, notice.status === 'sent' ? `자리 우편: ${notice.seat} #${notice.messageId}` : notice.status === 'skipped' ? '올린 자리 없음 — 우편 대상 없음' : `⚠ 자리 우편 실패(${notice.seat} · ${notice.reason})`);
     }));
   root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json').option('--hq-override')
     .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
@@ -209,4 +228,59 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (result.unread.length) process.exitCode = 1;
       return emit(result, o.json, `가져옴 ${result.imported.length} · 기존 ${result.existing.length} · 불완전 ${result.incomplete.length} · 못 읽음 ${result.unread.length}${result.incomplete.length ? `\n${result.incomplete.join('\n')}` : ''}${result.unread.length ? `\n${result.unread.join('\n')}` : ''}`);
     }));
+  const consensusRoot = root.command('consensus').description('두 대표 합의 — 조율자(일의 흐름)·수호자(몸)의 다섯 범주는 «둘의 합의» 뒤에 실행');
+  const consensusEngine = () => new ConsensusEngine({ stateDir: config.stateDir, now: config.now, resolveVersion: config.resolveVersion });
+  consensusRoot.command('propose').description('제안 카드를 올린다 — 사실 id·비용·되돌리기')
+    .requiredOption('--by <representative>', '제안 대표 (coordinator|guardian)')
+    .requiredOption('--category <category>', `합의 범주 (${CONSENSUS_CATEGORIES.join('|')})`)
+    .requiredOption('--title <text>').requiredOption('--fact-id <id>', '사실 id')
+    .requiredOption('--cost <text>', '비용').requiredOption('--undo <text>', '되돌리기')
+    .option('--threshold <category>', `${CROWN_MARK} 몫 임계 범주 (반복: ${CROWN_THRESHOLD_CATEGORIES.join('|')})`, repeat, [])
+    .option('--provider <name>', 'LLM 제공자 표식 — 가능하면 상대와 다른 제공자 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((o: { by: string; category: string; title: string; factId: string; cost: string; undo: string; threshold: string[]; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus propose', o.hqOverride)) return;
+      const proposal = consensusEngine().propose({
+        by: o.by as ConsensusRepresentative, category: o.category as ConsensusCategory, title: o.title, factId: o.factId, cost: o.cost, undo: o.undo,
+        thresholds: o.threshold.map(threshold => threshold as DecisionCategory), provider: o.provider,
+      });
+      return emit(proposal, o.json, `제안: ${formatProposalRow(proposal)}`);
+    }));
+  consensusRoot.command('review <id>').description('상대 검토 왕복을 남긴다 — 최대 2왕복, 마지막 왕복은 결론으로')
+    .requiredOption('--by <representative>', '검토 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .requiredOption('--claim <text>', '검토 주장')
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus review', o.hqOverride)) return;
+      const proposal = consensusEngine().review(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit(proposal, o.json, `검토 ${proposal.roundTrips}/${MAX_REVIEW_ROUND_TRIPS}왕복: ${formatProposalRow(proposal)}`);
+    }));
+  consensusRoot.command('agree <id>').description(`상대 대표의 합의 — 실행·합의 원장 기록 (임계 범주면 ${CROWN_MARK} 카드도 함께)`)
+    .requiredOption('--by <representative>', '합의 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .option('--claim <text>', '합의 주장 (생략 시 제안대로 실행)')
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim?: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus agree', o.hqOverride)) return;
+      const { proposal, crownCard } = consensusEngine().agree(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit({ proposal, ...(crownCard ? { crownCard } : {}) }, o.json,
+        `합의: ${formatProposalRow(proposal)}${crownCard ? `\n${CROWN_MARK} 카드: ${formatCrownCardRow(crownCard)}` : ''}`);
+    }));
+  consensusRoot.command('disagree <id>').description(`상대 대표의 불합의 — 양쪽 주장 나란히 ${CROWN_MARK} 결정 카드`)
+    .requiredOption('--by <representative>', '불합의 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .requiredOption('--claim <text>', `불합의 주장 — ${CROWN_MARK} 카드에 나란히 실린다`)
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus disagree', o.hqOverride)) return;
+      const { proposal, crownCard } = consensusEngine().disagree(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit({ proposal, crownCard }, o.json, `불합의: ${formatProposalRow(proposal)}\n${CROWN_MARK} 카드: ${formatCrownCardRow(crownCard)}`);
+    }));
+  consensusRoot.command('crown').description(`${CROWN_MARK} 결정 카드 목록 — 불합의·임계 범주만 만든다`)
+    .option('--json')
+    .action((o: { json?: boolean }) => fail(() => {
+      const cards = consensusEngine().crownCards();
+      return emit(cards, o.json, cards.length ? cards.map(formatCrownCardRow).join('\n') : `${CROWN_MARK} 결정 카드 0건`);
+    }));
 }