elanous 0.2.7 → 0.2.8

package/scripts/test-diet/lib.ts

@@ -0,0 +1,88 @@
+// TD2 — a daily look at the test suite, one cost-weighted slice at a time (shadow: it measures and drafts, it
+// never deletes or moves a test). Design: 내부 문서 `TD1-v2-gate-content-review-2026-10-01`.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const DEFAULT_COST_SECS = 10;
+export const SLOW_SECS = 60;
+export const HEAVY_MB = 2048;
+
+export interface Measurement { file: string; secs: number; rssMb: number | null; rc: number | null; pass: number | null; fail: number | null; reason?: string }
+export type Verdict = 'keep' | 'failing' | 'review';
+export interface Judged extends Measurement { caught90: number; flags: string[]; verdict: Verdict }
+export interface LedgerLine { at: string; range: string; start: number; end: number; next: number; total: number; commit: string; budgetSecs: number; results: Judged[] }
+
+/** `file\tsecs\t…` (TD1 whole-gate TSV) → seconds per file. */
+export function costTable(tsv: string): Map<string, number> {
+  const costs = new Map<string, number>();
+  for (const line of tsv.split('\n').slice(1)) {
+    const [file, secs] = line.split('\t');
+    const n = Number(secs);
+    if (file && Number.isFinite(n) && n > 0) costs.set(file, n);
+  }
+  return costs;
+}
+
+/** Next slice from the cursor until the known cost reaches the budget (at least one file; wraps at the end). */
+export function pickRange(files: readonly string[], start: number, costs: ReadonlyMap<string, number>, budgetSecs: number): { start: number; end: number; next: number; files: string[]; estimatedSecs: number } {
+  if (files.length === 0) return { start: 0, end: -1, next: 0, files: [], estimatedSecs: 0 };
+  const from = ((start % files.length) + files.length) % files.length;
+  const picked: string[] = [];
+  let spent = 0;
+  let i = from;
+  while (picked.length < files.length) {
+    const file = files[i]!;
+    const cost = costs.get(file) ?? DEFAULT_COST_SECS;
+    if (picked.length > 0 && spent + cost > budgetSecs) break;
+    picked.push(file);
+    spent += cost;
+    i = (i + 1) % files.length;
+  }
+  return { start: from, end: (from + picked.length - 1) % files.length, next: i, files: picked, estimatedSecs: spent };
+}
+
+/** Mechanical verdict: failing, or slow/heavy with nothing caught in 90 days → review (a draft card, never an action). */
+export function judge(m: Measurement, caught90: number): Judged {
+  const flags: string[] = [];
+  if (m.secs >= SLOW_SECS) flags.push('slow');
+  if (m.rssMb !== null && m.rssMb >= HEAVY_MB) flags.push('heavy');
+  const verdict: Verdict = m.rc !== 0 ? 'failing' : flags.length > 0 && caught90 === 0 ? 'review' : 'keep';
+  return { ...m, caught90, flags, verdict };
+}
+
+export function ledgerPath(root: string): string { return join(root, 'test-diet', 'ledger.jsonl'); }
+
+export function lastLedgerLine(root: string): LedgerLine | null {
+  const path = ledgerPath(root);
+  if (!existsSync(path)) return null;
+  const lines = readFileSync(path, 'utf8').trim().split('\n').filter(Boolean);
+  try { return lines.length ? JSON.parse(lines.at(-1)!) as LedgerLine : null; } catch { return null; }
+}
+
+export function appendLedger(root: string, line: LedgerLine): void {
+  mkdirSync(join(root, 'test-diet'), { recursive: true });
+  appendFileSync(ledgerPath(root), `${JSON.stringify(line)}\n`);
+}
+
+/** Draft approval card — written as a file for a person to read; nothing is acted on. */
+export function writeCardDraft(root: string, line: LedgerLine): string | null {
+  const items = line.results.filter((r) => r.verdict !== 'keep');
+  if (items.length === 0) return null;
+  const dir = join(root, 'test-diet', 'cards');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${line.at.slice(0, 10)}-${line.range.replace(/[^0-9a-z~#-]/gi, '')}.md`);
+  const rows = items.map((r) => `| \`${r.file}\` | ${r.verdict} | ${r.secs}s | ${r.rssMb ?? '?'} MB | ${r.caught90} | ${r.flags.join(', ') || '—'} | ${(r.reason ?? '').replace(/\|/g, '/')} |`);
+  writeFileSync(path, [
+    `# 시험 리뷰 초안 — ${line.range} (${line.at.slice(0, 10)})`,
+    '',
+    '> 초안이다. 아무것도 지우거나 옮기지 않았다. 사람이 읽고 정한다.',
+    '',
+    '| 파일 | 판정 | 단독 시간 | 피크 메모리 | 90일 fix 커밋 | 표지 | 실패 사유(첫 줄) |',
+    '|---|---|---|---|---|---|---|',
+    ...rows,
+    '',
+    `원장: ${line.results.length}개 중 ${items.length}개 · 측정 판 ${line.commit}`,
+    '',
+  ].join('\n'));
+  return path;
+}

package/scripts/test-diet/node.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+// TD2 graph nodes: pick → measure → record. Shadow only — measures alone on a remote host and drafts a card.
+//   bun scripts/test-diet/node.ts pick|measure|record   (inside `elanous graph run graphs/test-diet/test-diet.yaml`)
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { appendLedger, costTable, judge, lastLedgerLine, pickRange, writeCardDraft, type Measurement } from './lib.js';
+
+type Context = { input: Record<string, unknown>; outputs: Record<string, Record<string, unknown>> };
+function context(): Context {
+  const at = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!at) throw new Error('ELANOUS_GRAPH_CONTEXT required');
+  const raw = JSON.parse(at.trimStart().startsWith('{') ? at : readFileSync(at, 'utf8')) as Partial<Context>;
+  return { input: raw.input ?? {}, outputs: raw.outputs ?? {} };
+}
+function emit(result: Record<string, unknown> & { outcome: 'ok' | 'fail' | 'error'; summary: string }): number {
+  console.log(JSON.stringify({ verdict: result.outcome === 'ok' ? 'pass' : 'fail', ...result }));
+  return result.outcome === 'ok' ? 0 : result.outcome === 'fail' ? 1 : 2;
+}
+const git = (args: string[]) => spawnSync('git', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).stdout ?? '';
+
+function pick(ctx: Context): number {
+  const budgetSecs = typeof ctx.input.budgetSecs === 'number' && ctx.input.budgetSecs > 0 ? ctx.input.budgetSecs : 1800;
+  const files = git(['ls-files', '*.test.ts']).split('\n').filter(Boolean).sort();
+  const costs = costTable(readFileSync(join(process.cwd(), 'docs/measurements/td1-whole-gate-mechanical-2026-10-01.tsv'), 'utf8'));
+  const last = lastLedgerLine(effectiveInstanceRoot());
+  for (const r of last?.results ?? []) costs.set(r.file, r.secs);
+  // `start` re-looks a slice on purpose; otherwise continue from the ledger cursor.
+  const startAt = typeof ctx.input.start === 'number' && ctx.input.start >= 0 ? ctx.input.start : last?.next ?? 0;
+  const range = pickRange(files, startAt, costs, budgetSecs);
+  return emit({ outcome: 'ok', summary: `test-diet pick #${range.start}~#${range.end} of ${files.length} (≈${Math.round(range.estimatedSecs)}s)`, ...range, total: files.length, budgetSecs });
+}
+
+/** One remote run: shallow clone of the mirror, one install, each file alone with its peak memory. */
+function measure(ctx: Context): number {
+  const picked = ctx.outputs.pick?.files;
+  if (!Array.isArray(picked) || picked.length === 0) return emit({ outcome: 'fail', summary: 'nothing picked' });
+  const host = typeof ctx.input.remote === 'string' ? ctx.input.remote : 'node-b';
+  const mirror = typeof ctx.input.mirror === 'string' ? ctx.input.mirror : '~/mirror/elanous-agent.git';
+  const script = [
+    'set -u', 'export PATH="$HOME/.bun/bin:$PATH"',
+    'T=$(mktemp -d)', 'trap \'rm -rf "$T"\' EXIT',
+    `git clone -q --depth 1 "file://$(eval echo ${mirror})" "$T/repo" || exit 3`,
+    // Same installs as the gate: root and apps/pwa (PWA tests import its own dependencies).
+    'cd "$T/repo" && bun install --frozen-lockfile >/dev/null 2>&1 || exit 4',
+    '(cd apps/pwa && bun install --frozen-lockfile >/dev/null 2>&1) || echo "WARN pwa-install-failed"',
+    'echo "COMMIT $(git rev-parse HEAD)"',
+    'TO=$(command -v timeout || command -v gtimeout || true)',
+    'while IFS= read -r f; do',
+    '  [ -n "$f" ] || continue',
+    '  s=$(date +%s)',
+    '  if [ -n "$TO" ]; then /usr/bin/time -l "$TO" -k 10 300 bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else /usr/bin/time -l bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi',
+    '  rc=$?; e=$(( $(date +%s) - s ))',
+    '  rss=$(awk \'/maximum resident set size/ {printf "%d", $1/1048576}\' "$T/err")',
+    // bun test prints its summary on stderr — read both streams.
+    '  pass=$(cat "$T/out" "$T/err" | grep -E -o "^ *[0-9]+ pass" | grep -E -o "[0-9]+" | tail -1); fail=$(cat "$T/out" "$T/err" | grep -E -o "^ *[0-9]+ fail" | grep -E -o "[0-9]+" | tail -1)',
+    // A failing file names its first error, so an environment gap (e.g. no Java on the host) is not read as a test defect.
+    '  why=""; [ "$rc" -ne 0 ] && why=$(grep -v -E "^\\s*$|^bun test|^ *[0-9]+ \\||^error: *$" "$T/err" | grep -m1 -E "Unable to|Cannot find|not found|ENOENT|EACCES|rror" | tr "\\t" " " | cut -c1-160)',
+    '  printf "M\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n" "$f" "$e" "${rss:-}" "$rc" "${pass:-}" "${fail:-}" "$why"',
+    'done',
+  ].join('\n');
+  const run = spawnSync('ssh', ['-o', 'BatchMode=yes', host, 'bash', '-s'], { input: `${script}\n${picked.join('\n')}\n`, encoding: 'utf8', timeout: 4 * 3600_000, maxBuffer: 16 * 1024 * 1024 });
+  // The file list follows the script on stdin; `read` in the loop consumes it.
+  if (run.status !== 0 && !String(run.stdout).includes('\nM\t')) return emit({ outcome: 'error', summary: `remote measure failed (rc=${run.status}): ${String(run.stderr).trim().slice(0, 200)}` });
+  const commit = /^COMMIT (\w+)/m.exec(run.stdout)?.[1] ?? '?';
+  const measurements: Measurement[] = String(run.stdout).split('\n').filter((l) => l.startsWith('M\t')).map((l) => {
+    const [, file, secs, rss, rc, pass, fail, why] = l.split('\t');
+    const num = (v: string | undefined) => (v === undefined || v === '' ? null : Number(v));
+    return { file: file!, secs: Number(secs), rssMb: num(rss), rc: num(rc), pass: num(pass), fail: num(fail), ...(why ? { reason: why } : {}) };
+  });
+  return emit({ outcome: measurements.length ? 'ok' : 'error', summary: `measured ${measurements.length}/${picked.length} on ${host} at ${commit.slice(0, 9)}`, host, commit, measurements });
+}
+
+function record(ctx: Context): number {
+  const p = ctx.outputs.pick;
+  const m = ctx.outputs.measure;
+  const measurements = (m?.measurements ?? []) as Measurement[];
+  if (!p || measurements.length === 0) return emit({ outcome: 'fail', summary: 'nothing measured' });
+  const results = measurements.map((x) => judge(x, Number(git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length)));
+  const line = {
+    at: new Date().toISOString(), range: `#${p.start}~#${p.end}`, start: Number(p.start), end: Number(p.end), next: Number(p.next), total: Number(p.total),
+    commit: String(m?.commit ?? '?'), budgetSecs: Number(p.budgetSecs), results,
+  };
+  const root = effectiveInstanceRoot();
+  appendLedger(root, line);
+  const card = writeCardDraft(root, line);
+  const counts = { keep: results.filter((r) => r.verdict === 'keep').length, review: results.filter((r) => r.verdict === 'review').length, failing: results.filter((r) => r.verdict === 'failing').length };
+  debug.log('test-diet', 'recorded', { range: line.range, ...counts, card: card !== null });
+  return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}) });
+}
+
+if (import.meta.main) {
+  const step = process.argv[2];
+  try {
+    const ctx = context();
+    process.exitCode = step === 'pick' ? pick(ctx) : step === 'measure' ? measure(ctx) : step === 'record' ? record(ctx) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
+  } catch (error) {
+    process.exitCode = emit({ outcome: 'error', summary: error instanceof Error ? error.message : String(error) });
+  }
+}

package/src/acp/auth-methods.ts

@@ -0,0 +1,30 @@
+// EN10a — ACP auth methods: a client that runs terminals gets a `terminal` method (it re-launches `elanous --acp-server --login`);
+// an older client gets an agent method carrying Zed's `terminal-auth` meta, so «sign-in needed → run elanous login in a terminal» shows either way.
+import type { AuthMethod, ClientCapabilities } from '@agentclientprotocol/sdk';
+
+export const ACP_LOGIN_METHOD_ID = 'elanous-login';
+/** Appended to the configured agent invocation (`elanous --acp-server`) by a terminal-auth client. */
+export const ACP_LOGIN_ARG = '--login';
+/** What the login step runs (the ChatGPT/Codex subscription sign-in). */
+export const ACP_LOGIN_SUBCOMMAND = ['login', 'openai-codex'] as const;
+
+export interface AcpLaunch { command: string; args: string[] }
+
+/** How this process was started (bun + script, or a compiled binary) so a client can start the same thing. */
+export function currentLaunch(argv: readonly string[] = process.argv, execPath = process.execPath): AcpLaunch {
+  const script = argv[1];
+  return script && /\.(?:m?js|ts)$/.test(script) ? { command: execPath, args: [script] } : { command: execPath, args: [] };
+}
+
+export function acpAuthMethods(client: ClientCapabilities | null | undefined, launch: AcpLaunch = currentLaunch()): AuthMethod[] {
+  const name = 'Sign in to elanous';
+  if (client?.auth?.terminal === true) {
+    return [{ type: 'terminal', id: ACP_LOGIN_METHOD_ID, name, description: 'Opens a terminal to sign in with your ChatGPT (Codex) subscription', args: [ACP_LOGIN_ARG] }];
+  }
+  return [{
+    id: ACP_LOGIN_METHOD_ID,
+    name,
+    description: `Run \`elanous ${ACP_LOGIN_SUBCOMMAND.join(' ')}\` in a terminal, then try again`,
+    _meta: { 'terminal-auth': { command: launch.command, args: [...launch.args, ...ACP_LOGIN_SUBCOMMAND], label: 'elanous login' } },
+  }];
+}

package/src/acp/server.ts

@@ -26,6 +26,7 @@
 //
 // Related: src/acp/client.ts (elanous-as-client path — pre-MT5 work).
 
+import { ACP_LOGIN_METHOD_ID, acpAuthMethods } from './auth-methods.js';
 import { AgentSideConnection, ndJsonStream, RequestError } from '@agentclientprotocol/sdk';
 import type {
   InitializeRequest, InitializeResponse,
@@ -1415,14 +1416,13 @@ function wireAcpConnection(
         agentCapabilities: opts.agentBrand !== undefined && opts.agentModel !== undefined
           ? buildAgentDeclaration({ brand: opts.agentBrand, model: opts.agentModel })
           : buildAgentDeclaration(),
-        authMethods: [],
+        authMethods: acpAuthMethods(req.clientCapabilities),
       };
     },
 
-    async authenticate(_req: AuthenticateRequest): Promise<AuthenticateResponse> {
-      // No auth flow — we advertise authMethods: [] so the client
-      // shouldn't call this, but the Agent interface requires the
-      // method to be present.
+    async authenticate(req: AuthenticateRequest): Promise<AuthenticateResponse> {
+      // EN10a — sign-in happens in a terminal (`--acp-server --login`); this only acknowledges the method so the client retries.
+      debug.log('acp.session', 'authenticate', { methodId: req.methodId === ACP_LOGIN_METHOD_ID ? req.methodId : 'other' });
       return {};
     },
 

package/src/channel-import/detect.ts

@@ -0,0 +1,191 @@
+// EN13 — 셋업이 «이미 쓰던» 텔레그램·디스코드 설정을 찾아 온다(대표 10-01).
+// 출처: OpenClaw(~/.openclaw/openclaw.json · tokenFile) · Hermes(~/.hermes/.env) · 이전 엘라누스(~/.monad/config.json).
+// ⛔ 토큰 값은 이 모듈 밖으로 «문자열»로 나가지 않는다 — `BotToken` 이 감싸고, 문자열화·JSON·inspect 는 전부 가린다.
+//    값이 필요한 곳(저장·연결 확인)만 `reveal()` 을 부른다. 미리보기는 «있음 · 끝 4자리 가림»만 낸다.
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type ImportPlatform = 'telegram' | 'discord';
+export type ImportSource = 'openclaw' | 'hermes' | 'elanous-legacy';
+
+const MASK = '있음 · 끝 4자리 가림';
+
+/** A bot token that never prints itself. */
+export class BotToken {
+  readonly #value: string;
+  constructor(value: string) { this.#value = value; }
+  reveal(): string { return this.#value; }
+  /** Same-token check without exposing either value. */
+  fingerprint(): string { return createHash('sha256').update(this.#value).digest('hex').slice(0, 8); }
+  toString(): string { return MASK; }
+  toJSON(): string { return MASK; }
+  [Symbol.for('nodejs.util.inspect.custom')](): string { return MASK; }
+}
+
+export interface ImportCandidate {
+  platform: ImportPlatform;
+  source: ImportSource;
+  /** `~`-relative file the value came from. */
+  file: string;
+  token: BotToken;
+  allowedUsers: string[];
+  /** Allowlist entries we could not use (not a numeric Telegram id, etc.). */
+  droppedUsers: number;
+}
+
+export const SOURCE_LABEL: Record<ImportSource, string> = {
+  openclaw: 'OpenClaw', hermes: 'Hermes', 'elanous-legacy': '이전 엘라누스(~/.monad)',
+};
+
+function tilde(path: string, home: string): string { return path.startsWith(home) ? `~${path.slice(home.length)}` : path; }
+function obj(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+function text(value: unknown): string | null { return typeof value === 'string' && value.trim() ? value.trim() : null; }
+
+/** JSON with comments and trailing commas (openclaw.json is JSON5-ish). Strings are kept intact. */
+export function parseLooseJson(raw: string): unknown {
+  try { return JSON.parse(raw); } catch { /* fall through */ }
+  let out = '';
+  let inString = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i]!;
+    if (inString) {
+      out += ch;
+      if (ch === '\\') { out += raw[++i] ?? ''; continue; }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') { inString = true; out += ch; continue; }
+    if (ch === '/' && raw[i + 1] === '/') { while (i < raw.length && raw[i] !== '\n') i++; out += '\n'; continue; }
+    if (ch === '/' && raw[i + 1] === '*') { i += 2; while (i < raw.length && !(raw[i] === '*' && raw[i + 1] === '/')) i++; i++; continue; }
+    out += ch;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'));
+}
+
+/** `KEY=value` lines (quotes and `export ` allowed, `#` comments ignored). */
+export function parseDotEnv(raw: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/.exec(line);
+    if (!m) continue;
+    let value = m[2]!;
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+    else value = value.replace(/\s+#.*$/, '');
+    out[m[1]!] = value.trim();
+  }
+  return out;
+}
+
+/** Telegram allowlists must be numeric user ids; `telegram:123` / `tg:123` prefixes are accepted. */
+export function normalizeUsers(platform: ImportPlatform, raw: unknown): { users: string[]; dropped: number } {
+  const list = Array.isArray(raw) ? raw : typeof raw === 'string' ? raw.split(',') : [];
+  const users: string[] = [];
+  let dropped = 0;
+  for (const entry of list) {
+    const value = String(entry).trim().replace(/^(?:telegram|tg|discord|user):/i, '');
+    if (!value || value === '*') { if (value === '*') dropped++; continue; }
+    const ok = platform === 'telegram' ? /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) && Number(value) > 0 : /^\d{5,}$/.test(value);
+    if (ok && !users.includes(value)) users.push(value); else if (!ok) dropped++;
+  }
+  return { users, dropped };
+}
+
+function readRegularFile(path: string): string | null {
+  try { return lstatSync(path).isFile() ? readFileSync(path, 'utf8').trim() || null : null; } catch { return null; }
+}
+
+function candidate(platform: ImportPlatform, source: ImportSource, file: string, token: string | null, users: unknown): ImportCandidate | null {
+  if (!token) return null;
+  const { users: allowedUsers, dropped } = normalizeUsers(platform, users);
+  return { platform, source, file, token: new BotToken(token), allowedUsers, droppedUsers: dropped };
+}
+
+function fromOpenClaw(home: string): ImportCandidate[] {
+  const path = join(home, '.openclaw', 'openclaw.json');
+  if (!existsSync(path)) return [];
+  const cfg = obj(parseLooseJson(readFileSync(path, 'utf8')));
+  const channels = obj(cfg?.channels);
+  const file = tilde(path, home);
+  const out: ImportCandidate[] = [];
+  const telegram = obj(channels?.telegram);
+  if (telegram) {
+    const firstAccount = obj(Object.values(obj(telegram.accounts) ?? {})[0]);
+    const token = text(telegram.botToken) ?? (text(telegram.tokenFile) ? readRegularFile(text(telegram.tokenFile)!.replace(/^~(?=\/)/, home)) : null)
+      ?? text(firstAccount?.botToken);
+    const c = candidate('telegram', 'openclaw', file, token, telegram.allowFrom ?? firstAccount?.allowFrom);
+    if (c) out.push(c);
+  }
+  const discord = obj(channels?.discord);
+  if (discord) {
+    const firstAccount = obj(Object.values(obj(discord.accounts) ?? {})[0]);
+    const c = candidate('discord', 'openclaw', file, text(discord.token) ?? text(firstAccount?.token), discord.allowFrom ?? obj(discord.dm)?.allowFrom);
+    if (c) out.push(c);
+  }
+  return out;
+}
+
+function fromHermes(home: string): ImportCandidate[] {
+  const path = join(home, '.hermes', '.env');
+  if (!existsSync(path)) return [];
+  const env = parseDotEnv(readFileSync(path, 'utf8'));
+  const file = tilde(path, home);
+  return [
+    candidate('telegram', 'hermes', file, text(env.TELEGRAM_BOT_TOKEN), env.TELEGRAM_ALLOWED_USERS),
+    candidate('discord', 'hermes', file, text(env.DISCORD_BOT_TOKEN), env.DISCORD_ALLOWED_USERS),
+  ].filter((c): c is ImportCandidate => c !== null);
+}
+
+function fromElanousLegacy(home: string): ImportCandidate[] {
+  const path = join(home, '.monad', 'config.json');
+  if (!existsSync(path)) return [];
+  const cfg = obj(parseLooseJson(readFileSync(path, 'utf8')));
+  const file = tilde(path, home);
+  return (['telegram', 'discord'] as const)
+    .map((platform) => candidate(platform, 'elanous-legacy', file, text(obj(cfg?.[platform])?.botToken), obj(cfg?.[platform])?.allowedUsers))
+    .filter((c): c is ImportCandidate => c !== null);
+}
+
+export interface DetectResult { candidates: ImportCandidate[]; unreadable: { file: string; reason: string }[] }
+
+/** Look in every known place; a broken file is reported by name (never by content) and the rest still count. */
+export function detectChannelImports(home = homedir()): DetectResult {
+  const candidates: ImportCandidate[] = [];
+  const unreadable: DetectResult['unreadable'] = [];
+  const readers: [string, (h: string) => ImportCandidate[]][] = [
+    [join(home, '.monad', 'config.json'), fromElanousLegacy],
+    [join(home, '.openclaw', 'openclaw.json'), fromOpenClaw],
+    [join(home, '.hermes', '.env'), fromHermes],
+  ];
+  for (const [path, read] of readers) {
+    try { candidates.push(...read(home)); }
+    catch (error) {
+      // JSON parse errors can quote the offending text — keep only the error class.
+      unreadable.push({ file: tilde(path, home), reason: error instanceof SyntaxError ? '형식을 읽지 못했습니다' : '읽지 못했습니다' });
+    }
+  }
+  return { candidates, unreadable };
+}
+
+/** One per platform: the first source in priority order; the rest are named as «다른 토큰도 있음». */
+export function pickPerPlatform(candidates: readonly ImportCandidate[]): { chosen: ImportCandidate[]; others: ImportCandidate[] } {
+  const chosen: ImportCandidate[] = [];
+  const others: ImportCandidate[] = [];
+  for (const c of candidates) {
+    const first = chosen.find((x) => x.platform === c.platform);
+    if (!first) chosen.push(c);
+    else if (first.token.fingerprint() !== c.token.fingerprint()) others.push(c);
+    else for (const user of c.allowedUsers) if (!first.allowedUsers.includes(user)) first.allowedUsers.push(user);
+  }
+  return { chosen, others };
+}
+
+export function previewLine(c: ImportCandidate): string {
+  const name = c.platform === 'telegram' ? '텔레그램' : '디스코드';
+  const users = c.allowedUsers.length ? `허용 사용자 ${c.allowedUsers.length}명` : '허용 사용자 없음(나중에 정해야 합니다)';
+  const dropped = c.droppedUsers ? ` · 쓸 수 없는 항목 ${c.droppedUsers}개 제외` : '';
+  return `${name} ← ${SOURCE_LABEL[c.source]} (${c.file}): 토큰 ${MASK} · ${users}${dropped}`;
+}

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/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('결정 목록 (기본 열린 것)')