elanous 0.2.6 → 0.2.8

package/src/channel-import/run.ts

@@ -0,0 +1,111 @@
+// EN13 — 감지 → 미리보기 → 동의 → 시크릿 저장 → 연결 확인(읽기 1회). 토큰 값은 화면·로그·채널 어디에도 안 나간다.
+import { homedir } from 'node:os';
+import { debug } from '../debug/log.js';
+import { detectChannelImports, pickPerPlatform, previewLine, SOURCE_LABEL, type ImportCandidate, type ImportPlatform } from './detect.js';
+
+export interface ChannelImportDeps {
+  home?: string;
+  out?: { log: (s: string) => void; error: (s: string) => void };
+  /** Asks once; returns true for yes. Absent or non-interactive → no. */
+  ask?: (question: string) => Promise<boolean>;
+  yes?: boolean;
+  /** Current token for that platform (to say «already the same»), or null. */
+  currentToken?: (platform: ImportPlatform) => string | null | Promise<string | null>;
+  store?: (platform: ImportPlatform, token: string, allowedUsers: string[] | undefined) => Promise<void>;
+  probe?: (platform: ImportPlatform, token: string) => Promise<{ ok: boolean; botName?: string }>;
+}
+
+export interface ChannelImportOutcome {
+  exitCode: number;
+  imported: { platform: ImportPlatform; source: string; connected: boolean; botName?: string }[];
+}
+
+const NAME: Record<ImportPlatform, string> = { telegram: '텔레그램', discord: '디스코드' };
+
+async function defaultStore(platform: ImportPlatform, token: string, allowedUsers: string[] | undefined): Promise<void> {
+  const { storeChannelBotToken } = await import('../channel-bot-token.js');
+  await storeChannelBotToken(platform, token, allowedUsers);
+}
+
+async function defaultProbe(platform: ImportPlatform, token: string): Promise<{ ok: boolean; botName?: string }> {
+  const { probeChannelBotToken } = await import('../channel-bot-token.js');
+  return probeChannelBotToken(platform, token);
+}
+
+async function defaultCurrentToken(platform: ImportPlatform): Promise<string | null> {
+  try {
+    const { resolveChannelBotToken } = await import('../channel-bot-token.js');
+    const { getUserConfig } = await import('../user-config.js');
+    return resolveChannelBotToken(platform, getUserConfig())?.token ?? null;
+  } catch { return null; }
+}
+
+export async function runChannelImport(deps: ChannelImportDeps = {}): Promise<ChannelImportOutcome> {
+  const out = deps.out ?? console;
+  const home = deps.home ?? homedir();
+  const { candidates, unreadable } = detectChannelImports(home);
+  for (const u of unreadable) out.log(`· ${u.file}: ${u.reason} — 건너뜁니다`);
+  const { chosen, others } = pickPerPlatform(candidates);
+  debug.log('channel-import', 'detected', {
+    sources: candidates.map((c) => `${c.source}:${c.platform}`), chosen: chosen.length, others: others.length, unreadable: unreadable.length,
+  });
+  if (!chosen.length) {
+    out.log('가져올 텔레그램·디스코드 설정을 찾지 못했습니다(OpenClaw · Hermes · 이전 엘라누스). 직접 넣으려면: elanous nexus channel-bot setup telegram');
+    return { exitCode: 0, imported: [] };
+  }
+
+  const current = deps.currentToken ?? defaultCurrentToken;
+  const todo: ImportCandidate[] = [];
+  out.log('이미 쓰던 채널 설정을 찾았습니다:');
+  for (const c of chosen) {
+    const existing = await current(c.platform);
+    if (existing && existing === c.token.reveal()) { out.log(`· ${previewLine(c)} — 이미 같은 토큰을 쓰고 있습니다`); continue; }
+    out.log(`· ${previewLine(c)}${existing ? ' — ⚠️ 지금 쓰는 토큰을 바꿉니다' : ''}`);
+    todo.push(c);
+  }
+  for (const c of others) out.log(`  (${NAME[c.platform]} 토큰이 ${SOURCE_LABEL[c.source]}에도 있습니다 — 다른 토큰이라 위의 것만 가져옵니다)`);
+  if (!todo.length) return { exitCode: 0, imported: [] };
+
+  const question = `가져올까요? 토큰은 엘라누스 비밀 저장소에만 넣고 화면·로그에는 남기지 않습니다. [Y/n] `;
+  const agreed = deps.yes || (deps.ask ? await deps.ask(question) : false);
+  if (!agreed) {
+    out.log(deps.ask || deps.yes ? '가져오지 않았습니다.' : '가져오려면: elanous nexus channel-bot import --yes');
+    debug.log('channel-import', 'declined', { count: todo.length });
+    return { exitCode: 0, imported: [] };
+  }
+
+  const store = deps.store ?? defaultStore;
+  const probe = deps.probe ?? defaultProbe;
+  const imported: ChannelImportOutcome['imported'] = [];
+  let failed = 0;
+  for (const c of todo) {
+    try {
+      await store(c.platform, c.token.reveal(), c.allowedUsers.length ? c.allowedUsers : undefined);
+    } catch (error) {
+      failed++;
+      // Store errors are our own (lock, invalid ids) — print the class only, never the message, in case it carries input.
+      const reason = error instanceof Error && error.message === 'invalid-allowed-users' ? '허용 사용자 형식이 맞지 않습니다' : '저장하지 못했습니다';
+      out.error(`✗ ${NAME[c.platform]}: ${reason}`);
+      debug.log('channel-import', 'store-failed', { platform: c.platform, source: c.source }, { level: 'warn' });
+      continue;
+    }
+    const check = await probe(c.platform, c.token.reveal()).catch(() => ({ ok: false } as { ok: boolean; botName?: string }));
+    imported.push({ platform: c.platform, source: c.source, connected: check.ok, ...(check.botName ? { botName: check.botName } : {}) });
+    debug.log('channel-import', 'stored', { platform: c.platform, source: c.source, connected: check.ok });
+    out.log(check.ok
+      ? `✓ ${NAME[c.platform]}: 저장했고 연결을 확인했습니다 — @${check.botName}`
+      : `△ ${NAME[c.platform]}: 저장했지만 연결 확인에 실패했습니다 — 토큰이 만료됐거나 네트워크 문제일 수 있습니다(다시 넣기: elanous nexus channel-bot setup ${c.platform})`);
+  }
+  if (imported.length) out.log('봇은 다음 넥서스 시작 때 켜집니다.');
+  return { exitCode: failed ? 1 : 0, imported };
+}
+
+/** One line for onboarding — null when there is nothing to import. Never reveals a value. */
+export function channelImportHint(home = homedir()): string | null {
+  try {
+    const { chosen } = pickPerPlatform(detectChannelImports(home).candidates);
+    if (!chosen.length) return null;
+    const what = chosen.map((c) => `${NAME[c.platform]}(${SOURCE_LABEL[c.source]})`).join(' · ');
+    return `쓰던 채널 설정 찾음: ${what} — 가져오려면: elanous nexus channel-bot import`;
+  } catch { return null; }
+}

package/src/chat/chat-cli.ts

@@ -49,5 +49,8 @@ export function toDevChatOpts(opts: ChatCliOpts): DevChatOpts {
 export async function runChatCliCommand(text: string, opts: ChatCliOpts, deps: ChatCliDeps): Promise<void> {
   const spec = buildChatDevSpec(text, toDevChatOpts(opts));
   const run = deps.runDevPipeline ?? runDevPipeline;
-  await run(spec, { runChatTurn: deps.runChatTurn });
+  await run(spec, {
+    runChatTurn: deps.runChatTurn,
+    ...(opts.json ? { progress: (message: string) => { process.stderr.write(`${message}\n`); } } : {}),
+  });
 }

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/config-test-sync.ts

@@ -41,6 +41,9 @@ export const TEST_SYNC_AUX_FILES: readonly string[] = [
   'llm-fallback.json', // 모델 폴백 체인
   'auth.json',         // oauth 자격 (LLM provider)
   'identity.json',     // self identity — 무해·자기인식 일관
+  // POL1 (10-01): the LLM policy (credit use · pace · grants). Without it a tree's test universe resolved «fallback»
+  // while production said «credits», and every harness run from a work tree went to grok.
+  'policy/llm.yaml',
 ];
 
 /** 의도적 제외 (복사 금지 — 이유 명시. 목록 변경 시 반드시 사유와 함께). */
@@ -201,6 +204,7 @@ export function syncTestConfig(testDir: string, srcDir: string = prodConfigDir()
     //   목록 뒤의 `auth.json`(codex 로그인)이 복사되지 않아 격리 우주의 자식이 codex 를 못 썼다.
     //   ⇒ 이미 같은 바이트면 건너뛴다(멱등) — 다르면 종전처럼 복사한다(실패는 그대로 드러난다).
     if (existsSync(to) && readFileSync(from).equals(readFileSync(to))) { chmodSync(to, 0o600); skippedIdentical.push(f); continue; }
+    mkdirSync(dirname(to), { recursive: true });
     copyFileSync(from, to);
     chmodSync(to, 0o600);
     copied.push(f);

package/src/cli/decisions-cli.ts

@@ -9,6 +9,12 @@ function date(raw?: string): string | undefined {
   if (!Number.isFinite(parsed.getTime())) throw new Error(`invalid since: ${raw}`);
   return parsed.toISOString();
 }
+/** `+6h` → now + 6 hours; otherwise a UTC ISO timestamp (validated by the ledger). */
+function dueAt(raw: string): string {
+  const hours = /^\+(\d+(?:\.\d+)?)h$/.exec(raw.trim());
+  if (hours) return new Date(Date.now() + Number(hours[1]) * 3600000).toISOString();
+  return raw.trim();
+}
 const kst = (at: string) => new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'medium' }).format(new Date(at)) + ' KST';
 const version = (e: DecisionEntry['version']) => e ? `released=${e.released ?? '-'} · dev=${e.dev ?? '-'}${e.codename ? ` «${e.codename}»` : ''}` : '판 미상';
 function agent(o?: string): string {
@@ -30,6 +36,7 @@ export function formatDecisionDetail(e: DecisionEntry): string {
     '선택지 | 결과', ...(e.options.length ? e.options.map(o => `${o.key}: ${o.label} | ${o.consequence}`) : ['원문에 선택지 없음 · 확인 필요']),
     'skipped' in e.recommendation ? `권고 생략: ${e.recommendation.reason}` : `권고: ${e.recommendation.option} — ${e.recommendation.why}`,
     `올림: ${e.raisedAt ? kst(e.raisedAt) : '시각 미상'} · ${e.raisedBy.agent} · ${version(e.version)}`,
+    ...(e.dueAt ? [`기한: ${kst(e.dueAt)}`] : []),
     ...(e.importedAt ? [`가져옴: ${kst(e.importedAt)}`] : []),
     ...(e.status === 'decided' ? [`결정: ${e.decidedAt ? kst(e.decidedAt) : '시각 미상'} · ${e.decidedBy?.kind === 'auto' ? `AUTO ${e.decidedBy.agent} (${e.decidedBy.delegation})` : e.decidedBy?.kind === 'human' ? 'human' : '주체 미상'} · ${e.choice ?? '선택 키 미상'} · ${e.versionAtDecision ? version(e.versionAtDecision) : '결정 당시 판 미상'}`,
       ...(e.note ? [`메모: ${e.note}`] : [])] : []),
@@ -48,14 +55,17 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--track <track>').option('--agent <agent>').option('--session <id>')
-    .option('--ref <url>', '참조 (반복)', repeat, [] as string[]).option('--json')
-    .action((o: { title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
+    .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
+    .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
+    .option('--json')
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
       if (o.skipRecommend !== undefined && (o.recommend !== undefined || o.why !== undefined)) throw new Error('choose recommendation or skip, not both');
       if (o.skipRecommend === undefined && (!o.recommend || !o.why)) throw new Error('--recommend and --why required, or --skip-recommend <reason>');
       const options: DecisionOption[] = o.option.map(parseOption);
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },
-        raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}) });
+        raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}),
+        ...(o.due ? { dueAt: dueAt(o.due) } : {}) });
       emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
   root.command('list').description('결정 목록 (기본 열린 것)')

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));
+    });
+}