elanous 0.2.28 → 0.2.31

package/src/chat/turn-typeahead.ts

@@ -13,6 +13,59 @@ export interface TurnTypeaheadState {
   buffer: string;
   /** Enter 한 입력들. 턴 종료 뒤 입력 순서대로 자동 제출한다. */
   queuedSubmissions: string[];
+  /**
+   * `queuedSubmissions` 와 같은 순서의 짝 — 턴 «안» 주입 레지스트리(`session/pending-input`) 항목 id.
+   * `null`(또는 칸이 모자람) = 레지스트리에 안 넣은 항목. ⭐ 이 id 로 배수·되꺼내기·턴 종료 승격을
+   * «짝지어» 떨어낸다 — 위치·문자열로 짝지으면 같은 발화가 두 번 들어간다(10-14 중복 수리).
+   */
+  queuedPendingIds?: (string | null)[];
+  /** «지금 밀어 넣기»가 «다음 도구 경계 최우선»으로 떨어졌다(도는 도구가 취소 불가). 큐가 비거나 턴이 끝나면 지운다. */
+  steerPriority?: boolean;
+  /** 이번 턴에 도구 경계로 들어간 수 — 큐가 비었을 때 «✓ 넣음» 줄로 보인다. 턴이 끝나면 지운다. */
+  injectedCount?: number;
+}
+
+/** 큐 길이에 맞춘 id 짝(모자라면 null 로 채운다). 순수. */
+export function turnTypeaheadPendingIds(state: TurnTypeaheadState): (string | null)[] {
+  const ids = state.queuedPendingIds ?? [];
+  return state.queuedSubmissions.map((_, i) => ids[i] ?? null);
+}
+
+function presentIds(ids: readonly (string | null)[]): string[] {
+  return ids.filter((id): id is string => typeof id === 'string');
+}
+
+/** 짝이 하나도 없으면 칸을 아예 안 둔다(`undefined` 키도 없이) — 레지스트리를 안 쓰는 경로의 상태 모양을 옛 그대로 둔다. */
+function idsField(ids: readonly (string | null)[]): { queuedPendingIds?: (string | null)[] } {
+  return ids.some(id => id !== null) ? { queuedPendingIds: [...ids] } : {};
+}
+
+/** 상태에서 id 짝 칸을 뗀다 — `idsField` 와 함께 써서 옛 짝이 스프레드로 살아남지 않게 한다. */
+function withoutIds(state: TurnTypeaheadState): TurnTypeaheadState {
+  if (!('queuedPendingIds' in state)) return state;
+  const { queuedPendingIds: _ids, ...rest } = state;
+  return rest;
+}
+
+/** 큐 index 번째 항목에 레지스트리 id 를 단다. 순수. 범위 밖이면 그대로. */
+export function attachTurnTypeaheadPendingId(
+  state: TurnTypeaheadState,
+  index: number,
+  id: string,
+): TurnTypeaheadState {
+  if (index < 0 || index >= state.queuedSubmissions.length) return state;
+  const ids = turnTypeaheadPendingIds(state);
+  ids[index] = id;
+  return { ...withoutIds(state), ...idsField(ids) };
+}
+
+/**
+ * 턴 «안» 주입(steer) 대상인가. ⛔ 슬래시는 뺀다 — 명령은 턴이 끝난 뒤 FIFO 로만 실행한다
+ * (모델에 `/…` 문면이 발화로 들어가면 명령이 아니라 잡음이다 · Claude Code 도 같은 경계에서 뺀다).
+ */
+export function isTurnTypeaheadSteerable(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !trimmed.startsWith('/');
 }
 
 export function createTurnTypeaheadState(): TurnTypeaheadState {
@@ -38,16 +91,33 @@ export type TurnTypeaheadKeyResult = {
   immediateSubmission?: string;
   /** 비어 있지 않은 Enter 입력의 제출 경로 분류. */
   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,
@@ -66,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 {
@@ -82,7 +164,11 @@ export function applyTurnTypeaheadKey(
       // A registry lookup failure must preserve the typed input on the existing FIFO path.
     }
     return {
-      state: { buffer: '', queuedSubmissions: [...state.queuedSubmissions, state.buffer] },
+      state: {
+        buffer: '',
+        queuedSubmissions: [...state.queuedSubmissions, state.buffer],
+        ...idsField([...turnTypeaheadPendingIds(state), null]),
+      },
       consumed: true,
       changed: true,
       submissionDisposition: 'fifo',
@@ -92,12 +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 };
+    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) },
+      state: { ...withoutIds(state), buffer: recalled, queuedSubmissions: [], steerPriority: undefined },
       consumed: true,
       changed: true,
+      ...(released.length > 0 ? { releasedPendingIds: released } : {}),
     };
   }
 
@@ -114,13 +204,17 @@ export function restoreTurnTypeaheadSubmission(
   state: TurnTypeaheadState,
   text: string,
 ): TurnTypeaheadState {
-  return { ...state, queuedSubmissions: [...state.queuedSubmissions, text] };
+  return {
+    ...withoutIds(state),
+    queuedSubmissions: [...state.queuedSubmissions, text],
+    ...idsField([...turnTypeaheadPendingIds(state), null]),
+  };
 }
 
 export type TurnTypeaheadHandoff =
   | { kind: 'none' }
   | { kind: 'prefill'; text: string }
-  | { kind: 'submit'; text: string };
+  | { kind: 'submit'; text: string; pendingId?: string };
 
 /** 턴 종료 때 FIFO의 다음 항목 하나를 꺼낸다. 큐가 비면 미제출 buffer는 prefill한다. */
 export function dequeueTurnTypeaheadHandoff(
@@ -128,12 +222,28 @@ export function dequeueTurnTypeaheadHandoff(
 ): { handoff: TurnTypeaheadHandoff; state: TurnTypeaheadState } {
   const [next, ...queuedSubmissions] = state.queuedSubmissions;
   if (next !== undefined) {
-    return { handoff: { kind: 'submit', text: next }, state: { ...state, queuedSubmissions } };
+    const [pendingId, ...queuedPendingIds] = turnTypeaheadPendingIds(state);
+    return {
+      handoff: pendingId ? { kind: 'submit', text: next, pendingId } : { kind: 'submit', text: next },
+      state: { ...withoutIds(state), queuedSubmissions, ...idsField(queuedPendingIds) },
+    };
   }
   if (!state.buffer) return { handoff: { kind: 'none' }, state };
   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` 안에만 있어서, 테스트가 그 순서를 **베껴 모사**할 수밖에 없었다. 베낀 테스트는
@@ -143,21 +253,36 @@ export function drainTurnTypeaheadOnce(
   state: TurnTypeaheadState,
   carriedInitial: string | null | undefined,
   opts?: { interrupted?: boolean },
-): { state: TurnTypeaheadState; nextInitial: string | undefined; injectEnter: boolean } {
+): {
+  state: TurnTypeaheadState;
+  nextInitial: string | undefined;
+  injectEnter: boolean;
+  /**
+   * ⭐ 이번 걸음에 큐를 «떠난» 항목의 레지스트리 id — 호출측이 레지스트리에서도 떨어낸다.
+   *   안 떨어내면 승격된 발화(새 프롬프트)가 다음 턴 둘째 바퀴에 «또» 들어가고(턴 종료),
+   *   composer 로 돌아간 글이 고치기 전 문면으로 모델에 들어간다(중단 복원).
+   */
+  releasedPendingIds: string[];
+} {
+  state = clearTurnScopedMarks(state);
   if (opts?.interrupted && state.queuedSubmissions.length > 0) {
     const restored = [...state.queuedSubmissions, ...(state.buffer ? [state.buffer] : [])].join('\n');
     return {
       state: createTurnTypeaheadState(),
       nextInitial: carriedInitial ? `${carriedInitial}\n${restored}` : restored,
       injectEnter: false,
+      releasedPendingIds: presentIds(turnTypeaheadPendingIds(state)),
     };
   }
   const { handoff, state: remaining } = dequeueTurnTypeaheadHandoff(state);
-  if (handoff.kind === 'none') return { state: remaining, nextInitial: carriedInitial ?? undefined, injectEnter: false };
+  if (handoff.kind === 'none') {
+    return { state: remaining, nextInitial: carriedInitial ?? undefined, injectEnter: false, releasedPendingIds: [] };
+  }
   return {
     state: remaining,
     nextInitial: carriedInitial ? `${carriedInitial}${handoff.text}` : handoff.text,
     injectEnter: handoff.kind === 'submit',
+    releasedPendingIds: handoff.kind === 'submit' && handoff.pendingId ? [handoff.pendingId] : [],
   };
 }
 
@@ -177,7 +302,7 @@ export function drainTurnTypeaheadQueue(
 ): { state: TurnTypeaheadState; drained: string[] } {
   if (state.queuedSubmissions.length === 0) return { state, drained: [] };
   return {
-    state: { ...state, queuedSubmissions: [] },
+    state: { ...withoutIds(state), queuedSubmissions: [] },
     drained: [...state.queuedSubmissions],
   };
 }
@@ -185,8 +310,10 @@ export function drainTurnTypeaheadQueue(
 /**
  * ★ 라이브 턴 안으로 배수된 발화의 상태 전이 + 챗로그 문장. 순수.
  *
- * 대시보드 `enqueuePendingUserInput` onDrained 가 앞에서부터
- * `slice(drained.length)` 로 떨어내는 FIFO 와 같다.
+ * `items`(레지스트리 항목 · id 포함)를 주면 ***id 가 짝지어지는 항목만*** 떨어내고 문장도 그것만 적는다.
+ *   ⛔ 앞에서부터 `slice(drained.length)` 하면 같은 버킷의 남의 항목(goal-loop 제어 메모)이나
+ *   이미 되꺼낸 항목 때문에 엉뚱한 대기 발화가 떨어진다(10-14 중복 수리).
+ * `items` 가 없으면 옛 계약(앞에서부터 떨어내기)을 지킨다.
  * 버퍼는 건드리지 않는다. 배수된 것이 없으면 문장도 없다.
  *
  * 문면은 `renderTurnTypeaheadQueueRow` 와 나란히 읽힌다:
@@ -199,15 +326,39 @@ export function drainTurnTypeaheadQueue(
 export function drainedIntoTurn(
   state: TurnTypeaheadState,
   drained: readonly string[],
-): { state: TurnTypeaheadState; sentence: string | null } {
-  if (drained.length === 0) return { state, sentence: null };
-  const remaining = state.queuedSubmissions.slice(drained.length);
-  const count = drained.length;
+  items?: readonly { id: string; text: string }[],
+): { state: TurnTypeaheadState; sentence: string | null; matched: string[] } {
+  if (drained.length === 0) return { state, sentence: null, matched: [] };
+  let next: TurnTypeaheadState;
+  let matched: string[];
+  if (items) {
+    const drainedIds = new Set(items.map(item => item.id));
+    const ids = turnTypeaheadPendingIds(state);
+    const keep = ids.map(id => id === null || !drainedIds.has(id));
+    matched = state.queuedSubmissions.filter((_, i) => !keep[i]);
+    next = {
+      ...withoutIds(state),
+      queuedSubmissions: state.queuedSubmissions.filter((_, i) => keep[i]),
+      ...idsField(ids.filter((_, i) => keep[i])),
+    };
+  } else {
+    matched = [...drained];
+    next = {
+      ...withoutIds(state),
+      queuedSubmissions: state.queuedSubmissions.slice(drained.length),
+      ...idsField(turnTypeaheadPendingIds(state).slice(drained.length)),
+    };
+  }
+  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 = drained.map(text => `"${text}"`).join(' · ');
+  const quoted = matched.map(text => `"${text}"`).join(' · ');
   return {
-    state: { ...state, queuedSubmissions: remaining },
+    state: next,
     sentence: `${label} · ${quoted} · 라이브 턴으로 전송`,
+    matched,
   };
 }
 
@@ -226,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}`;
 }
 
@@ -244,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/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/dashboard-name-flag.ts

@@ -0,0 +1,48 @@
+// `elanous --name <name>` — 맨 `elanous`(대시보드 TUI)가 자기 PTY manifest 행(`tui:<pid>`)에
+// 별명을 달고 뜬다. 그러면 `elanous pty list` 에 그 이름이 보이고 `pty snapshot <name>` ·
+// `pty text <name> …` 가 별명으로 해석된다(ref 해석은 이미 nickname 을 받는다).
+//
+// ⭐ 루트 «실행» 플래그다 — `--resume`·`--debug` 와 같은 규칙으로 Commander «전»에 걷어낸다.
+// ⛔ 하위 명령 «뒤»의 `--name`(`elanous pty list --name x` · `elanous --debug session new --name x`)은 건드리지 않는다 — 그 명령이 `--name` 을
+//    자기 옵션으로 가질 수 있다(가로채면 조용히 그 옵션을 먹는다).
+
+import { ROOT_FLAGS_TAKING_VALUE } from './remote-resolve.js';
+
+export interface DashboardNameFlag {
+  /** 걷어낸 뒤의 인자 — Commander·대시보드 필터로 넘긴다. */
+  readonly args: string[];
+  /** 준 이름(앞뒤 공백 제거). 플래그가 없으면 undefined. */
+  readonly name?: string;
+  /** 값이 없거나 빈 이름이면 사람에게 낼 오류 문면. */
+  readonly error?: string;
+}
+
+/** 루트 «선행 플래그 구간»에서 값을 받는 플래그 — 그 값 토큰은 하위 명령이 아니다. */
+const LEADING_VALUE_FLAGS = new Set([...ROOT_FLAGS_TAKING_VALUE, '--resume']);
+
+/** 루트 선행 플래그 구간 안의 `--name` 위치. 하위 명령(맨 위치 인자)이나 `--` 를 만나면 멈춘다 —
+ *  `elanous --debug session new --name x` 의 `--name` 은 그 하위 명령의 것이다(리뷰 must-fix). */
+function leadingNameIndex(rawArgs: readonly string[]): number {
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i]!;
+    if (arg === '--' || !arg.startsWith('-')) return -1;
+    if (arg === '--name' || arg.startsWith('--name=')) return i;
+    if (LEADING_VALUE_FLAGS.has(arg)) i += 1;
+  }
+  return -1;
+}
+
+export function readDashboardNameFlag(rawArgs: readonly string[]): DashboardNameFlag {
+  const idx = leadingNameIndex(rawArgs);
+  if (idx < 0) return { args: [...rawArgs] };
+  const flag = rawArgs[idx]!;
+  const inline = flag.startsWith('--name=');
+  const value = inline ? flag.slice('--name='.length) : rawArgs[idx + 1];
+  const args = rawArgs.filter((_, i) => i !== idx && (inline || i !== idx + 1));
+  if (value === undefined || (!inline && value.startsWith('-'))) {
+    return { args: rawArgs.filter((_, i) => i !== idx), error: 'elanous: --name needs a value (e.g. elanous --name op)' };
+  }
+  const name = value.trim();
+  if (!name) return { args, error: 'elanous: --name must not be empty' };
+  return { args, name };
+}