elanous 0.2.5 → 0.2.7

package/src/chat/short-question.ts

@@ -0,0 +1,40 @@
+// 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 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' };
+}

package/src/cli/agent-cli.ts

@@ -393,8 +393,8 @@ tierCmd
  *  When `json` is true, the function suppresses the streaming text +
  *  ui.info trailer and instead emits exactly ONE JSON line on stdout
  *  at end-of-turn:
- *    {sessionId, provider, model, reply, logPath, budget, durationMs,
- *     turnIndex, ts}
+ *    {sessionId, provider, model, reply, finalReply, transcript, logPath,
+ *     budget, durationMs, ts}
  *  Stable shape so LLMs can self-spawn `elanous chat` for follow-ups
  *  without parsing human-readable terminal output. */
 export async function runChatTurnCli(opts: {
@@ -442,12 +442,14 @@ export async function runChatTurnCli(opts: {
     dbg.setAmbientSessionId?.(session.id);
   } catch { /* debug module unavailable — fine */ }
   const replyChunks: string[] = [];
-  // 어시스턴트 메시지 경계(도구 호출)로 자른 본문 조각 — 마지막 «비어 있지 않은» 조각이 finalReply.
+  // Tool calls delimit assistant messages. finalReply retains its last non-empty-message meaning.
   let segmentChunks: string[] = [];
   let lastSegment = '';
+  let finalMessage = '';
+  let sawToolCall = false;
   const closeSegment = (): void => {
-    const text = segmentChunks.join('').trim();
-    if (text) lastSegment = text;
+    finalMessage = segmentChunks.join('').trim();
+    if (finalMessage) lastSegment = finalMessage;
     segmentChunks = [];
   };
   if (!opts.json) {
@@ -528,15 +530,17 @@ export async function runChatTurnCli(opts: {
       userText: opts.userText,
       systemPrompt: agentSystemPrompt,
       onDelta: (d) => {
-        if (opts.json) { replyChunks.push(d); segmentChunks.push(d); }
-        else process.stdout.write(d);
+        replyChunks.push(d);
+        segmentChunks.push(d);
+        if (!opts.json && !opts.enableTools) process.stdout.write(d);
       },
       tools: cliToolSpecs,
       dispatchTool,
       ...(opts.goalLoop ? { goalLoop: true } : {}),
       onToolCall: (call) => {
-        // 도구 호출 뒤의 본문은 «새» 어시스턴트 메시지다 — 직전 조각을 마감한다(finalReply 용).
-        if (opts.json) closeSegment();
+        // The next delta belongs to the next assistant message.
+        sawToolCall = true;
+        closeSegment();
         if (!opts.json) {
           process.stdout.write(`\n  ⏺ ${call.name}(${truncateArgsForLog(call.args)})\n`);
         }
@@ -555,6 +559,12 @@ export async function runChatTurnCli(opts: {
     }
     throw err;
   }
+  if (!sawToolCall && replyChunks.length === 0 && result.text) {
+    replyChunks.push(result.text);
+    segmentChunks.push(result.text);
+    if (!opts.json && !opts.enableTools) process.stdout.write(result.text);
+  }
+  closeSegment();
   if (opts.json) {
     let logPath: string | null = null;
     try {
@@ -566,11 +576,9 @@ export async function runChatTurnCli(opts: {
       sessionId: session.id,
       provider: result.provider,
       model: result.model ?? null,
-      reply: replyChunks.join(''),
-      // ⭐ 2026-09-23 — `reply` 는 «모든 턴·모든 목표 루프 반복»의 본문을 이어 붙인다(뜻은 그대로 둔다 · 소비자 보호).
-      //   그래서 모델이 반복마다 최종 답을 다시 말하면 같은 문장이 여러 번 나온다(실측: kimi 3회·grok 2회).
-      //   `finalReply` = 마지막 어시스턴트 메시지 본문 — 「최종 답만」이 필요한 소비자용(뒤호환 추가 칸).
-      finalReply: (closeSegment(), lastSegment),
+      reply: finalMessage,
+      transcript: replyChunks.join(''),
+      finalReply: lastSegment,
       budget: sessionBudget(session.id),
       durationMs: Date.now() - startedAt,
       logPath,
@@ -579,7 +587,8 @@ export async function runChatTurnCli(opts: {
     await writeStdoutJson(JSON.stringify(out) + '\n');
     return;
   }
-  process.stdout.write('\n');
+  if (opts.enableTools) process.stdout.write(`${finalMessage}\n`);
+  else process.stdout.write('\n');
   ui.info(`[session ${session.id.slice(0, 8)}  ${result.provider}${result.model ? '/' + result.model : ''}  ${sessionBudget(session.id)}]`);
 }
 

package/src/cli/ask-bare.ts

@@ -0,0 +1,42 @@
+import { decideProviderForConfig, getProviderForConfig, streamLLM, type LLMMessage } from '../llm.js';
+import { getUserConfig } from '../user-config.js';
+import { DEFAULT_TOKEN_BUDGET, trimToBudget } from '../tokens.js';
+
+export interface AskBareDeps {
+  getUserConfig: typeof getUserConfig;
+  decideProviderForConfig: typeof decideProviderForConfig;
+  getProviderForConfig: typeof getProviderForConfig;
+  streamLLM: typeof streamLLM;
+  trimToBudget: typeof trimToBudget;
+}
+
+export async function askBare({ text, provider, model, deps }: {
+  text: string;
+  provider?: string;
+  model?: string;
+  deps: AskBareDeps;
+}): Promise<{ provider: string; model: string; reply: string }> {
+  const messages: LLMMessage[] = [{ role: 'user', content: text }];
+  if (deps.trimToBudget(messages, DEFAULT_TOKEN_BUDGET).used > DEFAULT_TOKEN_BUDGET) {
+    throw new Error(`ask --bare: input exceeds the ${DEFAULT_TOKEN_BUDGET}-token context budget`);
+  }
+  const cfg = deps.getUserConfig();
+  const selectedConfig = provider === undefined ? cfg : {
+    ...cfg,
+    llm: {
+      ...cfg.llm,
+      provider: provider as typeof cfg.llm.provider,
+      model: model ?? (provider === cfg.llm.provider ? cfg.llm.model : undefined),
+    },
+  };
+  const selected = deps.decideProviderForConfig(selectedConfig, model);
+  const chosenProvider = deps.getProviderForConfig(selectedConfig, model);
+  let resolvedProvider = chosenProvider.name;
+  let resolvedModel = selected.model;
+  const reply = await deps.streamLLM(messages, () => {}, {
+    ...(provider === undefined ? { initialProvider: chosenProvider } : { provider: chosenProvider }),
+    ...(selected.model === '(none)' ? {} : { model: selected.model }),
+    onResolvedProvider: (name, activeModel) => { resolvedProvider = name; resolvedModel = activeModel; },
+  });
+  return { provider: resolvedProvider, model: resolvedModel, reply };
+}

package/src/cli/cli-user-error.ts

@@ -0,0 +1,25 @@
+import { HarnessCliInputError } from '../harness/harness-cli-command.js';
+
+const cliUserErrorBrand = Symbol.for('elanous.cli.CliUserError');
+const harnessCliInputErrorBrand = Symbol.for('elanous.cli.HarnessCliInputError');
+
+export class CliUserError extends Error {
+  constructor(message: string, public readonly hint?: string) {
+    super(message);
+    this.name = 'CliUserError';
+    Object.defineProperty(this, cliUserErrorBrand, { value: true });
+  }
+}
+
+export function isCliUserError(err: unknown): err is Error & { hint?: string } {
+  return err instanceof HarnessCliInputError || err instanceof CliUserError || (
+    err instanceof Error && (
+      (err.name === 'CliUserError' && Object.getOwnPropertyDescriptor(err, cliUserErrorBrand)?.value === true) ||
+      (err.name === 'HarnessCliInputError' && Object.getOwnPropertyDescriptor(err, harnessCliInputErrorBrand)?.value === true)
+    )
+  );
+}
+
+export function formatCliUserError(err: Error & { hint?: string }): string {
+  return `❌ ${err.message}${err.hint ? `\n  ↳ ${err.hint}` : ''}`;
+}

package/src/cli/codex-credit-plan-view.ts

@@ -0,0 +1,25 @@
+// Assembles the codex credit plan from disk for `provider codex status` and `usage` — policy file, the last
+// measured per-account balances and the balance history. No network.
+import { codexCreditPlan, readCreditHistory, type CodexCreditPlan } from '../budget/codex-credit-plan.js';
+import { quotaSignalDir } from '../budget/codex-reset-credit-state.js';
+import { inspectCodexRotation } from '../oauth/codex-account-store.js';
+import { loadLlmPolicy } from '../policy/llm-policy.js';
+
+export function codexCreditPlanFromDisk(now: number = Date.now()): CodexCreditPlan {
+  const s = inspectCodexRotation(process.env, { now });
+  const seen = new Set<string>();
+  const balances: Array<{ name: string; balance?: number }> = [];
+  const push = (key: string, name: string, balance: number | undefined) => {
+    if (seen.has(key)) return;
+    seen.add(key);
+    balances.push({ name, ...(balance === undefined ? {} : { balance }) });
+  };
+  push(s.current.storeKey, s.current.name, s.currentCreditBalance);
+  for (const c of s.candidates) push(c.storeKey, c.name, c.creditBalance);
+  return codexCreditPlan({
+    now,
+    balances,
+    credits: loadLlmPolicy({ now: new Date(now) }).policy.credits,
+    history: readCreditHistory(quotaSignalDir()),
+  });
+}

package/src/cli/dependence-gauge.ts

@@ -0,0 +1,237 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import type { Command } from 'commander';
+
+/** Attribution is evidence about the executor, not about the person who requested the work. */
+export type DependenceAttribution = 'claude-code' | 'elanous' | 'other' | 'unknown';
+export type DependenceAxis = 'positions' | 'executions' | 'changes' | 'decisions';
+export interface DependenceObservation {
+  at?: string;
+  runtime?: string;
+  agent?: string;
+  track?: string;
+  /** A direct attribution supplied by a source record; never inferred from the author. */
+  actor?: string;
+}
+export interface DependenceSource {
+  observations: readonly DependenceObservation[];
+  /** A missing source is different from an observed empty source. */
+  unmeasurable?: string;
+}
+export interface DependenceAxisResult {
+  status: 'measured' | 'unmeasurable';
+  total: number;
+  covered: number;
+  claudeCode: number;
+  elanous: number;
+  other: number;
+  unknown: number;
+  /** Records whose timestamp cannot place them inside or outside the requested window. Not in total. */
+  undated: number;
+  reason?: string;
+}
+export interface DependenceReport {
+  since: string;
+  until: string;
+  axes: Record<DependenceAxis, DependenceAxisResult>;
+}
+export interface DependenceGaugeDeps {
+  now?: () => Date;
+  readPositions?: () => DependenceSource;
+  readExecutions?: () => DependenceSource;
+  readChanges?: (window: { since: string; until: string }) => DependenceSource;
+  readDecisions?: () => DependenceSource;
+  out?: Pick<Console, 'log'>;
+}
+
+const axes = ['positions', 'executions', 'changes', 'decisions'] as const;
+const identity = (value: unknown): DependenceAttribution => {
+  if (typeof value !== 'string' || !value.trim()) return 'unknown';
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'claude-code' || normalized === 'claude code') return 'claude-code';
+  if (normalized === 'elanous') return 'elanous';
+  if (normalized === 'unknown') return 'unknown';
+  return 'other';
+};
+
+/** Explicit per-event runtime wins over an agent label, which wins over the seat default. */
+export function attributeDependence(row: DependenceObservation, positions: ReadonlyMap<string, DependenceAttribution>): DependenceAttribution {
+  if (row.actor?.trim()) return identity(row.actor);
+  if (row.runtime?.trim()) return identity(row.runtime);
+  if (row.agent?.trim()) return identity(row.agent);
+  return row.track ? (positions.get(row.track) ?? 'unknown') : 'unknown';
+}
+
+function instant(raw: string, label: string): Date {
+  // Date.parse silently normalizes impossible days (e.g. February 30), including timestamps.
+  const calendarDate = /^(\d{4}-\d{2}-\d{2})(?:T|$)/.exec(raw)?.[1];
+  if (calendarDate) {
+    const day = new Date(`${calendarDate}T00:00:00.000Z`);
+    if (!Number.isFinite(day.getTime()) || day.toISOString().slice(0, 10) !== calendarDate) {
+      throw new Error(`invalid ${label}: ${raw}`);
+    }
+  }
+  const date = new Date(calendarDate === raw ? `${raw}T00:00:00.000Z` : raw);
+  if (!Number.isFinite(date.getTime())) throw new Error(`invalid ${label}: ${raw}`);
+  return date;
+}
+
+function observationTime(raw: string | undefined): number | undefined {
+  if (!raw) return undefined;
+  const match = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.exec(raw);
+  if (!match) return undefined;
+  const day = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])));
+  if (day.toISOString().slice(0, 10) !== raw.slice(0, 10)) return undefined;
+  const time = Date.parse(raw);
+  return Number.isFinite(time) ? time : undefined;
+}
+
+export function dependenceWindow(since: string | undefined, until: string | undefined, now: Date): { since: string; until: string } {
+  const end = until ? instant(until, '--until') : now;
+  if (!Number.isFinite(end.getTime())) throw new Error('invalid current date');
+  // Date-only --until includes that entire UTC day; relative lookback is anchored to its end.
+  const inclusiveEnd = until && /^\d{4}-\d{2}-\d{2}$/.test(until)
+    ? new Date(end.getTime() + 86_400_000 - 1) : end;
+  const match = /^(\d+)d$/.exec(since ?? '7d');
+  const start = match ? new Date(inclusiveEnd.getTime() - Number(match[1]) * 86_400_000)
+    : instant(since ?? '7d', '--since');
+  if (!Number.isFinite(start.getTime()) || start > inclusiveEnd) throw new Error('invalid --since: start must be at or before --until');
+  return { since: start.toISOString(), until: inclusiveEnd.toISOString() };
+}
+
+export function readSeatRegistry(): DependenceSource {
+  try {
+    const raw = JSON.parse(readFileSync(resolve(import.meta.dir, '../../scripts/coord-tracks.json'), 'utf8')) as { tracks?: unknown };
+    if (!Array.isArray(raw.tracks)) return { observations: [], unmeasurable: 'seat registry has no tracks' };
+    return { observations: raw.tracks.filter((track): track is { id: string; title: string; runtime?: string } =>
+      typeof track === 'object' && track !== null && typeof track.id === 'string' && typeof track.title === 'string')
+      .map(track => ({ track: track.id, runtime: track.runtime })) };
+  } catch (error) {
+    return { observations: [], unmeasurable: `seat registry unreadable: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+
+function unknownSource(description: string): DependenceSource {
+  return { observations: [], unmeasurable: description };
+}
+
+function stringField(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function object(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+export function readRunExecutions(directory = join(elanousStateRoot(), 'run-ledger')): DependenceSource {
+  try {
+    if (!existsSync(directory)) return unknownSource('run-ledger directory absent');
+    const observations: DependenceObservation[] = [];
+    for (const name of readdirSync(directory).filter(name => name.endsWith('.jsonl')).sort()) {
+      const lines = readFileSync(join(directory, name), 'utf8').split('\n').filter(Boolean);
+      let launch: DependenceObservation | undefined;
+      for (const line of lines) {
+        const entry = object(JSON.parse(line));
+        if (entry.event === 'run-origin') {
+          const data = object(entry.data);
+          launch = { at: stringField(entry.timestamp), runtime: stringField(data.runtime),
+            agent: stringField(data.agent), track: stringField(data.track) };
+          break;
+        }
+        if (!launch) launch = { at: stringField(entry.timestamp) };
+      }
+      if (launch) observations.push(launch);
+    }
+    return { observations };
+  } catch (error) {
+    return unknownSource(`run-ledger unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/** 이 저장소의 실제 표지 — `Co-Authored-By:` 트레일러(작성자·커미터는 전부 같은 사람이라 쓰지 않는다).
+ *  하니스 착지(`elanous pod child`) > codex > Claude 순 — 한 병합에 여러 표지면 실제로 코드를 쓴 쪽이 앞선다. */
+export function runtimeFromCoAuthors(body: string): string | undefined {
+  const names = [...body.matchAll(/^co-authored-by:[^\S\r\n]*([^<\r\n]*)/gim)].map(m => m[1]!.trim().toLowerCase());
+  if (names.some(n => n.includes('elanous'))) return 'elanous';
+  if (names.some(n => n.includes('codex'))) return 'codex';
+  if (names.some(n => n.includes('claude'))) return 'claude-code';
+  return undefined;
+}
+
+export function readChangeCommits(window: { since: string; until: string }, repo = resolve(import.meta.dir, '../..')): DependenceSource {
+  // Git object reads only: author and committer are deliberately NOT treated as the executor.
+  // 착지 = main 의 첫 부모 줄(스쿼시 병합 하나 = 착지 하나) — `--all` 은 가지의 중간 커밋까지 세어 부풀린다.
+  const result = spawnSync('git', ['log', 'origin/main', '--first-parent', '--format=%cI%x1f%B%x1e', `--since-as-filter=${window.since}`, `--until=${window.until}`], {
+    cwd: repo, encoding: 'utf8', timeout: 15_000, maxBuffer: 16 * 1024 * 1024,
+  });
+  if (result.status !== 0 || result.error) return unknownSource(`git history unreadable: ${result.error?.message ?? result.stderr ?? result.status}`);
+  if (result.stdout.length >= 16 * 1024 * 1024 - 1024) return unknownSource('git history exceeds gauge read limit');
+  const observations = result.stdout.split('\x1e').filter(record => record.includes('\x1f')).map(record => {
+    const [at, body] = record.trim().split('\x1f', 2);
+    const attribution = /(?:^|\n)(?:Executed-By|Agent-Runtime|Runtime):[^\S\r\n]*([^\r\n]*)/im.exec(body ?? '');
+    return { at, runtime: attribution?.[1]?.trim() ?? runtimeFromCoAuthors(body ?? '') };
+  });
+  return { observations };
+}
+
+/** No mutation of ledgers or state; absent attribution data is reported, never guessed from an author or requester. */
+export function measureDependence(deps: DependenceGaugeDeps = {}, options: { since?: string; until?: string } = {}): DependenceReport {
+  const window = dependenceWindow(options.since, options.until, (deps.now ?? (() => new Date()))());
+  const sources: Record<DependenceAxis, DependenceSource> = {
+    positions: (deps.readPositions ?? readSeatRegistry)(),
+    executions: (deps.readExecutions ?? readRunExecutions)(),
+    changes: (deps.readChanges ?? readChangeCommits)(window),
+    decisions: (deps.readDecisions ?? (() => unknownSource('decision actor cannot be measured from the available data')))(),
+  };
+  const positions = new Map<string, DependenceAttribution>();
+  for (const row of sources.positions.observations) {
+    if (row.track) positions.set(row.track, identity(row.runtime));
+  }
+  const result = {} as Record<DependenceAxis, DependenceAxisResult>;
+  for (const axis of axes) {
+    const source = sources[axis];
+    const counts: DependenceAxisResult = { status: source.unmeasurable ? 'unmeasurable' : 'measured', total: 0, covered: 0, claudeCode: 0, elanous: 0, other: 0, unknown: 0, undated: 0,
+      ...(source.unmeasurable ? { reason: source.unmeasurable } : {}) };
+    for (const row of source.observations) {
+      if (axis !== 'positions') {
+        const at = observationTime(row.at);
+        if (at === undefined) { counts.undated++; continue; }
+        if (at < Date.parse(window.since) || at > Date.parse(window.until)) continue;
+      }
+      counts.total++;
+      const attribution = attributeDependence(row, positions);
+      if (attribution === 'unknown') counts.unknown++;
+      else {
+        counts.covered++;
+        if (attribution === 'claude-code') counts.claudeCode++;
+        else if (attribution === 'elanous') counts.elanous++;
+        else counts.other++;
+      }
+    }
+    result[axis] = counts;
+  }
+  return { ...window, axes: result };
+}
+
+export function formatDependenceReport(report: DependenceReport): string {
+  return [
+    `Dependence · ${report.since} — ${report.until}`,
+    ...axes.map(axis => {
+      const row = report.axes[axis];
+      return `${axis}: ${row.status}${row.reason ? ` (${row.reason})` : ''} · coverage ${row.covered}/${row.total} · claude-code ${row.claudeCode} · elanous ${row.elanous} · other ${row.other} · unknown ${row.unknown} · undated ${row.undated}`;
+    }),
+  ].join('\n');
+}
+
+/** Register below the existing `self` command rather than creating a second top-level command. */
+export function registerDependenceCommand(self: Command, deps: DependenceGaugeDeps = {}): void {
+  self.command('dependence').description('Read-only attribution gauge (unknown is not zero)')
+    .option('--since <date>', 'UTC date or lookback period (default 7d)', '7d')
+    .option('--until <date>', 'UTC date or timestamp').option('--json', 'JSON output')
+    .action((options: { since?: string; until?: string; json?: boolean }) => {
+      const report = measureDependence(deps, options);
+      (deps.out ?? console).log(options.json ? JSON.stringify(report) : formatDependenceReport(report));
+    });
+}

package/src/cli/doctor-cli.ts

@@ -34,6 +34,7 @@ import { ADVISABLE_DOCTOR_FIX_IDS, adviseDoctorFixes, type DoctorAdvice } from '
 import { gitInstallPlan } from './git-install-plan.js';
 import { detectDistroFamily, parseOsRelease } from './doctor-distro.js';
 import { checkPythonEnv } from './python-cli.js';
+import { describeModes, formatModeLine, type DoctorMode } from './doctor-modes.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -99,6 +100,8 @@ export interface DoctorReport {
   externalCommands: DoctorExternalCommand[];
   requiredMissing?: string[];
   capabilitySummary?: DoctorCapabilitySummary;
+  /** Read-only configuration and chat-use status. Present on a successful report. */
+  modes?: DoctorMode[];
   /** F1 readiness. Present on a successful report. Absent when the report itself failed. */
   readiness?: ReadinessReport;
   reason?: string;
@@ -1044,6 +1047,7 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
       externalCommands: externalCommands.commands,
       requiredMissing,
       capabilitySummary: summarizeDoctorCapabilities(credentials),
+      modes: describeModes(resolutionOptions.userConfig),
       readiness: evaluateReadiness(readiness),
       retiredConfigKeys: findRetiredConfigKeysInFile(options.configPath, readFile),
       ...(resourceMetadata.available ? {} : { catalogMetadataUnavailable: true }),
@@ -1136,6 +1140,7 @@ export function formatDoctorReport(report: DoctorReport, options: { credentials?
     }),
     ...(report.externalCommandsCatalogUnavailable ? [`External commands catalog unavailable: ${report.externalCommandsCatalogReason ?? 'catalog/external-commands.yaml is unavailable.'}`] : []),
     ...formatCapabilitySummary(capabilitySummary),
+    ...(report.modes ? ['모드:', ...report.modes.map((row) => `  ${formatModeLine(row)}`)] : []),
   ].join('\n');
 }
 

package/src/cli/doctor-modes.ts

@@ -0,0 +1,48 @@
+import { DEFAULT_MODEL_TIER, isModelTier, type ModelTier } from '../model-tier/types.js';
+
+export interface DoctorMode {
+  id: 'model-tier' | 'auto-route' | 'fast-mode';
+  value: ModelTier | boolean | 'none';
+  source: 'config' | 'default' | 'none';
+  usedByChat: boolean;
+  note: string;
+}
+
+/** Report configured switches without changing them or implying they affect chat turns. */
+export function describeModes(cfg: { modelTier?: { llm?: unknown }; llm?: { autoRoute?: { enabled?: unknown } } }): DoctorMode[] {
+  const tier = cfg.modelTier?.llm;
+  const autoRoute = cfg.llm?.autoRoute?.enabled;
+  return [
+    {
+      id: 'model-tier',
+      value: isModelTier(tier) ? tier : DEFAULT_MODEL_TIER,
+      source: isModelTier(tier) ? 'config' : 'default',
+      usedByChat: false,
+      note: '대화 턴 모델 선택에 쓰이지 않는다(표시·전환 계획만)',
+    },
+    {
+      id: 'auto-route',
+      value: typeof autoRoute === 'boolean' ? autoRoute : false,
+      source: typeof autoRoute === 'boolean' ? 'config' : 'default',
+      usedByChat: false,
+      note: '오토파일럿 턴만 읽는다 · 켜기 = elanous config set llm.autoRoute.enabled true',
+    },
+    {
+      id: 'fast-mode',
+      value: 'none',
+      source: 'none',
+      usedByChat: false,
+      note: '스위치 없음(분류기 호출부 0)',
+    },
+  ];
+}
+
+export function formatModeLine(row: DoctorMode): string {
+  const label = {
+    'model-tier': 'smart·등급',
+    'auto-route': 'smart·자동 라우팅',
+    'fast-mode': '빠른 모드',
+  }[row.id];
+  const source = { config: '설정', default: '기본', none: '없음' }[row.source];
+  return `${label}: ${String(row.value)}(${source}) · 대화에 ${row.usedByChat ? '쓰임' : '안 쓰임'} — ${row.note}`;
+}

package/src/cli/intake-cli.ts

@@ -11,6 +11,7 @@ import { writeStdoutFully } from './stdout-flush.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
+import { registerIntakeSourceCommands } from './intake-source-cli.js';
 
 export interface IntakeToTasksCliDeps {
   root: string;
@@ -91,6 +92,7 @@ export function resolveIntakeCheckRoot(
 export function registerIntakeCommands(program: Command): void {
   // ── intake check — 바깥 사실을 elanous 현재와 대조 (태스크 등록 없음) ──
   const intakeCmd = program.command('intake').description('바깥 사실·문서를 elanous 현재와 대조하거나 태스크로 받는다');
+  registerIntakeSourceCommands(intakeCmd);
   intakeCmd.hook('preAction', async () => {
     try {
       const { registerStandaloneLogSink } = await import('../domains/standalone-log-sink.js');
@@ -217,7 +219,9 @@ export function registerIntakeCommands(program: Command): void {
       const { readPipedStdin } = await import('./piped-stdin.js');
       const text = opts.file ? readFileSync(opts.file, 'utf8') : (await readPipedStdin()) ?? '';
       const { raws, bad } = parseRawIntakeJsonl(text);
-      const result = ingestIntakeItems(effectiveInstanceRoot(), opts.source as (typeof INTAKE_SOURCES)[number], raws);
+      let result: ReturnType<typeof ingestIntakeItems>;
+      try { result = ingestIntakeItems(effectiveInstanceRoot(), opts.source as (typeof INTAKE_SOURCES)[number], raws); }
+      catch (error) { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 2; return; }
       const out = { source: opts.source, inputLines: raws.length + bad, badInputLines: bad, ...result };
       if (opts.json) await writeStdoutFully(JSON.stringify(out, null, 2));
       else console.log(`흡수 원장 · ${opts.source}: 새 ${result.added} · 합침 ${result.merged} · 이미 끝난 것 ${result.seen} · 버림 ${result.skipped}${bad ? ` · 깨진 입력 ${bad}` : ''}${result.badLines ? ` · 깨진 원장 줄 ${result.badLines}` : ''}`);
@@ -228,14 +232,20 @@ export function registerIntakeCommands(program: Command): void {
     .description('흡수 원장 항목 보기 (최근 본 순)')
     .option('--status <status>', 'new | queued | absorbed | checked | routed | discarded | deferred')
     .option('--source <source>', '입력원으로 거르기')
+    .option('--seat <id>', '자리 id (별칭 허용; 자리 없는 옛 항목은 제외)')
     .option('--limit <n>', '최대 줄 수 (기본 30)')
     .option('--json', '구조화 출력')
-    .action(async (opts: { status?: string; source?: string; limit?: string; json?: boolean }) => {
+    .action(async (opts: { status?: string; source?: string; seat?: string; limit?: string; json?: boolean }) => {
       const { listIntakeItems } = await import('../intake-plane/items.js');
       const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+      const { canonicalSeat } = await import('../intake-plane/intake-sources.js');
+      let seat: string | undefined;
+      try { seat = opts.seat === undefined ? undefined : canonicalSeat(opts.seat); }
+      catch (error) { console.error((error as Error).message); process.exitCode = 2; return; }
       const all = listIntakeItems(effectiveInstanceRoot(), {
         ...(opts.status ? { status: opts.status as never } : {}),
         ...(opts.source ? { source: opts.source as never } : {}),
+        ...(seat ? { seat } : {}),
       });
       const limit = Math.max(1, Number(opts.limit ?? 30) || 30);
       const shown = all.slice(0, limit);

package/src/cli/intake-source-cli.ts

@@ -0,0 +1,58 @@
+import type { Command } from 'commander';
+import { randomUUID } from 'node:crypto';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { addSource, canonicalSeat, dueSources, expiredSource, listSources, removeSource, runDue, type SourceKind } from '../intake-plane/intake-sources.js';
+
+export function registerIntakeSourceCommands(intake: Command, root: () => string = effectiveInstanceRoot): void {
+  const source = intake.command('source').description('자리별 흡수 원천과 주기 등록·조회·실행');
+  const fail = (error: unknown) => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 2; };
+  source.command('add')
+    .requiredOption('--seat <id>', '자리 id 또는 별칭')
+    .requiredOption('--kind <kind>', 'github-query | rss | command')
+    .requiredOption('--spec <spec>', 'GitHub 질의 · 피드 URL · 명령')
+    .requiredOption('--every <cadence>', 'Nh | Nd | Nw')
+    .option('--until <date>', '만료 시작 날짜 YYYY-MM-DD (UTC)')
+    .option('--why <reason>', '등록 이유')
+    .option('--id <id>', '원천 id')
+    .action((opts: { seat: string; kind: string; spec: string; every: string; until?: string; why?: string; id?: string }) => {
+      try {
+        const added = addSource({ id: opts.id ?? `src-${randomUUID().slice(0, 8)}`, seat: opts.seat, kind: opts.kind as SourceKind,
+          spec: opts.spec, every: opts.every, ...(opts.until ? { until: opts.until } : {}), ...(opts.why ? { why: opts.why } : {}) }, root());
+        console.log(`${added.id}  ${added.seat}  ${added.kind}  ${added.every}`);
+      } catch (error) { fail(error); }
+    });
+  source.command('list')
+    .option('--seat <id>', '자리 id 또는 별칭')
+    .option('--json', 'JSON 출력')
+    .action((opts: { seat?: string; json?: boolean }) => {
+      try {
+        const now = new Date();
+        const sources = listSources({ seat: opts.seat }, root()).map((entry) => ({ ...entry, expired: expiredSource(entry, now) }));
+        if (opts.json) console.log(JSON.stringify(sources));
+        else for (const entry of sources) console.log(`${entry.id}  ${entry.seat}  ${entry.kind}  ${entry.every}  ${entry.expired ? '만료' : '활성'}  ${entry.spec}`);
+      } catch (error) { fail(error); }
+    });
+  source.command('remove <id>').action((id: string) => {
+    try { if (!removeSource(id, root())) { console.error(`원천 id 없음: ${id}`); process.exitCode = 2; return; } console.log(`removed ${id}`); }
+    catch (error) { fail(error); }
+  });
+  source.command('run-due')
+    .option('--seat <id>', '자리 id 또는 별칭')
+    .option('--dry-run', '기한 원천 목록만 · 수집·원장·마지막 실행 시각 무변')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { seat?: string; dryRun?: boolean; json?: boolean }) => {
+      try {
+        const seat = opts.seat === undefined ? undefined : canonicalSeat(opts.seat);
+        if (opts.dryRun) {
+          const sources = dueSources(new Date(), root()).filter((entry) => seat === undefined || entry.seat === seat);
+          if (opts.json) console.log(JSON.stringify(sources));
+          else for (const entry of sources) console.log(`${entry.id}  ${entry.seat}  ${entry.kind}  ${entry.every}`);
+          return;
+        }
+        const result = await runDue({ seat, deps: { stateDir: root() } });
+        if (opts.json) console.log(JSON.stringify(result));
+        else for (const row of result.ran) console.log(`${row.id}  ${row.items}${row.error ? `  실패: ${row.error}` : ''}`);
+        if (result.ran.some((row) => row.error)) process.exitCode = 1;
+      } catch (error) { fail(error); }
+    });
+}