elanous 0.2.14 → 0.2.15

package/src/briefing/brief-items.ts

@@ -0,0 +1,121 @@
+import { Database } from 'bun:sqlite';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+
+export type BriefPriority = 'high' | 'medium' | 'low';
+
+export interface BriefItem {
+  id: number;
+  text: string;
+  domain: string;
+  priority: BriefPriority;
+  deadline: string | null;
+  evidence: string | null;
+  source: string;
+  created_at: string;
+}
+
+export interface AddBriefItem {
+  text: string;
+  domain: string;
+  priority: BriefPriority;
+  deadline?: string | null;
+  evidence?: string | null;
+  source: string;
+}
+
+export interface BriefItemsOptions {
+  stateDir?: string;
+  now?: () => Date;
+}
+
+export class BriefItemsInputError extends Error {
+  override name = 'BriefItemsInputError';
+}
+
+function required(value: string, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new BriefItemsInputError(`${field} is required`);
+  return value;
+}
+
+function optional(value: string | null | undefined, field: string): string | null {
+  return value == null ? null : required(value, field);
+}
+
+/** Append-only item ledger. All three operations open the same instance-scoped SQLite file. */
+export class BriefItemsLedger {
+  readonly path: string;
+  private readonly now: () => Date;
+
+  constructor(options: BriefItemsOptions = {}) {
+    this.path = join(options.stateDir ?? elanousStateRoot(), 'briefing', 'items.sqlite');
+    this.now = options.now ?? (() => new Date());
+  }
+
+  private using<T>(work: (db: Database) => T): T {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const db = new Database(this.path, { create: true, strict: true });
+    try {
+      chmodSync(this.path, 0o600);
+      db.exec('PRAGMA busy_timeout = 10000');
+      db.exec(`CREATE TABLE IF NOT EXISTS items (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        text TEXT NOT NULL, domain TEXT NOT NULL,
+        priority TEXT NOT NULL CHECK(priority IN ('high', 'medium', 'low')),
+        deadline TEXT, evidence TEXT, source TEXT NOT NULL, created_at TEXT NOT NULL
+      );
+      CREATE TRIGGER IF NOT EXISTS items_no_update BEFORE UPDATE ON items
+        BEGIN SELECT RAISE(ABORT, 'brief items are immutable'); END;
+      CREATE TRIGGER IF NOT EXISTS items_no_delete BEFORE DELETE ON items
+        BEGIN SELECT RAISE(ABORT, 'brief items are immutable'); END;`);
+      return work(db);
+    } finally {
+      db.close();
+    }
+  }
+
+  add(input: AddBriefItem): BriefItem {
+    const text = required(input.text, 'text');
+    const domain = required(input.domain, 'domain');
+    const source = required(input.source, 'source');
+    if (!['high', 'medium', 'low'].includes(input.priority)) throw new BriefItemsInputError('invalid priority');
+    const deadline = optional(input.deadline, 'deadline');
+    if (deadline !== null) {
+      const format = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?$/;
+      if (!format.test(deadline) || !Number.isFinite(Date.parse(deadline))) throw new BriefItemsInputError('invalid deadline');
+    }
+    const evidence = optional(input.evidence, 'evidence');
+    return this.using(db => {
+      const createdAt = this.now().toISOString();
+      const result = db.query('INSERT INTO items (text, domain, priority, deadline, evidence, source, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+        .run(text, domain, input.priority, deadline, evidence, source, createdAt);
+      return db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items WHERE id = ?')
+        .get(result.lastInsertRowid) as BriefItem;
+    });
+  }
+
+  /** Higher priorities first, then nearest deadline by instant, then insertion order. */
+  list(filters: { domain?: string } = {}): BriefItem[] {
+    const items = this.using(db => (filters.domain === undefined
+      ? db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items').all()
+      : db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at FROM items WHERE domain = ?').all(filters.domain)) as BriefItem[]);
+    const rank: Record<BriefPriority, number> = { high: 0, medium: 1, low: 2 };
+    return items.sort((a, b) => rank[a.priority] - rank[b.priority]
+      || Number(a.deadline === null) - Number(b.deadline === null)
+      || (a.deadline !== null && b.deadline !== null ? Date.parse(a.deadline) - Date.parse(b.deadline) : 0)
+      || a.id - b.id);
+  }
+
+  /** Pure Markdown output: composing never marks, alters, or sends stored items. */
+  compose(slot: string, filters: { domain?: string } = {}): string {
+    required(slot, 'slot');
+    const items = this.list(filters);
+    const lines = [`# Briefing — ${slot}`, ''];
+    for (const item of items) {
+      lines.push(`- [${item.priority}] ${item.text} (${item.domain})`);
+      lines.push(`  - Source: ${item.source}${item.deadline ? ` · Deadline: ${item.deadline}` : ''}${item.evidence ? ` · Evidence: ${item.evidence}` : ''}`);
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+  }
+}

package/src/claims/claims-render.ts

@@ -2,7 +2,7 @@ import { Database } from 'bun:sqlite';
 import { appendFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { checkBrand } from '../../scripts/brand/check.js';
+import { BRAND_RULES_UNMEASURED, checkBrand } from '../../scripts/brand/check.js';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { ClaimsLedger, ClaimEvidence } from './claims-ledger.js';
@@ -11,7 +11,8 @@ export type ClaimSurface = 'deck' | 'site' | 'notice';
 export interface RenderedClaims {
   markdown: string;
   included: string[];
-  excluded: Array<{ id: string; reason: 'stale' | 'not-public' | 'retracted' | 'expired' | 'brand' | 'ambiguous-value' }>;
+  excluded: Array<{ id: string; reason: 'stale' | 'not-public' | 'retracted' | 'expired' | 'brand' | 'ambiguous-value' | 'rules-missing' }>;
+  unmeasured?: string;
 }
 
 const headings: Record<ClaimSurface, string> = {
@@ -48,7 +49,7 @@ export function representativeNumber(value: string): string | undefined {
   return matches[0];
 }
 
-export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurface; audience?: string }): RenderedClaims {
+export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurface; audience?: string; rulesPath?: string }): RenderedClaims {
   const { surface, audience } = options;
   if (!(surface in headings)) throw new Error(`invalid claims surface: ${surface}`);
   const excluded: RenderedClaims['excluded'] = [];
@@ -82,13 +83,21 @@ export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurf
     candidates.push({ id: row.id, line: `- ${claim} — ${number} <!-- claim:${row.id} measured:${evidence.measured_at} cmd:${commentValue(evidence.command)}${evidence.source ? ` source:${commentValue(evidence.source)}` : ''} --> <!-- src:${commentValue(evidence.source ?? evidence.command)} -->` });
   }
 
+  const rulesMissing = checkBrand(scopes[surface], [], options.rulesPath).missing;
+  if (rulesMissing) {
+    excluded.push(...candidates.map(({ id }) => ({ id, reason: 'rules-missing' as const })));
+    const result: RenderedClaims = { markdown: `${headings[surface]}\n\n> ⚠ ${BRAND_RULES_UNMEASURED}\n`, included: [], excluded, unmeasured: BRAND_RULES_UNMEASURED };
+    debug.log('claims.render', 'rendered', { surface, included: result.included, excluded, unmeasured: result.unmeasured });
+    return result;
+  }
+
   const temp = mkdtempSync(join(tmpdir(), 'claims-render-'));
   const file = join(temp, 'claims.md');
   try {
     const probe = (items: typeof candidates): Set<string> => {
       writeFileSync(file, [headings[surface], '', ...items.map(item => item.line)].join('\n').trimEnd() + '\n');
-      const result = checkBrand(scopes[surface], [file]);
-      if (result.missing) throw new Error('brand rules missing');
+      const result = checkBrand(scopes[surface], [file], options.rulesPath);
+      if (result.missing) throw new Error(BRAND_RULES_UNMEASURED);
       const bad = new Set<string>();
       for (const finding of result.findings) {
         const owner = items[finding.line - 3];

package/src/cli/agent-env-cli.ts

@@ -0,0 +1,21 @@
+import type { Command } from 'commander';
+import { writeFileSync } from 'node:fs';
+import { captureAgentEnv } from '../agent-env/profile.js';
+
+export function registerAgentEnvCommands(program: Command): void {
+  const agentEnv = program.command('agent-env').description('에이전트 CLI 환경의 비밀 없는 프로필');
+  agentEnv.command('capture').description('로컬 Claude · Codex · Grok 설정을 읽기 전용으로 캡처')
+    .option('--agent <agent>', 'claude|codex|grok')
+    .option('--out <file>', '프로필을 저장할 파일')
+    .option('--json', 'JSON 출력')
+    .action((opts: { agent?: string; out?: string; json?: boolean }) => {
+      if (opts.agent && !['claude', 'codex', 'grok'].includes(opts.agent)) {
+        throw new Error('--agent must be claude, codex or grok');
+      }
+      const profile = captureAgentEnv({ agent: opts.agent as 'claude' | 'codex' | 'grok' | undefined });
+      const text = JSON.stringify(profile, null, 2) + '\n';
+      if (opts.out) writeFileSync(opts.out, text, { encoding: 'utf8', mode: 0o600 });
+      if (opts.json || !opts.out) process.stdout.write(text);
+      else console.log(`agent-env capture · ${opts.out}`);
+    });
+}

package/src/cli/decisions-cli.ts

@@ -10,6 +10,7 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig } from '../user-config.js';
 import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry, type Seat, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
+import { formatProactMeter, readProactMeter } from '../decisions/proact-meter.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
 function date(raw?: string): string | undefined {
@@ -137,6 +138,14 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       const rows = new DecisionLedger(config).seatReport({ since: date(o.since), seat: o.seat });
       emit(rows, o.json, rows.length ? rows.map(formatSeatDecisionRow).join('\n') : '자리 결정 0건');
     }));
+  root.command('proact').description('선제성 기준선 — 지난 7일, 먼저 낸 수·채택 수·물어서야 드러난 수')
+    .option('--days <n>', 'KST 일수 (기본 7)', '7').option('--json')
+    .action((o: { days: string; json?: boolean }) => fail(() => {
+      const days = Number(o.days);
+      if (!Number.isInteger(days) || days < 1) throw new Error('invalid days');
+      const meter = readProactMeter({ ...(config.stateDir ? { stateDir: config.stateDir, instanceRoot: config.stateDir } : {}), ...(config.now ? { now: config.now() } : {}), days });
+      emit(meter, o.json, formatProactMeter(meter));
+    }));
   root.command('list').description('결정 목록 (기본 열린 것)')
     .option('--status <open|decided|all>', '기본 open', 'open').option('--since <date>').option('--version <version>')
     .option('--decided-by <human|auto>').option('--category <category>').option('--json')

package/src/cli/doctor-cli.ts

@@ -39,6 +39,7 @@ import { formatDoctorLocalLlm, probeDoctorLocalLlm, type DoctorLocalLlm } from '
 import type { LlmInventory } from '../llm/local-manager/types.js';
 import { buildDoctorBundle } from './doctor-bundle.js';
 import { uploadDoctorBundle } from './doctor-bundle-upload.js';
+import { checkNodeModules, formatNodeModulesCheck, nodeModulesTrees } from './doctor-node-modules.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -1216,9 +1217,30 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
   const out = deps.out ?? { log: (value: string) => console.log(value) };
   const err = deps.err ?? { error: (value: string) => console.error(value) };
   const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
-  program.command('doctor')
+  const doctor = program.command('doctor')
     .description('Reports whether credentials resolve and where each resolution comes from')
+    .option('--json', 'structured output');
+  doctor.command('node-modules')
+    .description('Check installed top-level packages against bun.lock (read-only)')
+    .option('--dir <tree>', 'tree to check', process.cwd())
+    .option('--all', 'also check nested package.json trees')
     .option('--json', 'structured output')
+    .action((opts: { dir: string; all?: boolean; json?: boolean }, command: Command) => {
+      const json = opts.json || command.parent?.opts().json === true;
+      let dirs: string[];
+      try { dirs = opts.all ? nodeModulesTrees(opts.dir) : [resolve(opts.dir)]; }
+      catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        if (json) out.log(JSON.stringify({ status: 'unreadable', reason }));
+        else out.log(`unreadable: ${reason}`);
+        setExitCode(1);
+        return;
+      }
+      const checks = dirs.map(checkNodeModules);
+      out.log(json ? JSON.stringify(opts.all ? checks : checks[0], null, 2) : checks.map(formatNodeModulesCheck).join('\n'));
+      if (checks.some((check) => check.status !== 'ok')) setExitCode(1);
+    });
+  doctor
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')
     .option('--upload', 'send the bundle to diagnostics.uploadUrl after consent (requires --bundle)')

package/src/cli/doctor-node-modules.ts

@@ -0,0 +1,147 @@
+import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface NodeModulesCheck {
+  dir: string;
+  status: 'ok' | 'issues' | 'unreadable';
+  missing: string[];
+  mismatch: { name: string; expected: string; actual: string }[];
+  borrowed: { target: string; tree: string } | null;
+  reason?: string;
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function loadJson(path: string): unknown {
+  return JSON.parse(readFileSync(path, 'utf8')) as unknown;
+}
+
+function dependencyNames(pkg: Record<string, unknown>): string[] {
+  if (!record(pkg.dependencies ?? {}) || !record(pkg.devDependencies ?? {})) throw new Error('invalid package.json dependencies');
+  return [...new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})])].sort();
+}
+
+interface LockContext { lockRoot: string; workspace: Record<string, unknown>; packages: Record<string, unknown>; scope: string | null }
+
+/** Own bun.lock first; otherwise the nearest ancestor bun.lock whose workspaces list this folder (root-lock Bun workspaces). */
+function findLock(root: string, packageName: string | null): LockContext {
+  let current = root;
+  for (;;) {
+    let text: string | null = null;
+    try { text = readFileSync(join(current, 'bun.lock'), 'utf8'); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    if (text !== null) {
+      const lock = Bun.JSONC.parse(text) as unknown;
+      if (!record(lock) || !record(lock.packages) || !record(lock.workspaces)) throw new Error('invalid bun.lock');
+      const key = relative(current, root).split(sep).join('/');
+      const workspace = lock.workspaces[key];
+      if (record(workspace)) return { lockRoot: current, workspace, packages: lock.packages, scope: key === '' ? null : (packageName ?? key) };
+      if (key === '') throw new Error('invalid bun.lock');
+      throw new Error(`bun.lock at ${current} does not list workspace ${key}`);
+    }
+    const parent = dirname(current);
+    if (parent === current) throw new Error('no bun.lock in this folder or any parent workspace root');
+    current = parent;
+  }
+}
+
+function lockedVersion(packages: Record<string, unknown>, name: string, scope: string | null = null): string {
+  // Bun keys a workspace-specific resolution as «<workspace>/<dep>» when it differs from the hoisted one.
+  const scoped = scope ? packages[`${scope}/${name}`] : undefined;
+  const entry = Array.isArray(scoped) ? scoped : packages[name];
+  if (!Array.isArray(entry) || typeof entry[0] !== 'string' || !entry[0].startsWith(`${name}@`) || entry[0].length <= name.length + 1) {
+    throw new Error(`bun.lock has no resolved version for ${name}`);
+  }
+  return entry[0].slice(name.length + 1);
+}
+
+export function checkNodeModules(dir: string): NodeModulesCheck {
+  const root = resolve(dir);
+  const result: NodeModulesCheck = { dir: root, status: 'ok', missing: [], mismatch: [], borrowed: null };
+  try {
+    const pkg = loadJson(join(root, 'package.json'));
+    if (!record(pkg)) throw new Error('invalid package.json');
+    const names = dependencyNames(pkg);
+    const lock = findLock(root, typeof pkg.name === 'string' ? pkg.name : null);
+    const declared = dependencyNames(lock.workspace);
+    for (const name of names) {
+      if (!declared.includes(name)) throw new Error(`bun.lock does not declare ${name}`);
+    }
+    const versions = new Map(names.map((name) => [name, lockedVersion(lock.packages, name, lock.scope)]));
+    // A workspace without its own node_modules resolves hoisted packages from the lock root.
+    const own = join(root, 'node_modules');
+    const modules = lock.lockRoot !== root && !lstatSync(own, { throwIfNoEntry: false }) ? join(lock.lockRoot, 'node_modules') : own;
+    try {
+      const entry = lstatSync(modules);
+      if (entry.isSymbolicLink()) {
+        const target = realpathSync(modules);
+        if (!lstatSync(target).isDirectory()) throw new Error('node_modules symlink target is not a directory');
+        result.borrowed = { target, tree: dirname(target) };
+      } else if (!entry.isDirectory()) {
+        throw new Error('node_modules is not a directory');
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      // A dangling symlink has a different cause from an absent node_modules directory.
+      if (lstatSync(modules, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('node_modules symlink target is missing');
+      result.missing.push(...names);
+      if (names.length) result.status = 'issues';
+      return result;
+    }
+    for (const name of names) {
+      let installed: unknown;
+      const candidates = [...new Set([modules, join(lock.lockRoot, 'node_modules')])];
+      for (const base of candidates) {
+        try {
+          installed = loadJson(join(base, name, 'package.json'));
+          break;
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        }
+      }
+      if (installed === undefined) {
+        result.missing.push(name);
+        continue;
+      }
+      if (!record(installed) || typeof installed.version !== 'string') throw new Error(`invalid node_modules/${name}/package.json`);
+      const expected = versions.get(name)!;
+      if (installed.version !== expected) result.mismatch.push({ name, expected, actual: installed.version });
+    }
+    if (result.missing.length || result.mismatch.length) result.status = 'issues';
+  } catch (error) {
+    result.status = 'unreadable';
+    result.reason = error instanceof Error ? error.message : String(error);
+  } finally {
+    debug.log('doctor.node-modules', 'checked', { dir: root, missing: result.missing, mismatch: result.mismatch, borrowed: result.borrowed });
+  }
+  return result;
+}
+
+export function nodeModulesTrees(dir: string): string[] {
+  const root = resolve(dir);
+  const found = [root];
+  const skip = new Set(['node_modules', '.git', '.next', 'dist', 'build', 'out', '.elanous-test']);
+  function visit(current: string): void {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (!entry.isDirectory() || skip.has(entry.name) || entry.name.startsWith('.')) continue;
+      const child = join(current, entry.name);
+      const children = readdirSync(child);
+      if (children.includes('package.json')) found.push(child);
+      visit(child);
+    }
+  }
+  visit(root);
+  return found;
+}
+
+export function formatNodeModulesCheck(result: NodeModulesCheck): string {
+  const lines = [`${result.dir}: ${result.status === 'ok' ? '정상' : result.status === 'unreadable' ? '못 읽음' : '결손'}`];
+  if (result.borrowed) lines.push(`  빌린 트리: ${result.borrowed.tree} (node_modules → ${result.borrowed.target})`);
+  if (result.missing.length) lines.push(`  빠짐 ${result.missing.length}: ${result.missing.join(', ')}`);
+  if (result.mismatch.length) lines.push(`  버전 다름 ${result.mismatch.length}: ${result.mismatch.map(({ name, expected, actual }) => `${name} (${actual} != ${expected})`).join(', ')}`);
+  if (result.reason) lines.push(`  이유: ${result.reason}`);
+  return lines.join('\n');
+}

package/src/cli/intake-cli.ts

@@ -21,6 +21,13 @@ export interface IntakeToTasksCliDeps {
   llm?: (input: IntakeTaskInput) => Promise<string>;
 }
 
+export interface IntakeDigestCliDeps {
+  root?: string;
+  annotateLens?: (root: string, day: string) => Promise<unknown>;
+  buildDigest?: typeof import('../intake-plane/digest.js').buildIntakeDigest;
+  sendTelegram?: (text: string) => Promise<boolean>;
+}
+
 export function intakeToTasksMessages(content: string) {
   return [
     { role: 'system' as const, content: 'Interpret the supplied goal line or idea note into up to three actionable tasks. Respond only with JSON: {"tasks":[{"type":"implement|research|document|operate","title":"...","description":"...","priority":"low|medium|high","acceptanceCriteria":["..."]}],"questions":["..."]}. Each task needs a verifiable acceptance criterion; put unresolved requests in questions instead. Do not invent facts. Limit each title to 80 characters and description to 4000 characters.' },
@@ -76,6 +83,44 @@ export async function runIntakeToTasksCli(
   return runIntakeToTasks(deps.root, opts, { llm, post });
 }
 
+/** `--telegram` 다이제스트. 렌즈는 digest 를 만들기 전에 돈다. 렌즈 실패는 보고를 막지 않는다. */
+export async function runIntakeDigestCli(
+  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string },
+  deps: IntakeDigestCliDeps = {},
+): Promise<{ sent?: boolean; empty?: boolean }> {
+  const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
+  const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+  const root = deps.root ?? effectiveInstanceRoot();
+  const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
+  if (opts.telegram) {
+    const annotate = deps.annotateLens ?? (async (lensRoot, lensDay) => {
+      const { annotateIntakeLens } = await import('../intake-plane/lens.js');
+      return annotateIntakeLens(lensRoot, lensDay);
+    });
+    try { await annotate(root, day); }
+    catch (error) { debug.log('intake.lens', 'annotate-failed', { day, reason: error instanceof Error ? error.message : String(error) }); }
+  }
+  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
+  if (opts.telegram) {
+    if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
+    const sent = deps.sendTelegram
+      ? await deps.sendTelegram(text)
+      : await (async () => {
+        const { sendTelegramReport } = await import('../telegram-report.js');
+        const { getUserConfig } = await import('../user-config.js');
+        return sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
+      })();
+    debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
+    console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
+    if (!sent) process.exitCode = 3;
+    return { sent };
+  }
+  if (opts.json) { await writeStdoutFully(JSON.stringify(d, null, 2)); return {}; }
+  await writeStdoutFully(renderDigestMarkdown(d));
+  return {};
+}
+
 export function resolveIntakeCheckRoot(
   cwd: string,
   git: typeof runGitCommand = runGitCommand,
@@ -283,23 +328,7 @@ export function registerIntakeCommands(program: Command): void {
     .option('--vault <root>', '옵시디언 볼트 뿌리 — 텔레그램 판에 노트 열기 주소를 싣는다')
     .option('--note <path>', '열기 주소가 가리킬 노트(그날 트렌드 노트)')
     .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string }) => {
-      const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
-      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
-      const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
-      const d = buildIntakeDigest(effectiveInstanceRoot(), day);
-      if (opts.telegram) {
-        if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return; }
-        const { sendTelegramReport } = await import('../telegram-report.js');
-        const { getUserConfig } = await import('../user-config.js');
-        const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
-        const sent = await sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
-        debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
-        console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
-        if (!sent) process.exitCode = 3;
-        return;
-      }
-      if (opts.json) { await writeStdoutFully(JSON.stringify(d, null, 2)); return; }
-      await writeStdoutFully(renderDigestMarkdown(d));
+      await runIntakeDigestCli(opts);
     });
 
   intakeCmd

package/src/cli/pod-cli.ts

@@ -94,6 +94,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
             const mem = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
             io.log(`${m.context} | ${m.capacity} | ${m.running ?? '?'} | ${m.pending ?? '?'} | ${mem(m.memoryLimitBytes)}/${mem(m.allocatableMemoryBytes)} | ${m.allocatableCpuMillicores === null ? '?' : m.allocatableCpuMillicores / 1000}${m.reason ? ` (${m.reason})` : ''}`);
           }
+          io.log(`실측 점유: ${measure.members.map((m) => `${m.context} ${m.running === null || m.pending === null ? '못 쟀다' : m.running + m.pending}/${m.capacity}`).join(' · ') || '?'}`);
           io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
@@ -155,6 +156,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         });
         if (result.image) io.error(`[pod] image ${result.image} · job ${result.job}`);
         io.log(result.artifactsDir);
+        if (result.artifacts?.error) io.error(`산출 회수 못 함: ${result.artifacts.error}`);
         io.exit(result.exitCode);
       } catch (err) {
         io.error(err instanceof Error ? err.message : String(err));