elanous 0.2.24 → 0.2.25

package/src/budget/unified-usage.ts

@@ -3,9 +3,12 @@
 // Codex: enumerate known account names, fetch each via the existing
 // ProviderFetcher with CODEX_HOME on the child env only.
 // Grok: this wiring has no multi-account list — 0 or 1 current-credential row.
-// Claude / Gemini are intentionally out of this landing.
+// Claude Code (2026-10-11 CLAUDE-USAGE-WINDOW): subscription row — 5-hour window
+// (credits axis) + 7-day window (subscription axis), from the OAuth usage endpoint.
+// Gemini is intentionally out of this landing.
 
 import { createCodexFetcher, type CodexFetcherOpts } from './fetchers/codex.js';
+import { createClaudeFetcher, resolveClaudeAccessToken } from './fetchers/claude.js';
 import {
   fetchGrokUsage,
   GROK_SUBSCRIPTION_AXIS,
@@ -20,6 +23,7 @@ import { loadTokens } from '../oauth/store.js';
 import { envLiteral } from '../platform/env-literal.js';
 import { describeResetCreditExpiry } from './codex-reset-credit-state.js';
 import { visibleWidth } from '../tui.js';
+import { debug } from '../debug/log.js';
 import { listCodexResetCredits, type CodexResetCreditsResult } from './codex-reset-credits.js';
 import {
   buildZaiUsageView, fetchZaiQuota, getZaiApiKey, readZaiLedger,
@@ -28,6 +32,7 @@ import {
 import type {
   AccountUsageRow,
   CreditAxis,
+  RateWindow,
   ResetCreditExpiryAxis,
   SubscriptionAxis,
   UnifiedUsageReport,
@@ -59,25 +64,179 @@ export interface UnifiedUsageDeps {
   readonly zaiKey?: () => string | undefined;
   readonly fetchZaiQuota?: () => Promise<ZaiQuotaResult>;
   readonly readZaiLedger?: () => ZaiLedgerRecord[];
+  /** Claude Code OAuth 토큰 해석 심 — 없으면 조회를 안 탄다(토큰 없음 = 행 없음). */
+  readonly resolveClaudeToken?: () => string | null;
+  /** Claude 사용량 조회 심 — `createClaudeFetcher().fetch()` 모양. */
+  readonly fetchClaude?: () => Promise<UsageSnapshot>;
+  /** 캐시 «아래»의 원 조회 심 — 주면 15분/5분 캐시를 거친다(`fetchClaude` 는 캐시를 우회한다). */
+  readonly fetchClaudeUncached?: () => Promise<UsageSnapshot>;
+}
+
+/** 공급자별 실패 격리(2026-10-11) — collector 가 «try 밖에서» 던지면 그 공급자만 한 error 행으로 바꾼다.
+ *  ⛔ 종전 `Promise.all` 은 한 공급자의 예외(예: 키 조회 seam throw)가 usage «전체» 를 죽였다.
+ *    `allSettled` 로 바꾸고 rejected 는 여기서 한 행으로 접는다 — 다른 공급자 행은 그대로 산다. */
+type ZaiOutcome = { rows: AccountUsageRow[]; view: ZaiUsageView };
+
+function isolateProviderRows(
+  provider: AccountUsageRow['provider'],
+  settled: PromiseSettledResult<AccountUsageRow[] | ZaiOutcome | null>,
+): { rows: AccountUsageRow[]; zai: ZaiOutcome | null } {
+  if (settled.status === 'fulfilled') {
+    const value = settled.value;
+    if (value === null) return { rows: [], zai: null };
+    if (Array.isArray(value)) return { rows: value, zai: null };
+    return { rows: value.rows, zai: value };
+  }
+  const detail = settled.reason instanceof Error ? settled.reason.message : String(settled.reason);
+  debug.log('usage', 'provider-failed', { provider, detail });
+  return {
+    rows: [{
+      provider,
+      accountName: 'default',
+      accountCount: 1,
+      soleAccount: true,
+      credits: { status: 'error', detail },
+      subscription: { status: 'unavailable', reason: 'query-does-not-supply' },
+      resetCredits: { status: 'unavailable', detail },
+    }],
+    zai: null,
+  };
 }
 
 export async function collectUnifiedUsage(deps: UnifiedUsageDeps = {}): Promise<UnifiedUsageReport> {
-  const [codexRows, grokRows, openRouterRows, zai] = await Promise.all([
+  const [codexSettled, claudeSettled, grokSettled, openRouterSettled, zaiSettled] = await Promise.allSettled([
     collectCodexRows(deps),
+    collectClaudeRows(deps),
     collectGrokRows(deps),
     collectOpenRouterRows(deps),
     collectZaiRows(deps),
   ]);
+  const codex = isolateProviderRows('codex', codexSettled);
+  const claude = isolateProviderRows('claude', claudeSettled);
+  const grok = isolateProviderRows('grok', grokSettled);
+  const openRouter = isolateProviderRows('openrouter', openRouterSettled);
+  const zai = isolateProviderRows('zai', zaiSettled);
+  const zaiRows = zai.zai?.rows ?? zai.rows;
   return {
-    rows: [...codexRows, ...grokRows, ...openRouterRows, ...(zai?.rows ?? [])],
+    rows: [...codex.rows, ...claude.rows, ...grok.rows, ...openRouter.rows, ...zaiRows],
     accountCounts: {
-      codex: codexRows.length,
-      grok: grokRows.length,
-      openrouter: openRouterRows.length,
+      codex: codex.rows.length,
+      grok: grok.rows.length,
+      openrouter: openRouter.rows.length,
+      // ⛔ claude 도 토큰이 없으면(행 0) 칸을 안 싣는다 — 종전 JSON·문면과 바이트 동일(0행 ≠ 0% 사용).
+      ...(claude.rows.length > 0 ? { claude: claude.rows.length } : {}),
       // ⛔ 키가 없으면 칸 자체를 안 싣는다 — 종전 JSON·문면과 바이트 동일.
-      ...(zai ? { zai: 1 } : {}),
+      // 종전과 같게: 조회가 성공했으면(창이 비어도) zai 1 · 실패해 error 행만 남았어도 1(실패 행도 센다).
+      ...(zai.zai || zai.rows.length > 0 ? { zai: 1 } : {}),
     },
-    ...(zai ? { zaiCodingPlan: zai.view } : {}),
+    ...(zai.zai ? { zaiCodingPlan: zai.zai.view } : {}),
+  };
+}
+
+/** 실 OAuth usage 엔드포인트는 5~10분 간격에도 429 를 낸다(fetchers/claude.ts 머리말 · 기본 주기 15분).
+ *  nexus `/api/usage` 는 30초 캐시로 이 조립을 부르므로, 기본 조회 경로(심 없음)는 성공 스냅숏을 15분 재사용한다. */
+const CLAUDE_USAGE_CACHE_MS = 15 * 60_000;
+/** 실패(429 등)도 5분 재사용한다 — 429 가 이어지는 동안 30초마다 다시 치지 않게. */
+const CLAUDE_USAGE_FAILURE_CACHE_MS = 5 * 60_000;
+type ClaudeUsageCacheEntry = { readonly at: number; readonly token: string } & (
+  | { readonly ok: true; readonly snap: UsageSnapshot }
+  | { readonly ok: false; readonly error: unknown });
+let claudeUsageCache: ClaudeUsageCacheEntry | null = null;
+
+/** 시험 전용 — 모듈 캐시를 비운다. */
+export function resetClaudeUsageCacheForTest(): void {
+  claudeUsageCache = null;
+}
+
+async function fetchClaudeCached(token: string, nowMs: number, fetchRaw: () => Promise<UsageSnapshot>): Promise<UsageSnapshot> {
+  const c = claudeUsageCache;
+  // 캐시 키 = 토큰 — 토큰이 바뀌면(재로그인·계정 교체) 옛 계정 값을 새 행으로 보이지 않는다.
+  if (c && c.token === token && nowMs - c.at < (c.ok ? CLAUDE_USAGE_CACHE_MS : CLAUDE_USAGE_FAILURE_CACHE_MS)) {
+    if (c.ok) return c.snap;
+    throw c.error;
+  }
+  try {
+    const snap = await fetchRaw();
+    claudeUsageCache = { at: nowMs, token, ok: true, snap };
+    return snap;
+  } catch (error) {
+    claudeUsageCache = { at: nowMs, token, ok: false, error };
+    throw error;
+  }
+}
+
+/** Claude Code 구독 행 — 5시간 창(credits 축) ⊕ 7일 창(subscription 축).
+ *  ⛔ 토큰이 없으면 행을 «안» 만든다(0행 ≠ 0% 사용) — openrouter·zai 키와 같은 접기. */
+async function collectClaudeRows(deps: UnifiedUsageDeps): Promise<AccountUsageRow[]> {
+  // ⛔ 시험 런타임은 심이 없으면 «토큰 없음»으로 본다 — 실제 자격 파일을 읽으면
+  //   심을 모르는 옛 시험이 실제 네트워크를 치게 된다(openrouter·zai 키와 같은 이유).
+  const resolveToken = deps.resolveClaudeToken
+    ?? (process.env.NODE_ENV === 'test' ? () => null : resolveClaudeAccessToken);
+  let token: string | null;
+  try {
+    token = resolveToken();
+  } catch (err) {
+    // 자격 파일이 깨진 경우를 «토큰 없음»과 가를 수 있게 관측만 남긴다(행은 안 만든다).
+    debug.log('usage', 'claude-token-resolve-failed', { detail: err instanceof Error ? err.message : String(err) });
+    token = null;
+  }
+  if (!token) return [];
+  const base = {
+    provider: 'claude' as const,
+    accountName: 'default',
+    accountCount: 1,
+    soleAccount: true,
+    resetCredits: { status: 'not-applicable' } as const,
+  };
+  const tokenKey = token;
+  const fetchClaude = deps.fetchClaude ?? (() => fetchClaudeCached(
+    tokenKey, (deps.now ?? Date.now)(), deps.fetchClaudeUncached ?? (() => createClaudeFetcher().fetch())));
+  try {
+    const snap = await fetchClaude();
+    const fiveHour = snap.windows.find((w) => w.model === undefined && w.kind === 'session');
+    const weekly = snap.windows.find((w) => w.model === undefined && w.kind === 'weekly');
+    return [{ ...base, credits: claudeCreditsFromWindow(fiveHour), subscription: claudeSubscriptionFromWindow(weekly) }];
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    debug.log('usage', 'claude-fetch-failed', { detail });
+    return [{
+      ...base,
+      credits: { status: 'error', detail },
+      subscription: { status: 'unavailable', reason: 'query-does-not-supply' },
+    }];
+  }
+}
+
+function claudeCreditsFromWindow(window: RateWindow | undefined): CreditAxis {
+  const periodEnd = window && isValidEpochMs(window.resetsAt) ? new Date(window.resetsAt) : null;
+  const periodStartEpoch = periodEnd !== null && window !== undefined && isPositiveFinite(window.windowMinutes)
+    ? periodEnd.getTime() - window.windowMinutes * 60_000
+    : null;
+  const periodStart = periodStartEpoch !== null && isValidDateMs(periodStartEpoch) ? new Date(periodStartEpoch) : null;
+  return {
+    status: 'ok',
+    usedPercent: window ? window.used : null,
+    periodType: window?.kind ?? null,
+    periodStart: periodStart?.toISOString() ?? null,
+    periodEnd: periodEnd?.toISOString() ?? null,
+    monthlyLimit: null,
+    used: window ? window.used : null,
+    onDemandCap: null,
+    onDemandUsed: null,
+    prepaidBalance: null,
+    balance: null,
+    hasCredits: null,
+    unlimited: null,
+  };
+}
+
+function claudeSubscriptionFromWindow(window: RateWindow | undefined): SubscriptionAxis {
+  if (!window) return { status: 'unavailable', reason: 'query-does-not-supply' };
+  return {
+    status: 'available',
+    remainingPercent: window.remainingPercent,
+    resetsAt: window.resetsAt,
+    windowKind: window.kind,
   };
 }
 
@@ -429,6 +588,11 @@ export function formatUnifiedUsage(report: UnifiedUsageReport): string {
     const count = report.accountCounts[provider];
     lines.push(`  ${provider}  accounts=${count}${count === 1 ? '  (하나뿐)' : count === 0 ? '  (없음)' : ''}`);
   }
+  // ⛔ claude 토큰이 없으면 줄을 안 낸다 — 종전 문면과 바이트 동일.
+  if (report.accountCounts.claude !== undefined) {
+    const count = report.accountCounts.claude;
+    lines.push(`  claude  accounts=${count}${count === 1 ? '  (하나뿐)' : ''}  (Claude Code 구독 · 5시간 창 ⊕ 7일 창)`);
+  }
   // ⛔ 키가 없으면 줄을 안 낸다 — 종전 문면과 바이트 동일.
   if (report.accountCounts.zai !== undefined) lines.push(`  zai  accounts=${report.accountCounts.zai}  (GLM Coding Plan)`);
   lines.push('  provider    account     accounts  credits.usedPercent  credits.window              window-resets-in       reset-credit-expiry                  subscription');

package/src/cli/doctor-cli.ts

@@ -40,6 +40,7 @@ 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';
+import { formatHostDoctorLines, runHostDoctor, type HostDoctorExpected, type HostDoctorRemote } from '../fleet/host-doctor.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -198,6 +199,10 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   /** Inject the upload transport and consent for isolated CLI tests. */
   uploadFetch?: typeof globalThis.fetch;
   confirmBundleUpload?: (message: string) => Promise<boolean>;
+  /** `doctor host` 원격 실행(시험 seam) — 기본 = ssh BatchMode · `local` 이면 이 기계. */
+  hostDoctorRemote?: HostDoctorRemote;
+  /** `doctor host` 가 대조할 HQ 실측값(설치 판 · 이미지 핀) — 없으면 해당 점검은 unmeasured. */
+  hostDoctorExpected?: HostDoctorExpected;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1240,6 +1245,22 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
       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.command('host')
+    .description('Check whether a fleet host stands ready for its role (read-only · setup-status shape)')
+    .argument('<host>', "ssh name, or 'local' for this machine")
+    .option('--role <role>', 'host role: worker or hq', 'worker')
+    .option('--json', 'structured output')
+    .action((host: string, opts: { role: string; json?: boolean }, command: Command) => {
+      if (opts.role !== 'worker' && opts.role !== 'hq') {
+        err.error('--role must be worker or hq');
+        setExitCode(1);
+        return;
+      }
+      const json = opts.json === true || command.parent?.opts().json === true;
+      const report = runHostDoctor({ host, role: opts.role, remote: deps.hostDoctorRemote, expected: deps.hostDoctorExpected });
+      out.log(json ? JSON.stringify(report, null, 2) : formatHostDoctorLines(report).join('\n'));
+      if (!report.ok) setExitCode(1);
+    });
   doctor
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')

package/src/cli/friendly-errors.ts

@@ -0,0 +1,113 @@
+import { detectLocale, type Locale } from '../expression/locale.js';
+import { classifyError } from '../session-runtime/retry-policy.js';
+
+export type FriendlyErrorCode =
+  | 'credential-missing'
+  | 'provider-unknown'
+  | 'model-unavailable'
+  | 'network'
+  | 'quota'
+  | 'context-too-long'
+  | 'config-broken'
+  | 'daemon-down'
+  | 'permission'
+  | 'unknown-command';
+
+export interface FriendlyMessage {
+  what: string;
+  why: string;
+  next: string;
+}
+
+export type FriendlyLanguage = 'ko' | 'en';
+
+export const FRIENDLY_ERRORS: Readonly<Record<FriendlyErrorCode, Readonly<Record<FriendlyLanguage, FriendlyMessage>>>> = {
+  'credential-missing': {
+    ko: { what: '모델에 접속할 자격이 없습니다', why: '이 provider 에 로그인하지 않았거나 키가 없습니다', next: 'elanous login' },
+    en: { what: 'No credentials for this model provider', why: 'You have not signed in or set a key', next: 'elanous login' },
+  },
+  'provider-unknown': {
+    ko: { what: '설정된 provider 를 모릅니다', why: 'llm.provider 값이 지원 목록에 없습니다', next: 'elanous config get llm.provider' },
+    en: { what: 'Unknown model provider', why: 'llm.provider is not a supported name', next: 'elanous config get llm.provider' },
+  },
+  'model-unavailable': {
+    ko: { what: '이 모델을 쓸 수 없습니다', why: 'provider 와 모델이 맞지 않거나 모델이 없습니다', next: 'elanous config get llm.model' },
+    en: { what: 'This model is not available', why: 'The provider and model do not match, or the model does not exist', next: 'elanous config get llm.model' },
+  },
+  network: {
+    ko: { what: '서버에 연결하지 못했습니다', why: '네트워크가 끊겼거나 서버가 응답하지 않습니다', next: 'elanous doctor' },
+    en: { what: 'Could not reach the server', why: 'The network is down or the server did not answer', next: 'elanous doctor' },
+  },
+  quota: {
+    ko: { what: '사용 한도에 걸렸습니다', why: '이 계정의 할당량을 다 썼거나 요청이 너무 잦습니다', next: 'elanous usage' },
+    en: { what: 'Usage limit reached', why: 'The account quota is used up or requests are too frequent', next: 'elanous usage' },
+  },
+  'context-too-long': {
+    ko: { what: '입력이 너무 깁니다', why: '모델이 한 번에 읽는 양을 넘었습니다', next: 'elanous ask "<더 짧은 질문>"' },
+    en: { what: 'The input is too long', why: 'It exceeds what the model reads at once', next: 'elanous ask "<shorter question>"' },
+  },
+  'config-broken': {
+    ko: { what: '설정 파일을 읽지 못했습니다', why: 'config 파일의 JSON 이 깨졌습니다', next: 'elanous doctor --fix' },
+    en: { what: 'Could not read the config file', why: 'The config JSON is malformed', next: 'elanous doctor --fix' },
+  },
+  'daemon-down': {
+    ko: { what: '엘라누스 데몬이 떠 있지 않습니다', why: '백그라운드 서비스가 꺼져 있습니다', next: 'elanous nexus' },
+    en: { what: 'The elanous daemon is not running', why: 'The background service is stopped', next: 'elanous nexus' },
+  },
+  permission: {
+    ko: { what: '파일에 접근할 권한이 없습니다', why: '이 사용자로 그 경로를 읽거나 쓸 수 없습니다', next: 'elanous doctor' },
+    en: { what: 'Permission denied', why: 'This user cannot read or write that path', next: 'elanous doctor' },
+  },
+  'unknown-command': {
+    ko: { what: '모르는 명령입니다', why: '명령 이름이 틀렸거나 이 판에 없습니다', next: 'elanous --help' },
+    en: { what: 'Unknown command', why: 'The name is misspelled or not in this version', next: 'elanous --help' },
+  },
+};
+
+function messageOf(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  return typeof err === 'string' ? err : '';
+}
+
+function errnoOf(err: unknown): string {
+  if (err && typeof err === 'object') {
+    const code = (err as { code?: unknown }).code;
+    if (typeof code === 'string') return code;
+  }
+  return '';
+}
+
+/** Maps a thrown value to a friendly-error code by its wording and by the
+ *  retry-policy category. Returns null when nothing matches. */
+export function classifyFriendlyError(err: unknown): FriendlyErrorCode | null {
+  const msg = messageOf(err);
+  const errno = errnoOf(err);
+
+  if (/provider-model compatibility/i.test(msg)) return 'model-unavailable';
+  if (/\bunknown provider:/i.test(msg)) return 'provider-unknown';
+  if (/\bunavailable:\s+(set|run|configure)\b/i.test(msg)) return 'credential-missing';
+  if (/the elanous daemon is not running/i.test(msg)) return 'daemon-down';
+  if (/unknown command '/i.test(msg)) return 'unknown-command';
+  if (/input exceeds the \d+-token context budget/i.test(msg)) return 'context-too-long';
+  if (
+    /Unexpected token .*JSON|JSON Parse error|is not valid JSON|JSON at position/i.test(msg) ||
+    (err instanceof Error && err.name === 'SyntaxError' && /json/i.test(msg))
+  ) return 'config-broken';
+  if (errno === 'EACCES' || errno === 'EPERM' || /\b(EACCES|EPERM)\b/.test(msg)) return 'permission';
+
+  switch (classifyError(err)) {
+    case 'network-transient': return 'network';
+    case 'quota-exceeded':
+    case 'rate-limit': return 'quota';
+    case 'context-window-exceeded': return 'context-too-long';
+    case 'provider-unavailable': return 'credential-missing';
+    default: return null;
+  }
+}
+
+/** Renders one language only (ko, otherwise en). The last line is the one command to run. */
+export function formatFriendlyError(code: FriendlyErrorCode, locale: Locale = detectLocale()): string {
+  const language: FriendlyLanguage = locale === 'ko' ? 'ko' : 'en';
+  const { what, why, next } = FRIENDLY_ERRORS[code][language];
+  return `❌ ${what}\n  ↳ ${why}\n  ${next}`;
+}

package/src/cli/intake-cli.ts

@@ -173,7 +173,9 @@ export async function runIntakeDigestCli(
         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 });
+    const judgedCount = (entries: { verdict: string }[] | undefined) => (entries ?? []).filter((entry) => entry.verdict !== '판정 대기').length;
+    debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length,
+      github: d.githubNew?.length ?? 0, githubJudged: judgedCount(d.githubNew), x: d.xTrends?.length ?? 0, xJudged: judgedCount(d.xTrends), sent });
     if (seat && sent) recordSeatBriefed(root, seat, day, d.absorbed.map((entry) => entry.id));
     if (seat === 'user') debug.log('watch.default', 'brief', { topics: (await import('../intake-plane/intake-sources.js')).listSources({ seat }, root).length, items: d.absorbed.length, sent });
     console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');

package/src/cli/memory-cli.ts

@@ -0,0 +1,182 @@
+/**
+ * `elanous memory` 명령 묶음 등록 — BIG-FILE-index-1 첫 조각(순수 이동 · src/index.ts → src/cli/memory-cli.ts).
+ * 로직·문면·옵션·종료 코드는 이동 원본과 동일하다.
+ */
+import type { Command } from 'commander';
+import * as ui from '../ui.js';
+import { readPipedStdin } from './piped-stdin.js';
+import {
+  saveMemory, loadMemory, listMemories, deleteMemory, searchMemories,
+  readIndex, memoryRoot, memoryIndexPath,
+  type MemoryType,
+} from '../memory.js';
+
+export function registerMemoryCommands(program: Command): void {
+  const memCmd = program.command('memory').description('Persistent memories injected into every chat turn (user / feedback / project / reference)');
+
+  memCmd
+  .command('list [type]')
+  .description('List memories (optionally filtered by type)')
+  .option('-n, --limit <n>', 'Max entries to show', '30')
+  .action((type?: string, opts?: { limit: string }) => {
+    const t = type as MemoryType | undefined;
+    const entries = listMemories({ type: t, limit: parseInt(opts?.limit ?? '30', 10) });
+    if (entries.length === 0) {
+      ui.info('No memories yet. Add one with `elanous memory add <type> "<name>" "<description>"`.');
+      return;
+    }
+    ui.header(`memories (${entries.length})`);
+    for (const e of entries) {
+      console.log(`  ${e.id.slice(0, 8)}  [${e.type.padEnd(9)}]  ${e.name}`);
+      if (e.description) console.log(`             ${e.description.slice(0, 100)}`);
+    }
+  });
+
+  memCmd
+  .command('add <type> <name> [description...]')
+  .description('Create a memory (type: user|feedback|project|reference). Body piped via stdin if available.')
+  .action(async (type: string, name: string, descParts: string[]) => {
+    if (!['user', 'feedback', 'project', 'reference'].includes(type)) {
+      ui.error(`invalid type "${type}". Use: user | feedback | project | reference`);
+      process.exit(1);
+    }
+    const description = (descParts || []).join(' ');
+    // Read body from stdin if piped; otherwise use description as body too.
+    let body = description;
+    const pipedBody = await readPipedStdin();   // ★ OBS-T3 — 비-TTY 는 파이프를 뜻하지 않는다(소켓이면 EOF 가 안 온다)
+    if (pipedBody) body = pipedBody;
+    const e = saveMemory({ type: type as MemoryType, name, description, body });
+    ui.info(`saved ${e.id.slice(0, 8)} [${e.type}] "${e.name}"`);
+  });
+
+  // 3번째 recall 레버(2026-07-19) — pin(항상주입) / priority(매칭 시 순위 부스트).
+  memCmd
+  .command('pin <idPrefix>')
+  .description('Pin a memory so it is ALWAYS injected (bypass keyword gate). Optionally set priority.')
+  .option('-p, --priority <n>', 'priority boost (higher = ranked/kept first)', '5')
+  .action((prefix: string, opts: { priority: string }) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, pinned: true, priority: parseInt(opts.priority, 10) || 0 });
+    ui.info(`📌 pinned ${e.id.slice(0, 8)} "${e.name}" (priority ${opts.priority})`);
+  });
+
+  memCmd
+  .command('unpin <idPrefix>')
+  .description('Un-pin a memory (back to keyword-gated recall).')
+  .action((prefix: string) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, pinned: false, priority: e.priority });
+    ui.info(`unpinned ${e.id.slice(0, 8)} "${e.name}"`);
+  });
+
+  memCmd
+  .command('priority <idPrefix> <n>')
+  .description('Set a memory\'s injection priority boost (0 = default). Added to match score.')
+  .action((prefix: string, n: string) => {
+    const e = loadMemory(prefix);
+    if (!e) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    saveMemory({ type: e.type, name: e.name, description: e.description, body: e.body, id: e.id, priority: parseInt(n, 10) || 0, pinned: e.pinned });
+    ui.info(`priority ${e.id.slice(0, 8)} "${e.name}" → ${parseInt(n, 10) || 0}`);
+  });
+
+  // 통합 관리 뷰(2026-07-19) — 2 시스템(큐레이션 파일메모리 + 에피소드 self-log)을 한 화면에.
+  memCmd
+  .command('status')
+  .description('Unified memory overview — ① curated file-memory + ② self-log (surface_events)')
+  .action(async () => {
+    const { memoryRoot } = await import('../memory.js');
+    const mems = listMemories();
+    const byType: Record<string, number> = {};
+    let pinned = 0;
+    for (const e of mems) { byType[e.type] = (byType[e.type] ?? 0) + 1; if (e.pinned) pinned += 1; }
+    ui.header('memory (unified)');
+    console.log(`① 큐레이션 파일메모리: ${mems.length}건  [${Object.entries(byType).map(([k, v]) => `${k}:${v}`).join(' ') || '-'}]  📌pinned ${pinned}`);
+    console.log(`   ${memoryRoot()}  (LLM-judge/luna recall · MEMORY.md 항상주입)`);
+    try {
+      const { surfaceEventsDbPath, openSurfaceEventsDb } = await import('../domains/surface-events.js');
+      const path = surfaceEventsDbPath();
+      // 항상 open — legacy conatus/ → memory/ 자가치유 마이그레이션이 여기서 실행된다(존재 체크 먼저
+      // 하면 신 경로 부재로 마이그레이션이 스킵됨). 없으면 빈 store 생성(무해).
+      const db = openSurfaceEventsDb(path);
+      const n = (db.prepare('SELECT count(*) c FROM events').get() as { c: number }).c;
+      const recent = (db.prepare('SELECT ts FROM events ORDER BY ts DESC LIMIT 1').get() as { ts: string } | undefined)?.ts;
+      db.close();
+      console.log(`② 에피소드 self-log: ${n.toLocaleString()} events  (최근 ${recent?.slice(0, 16) ?? '-'})`);
+      console.log(`   ${path}  (FTS5 bm25+recency+myelin rerank · ambient 회상)`);
+    } catch (e) { console.log(`② self-log 조회 실패: ${(e as Error).message}`); }
+    try {
+      const { openKnowledgeDb, knowledgeDbPath } = await import('../domains/knowledge.js');
+      const kdb = openKnowledgeDb(); // 기본 경로 → legacy conatus/ 자가치유 이전
+      const kn = (kdb.prepare('SELECT count(*) c FROM docs').get() as { c: number }).c;
+      const dom = (kdb.prepare("SELECT domain, count(*) c FROM docs GROUP BY domain ORDER BY c DESC LIMIT 3").all() as Array<{ domain: string | null; c: number }>);
+      kdb.close();
+      console.log(`③ 시맨틱 knowledge: ${kn.toLocaleString()} docs  [${dom.map(d => `${d.domain ?? 'null'}:${d.c}`).join(' ')}]`);
+      console.log(`   ${knowledgeDbPath()}  (임베딩 벡터+BM25 하이브리드 · 의미 회상)`);
+    } catch (e) { console.log(`③ knowledge 조회 실패: ${(e as Error).message}`); }
+  });
+
+  memCmd
+  .command('show <idPrefix>')
+  .description('Print full memory body')
+  .action((prefix: string) => {
+    const entries = listMemories();
+    const hit = entries.find(e => e.id.startsWith(prefix));
+    if (!hit) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    const full = loadMemory(hit.id)!;
+    ui.header(`${full.type}: ${full.name}`);
+    console.log(`  id          ${full.id}`);
+    console.log(`  created     ${full.createdAt}`);
+    console.log(`  updated     ${full.updatedAt}`);
+    console.log(`  description ${full.description}`);
+    console.log('');
+    console.log(full.body);
+  });
+
+  memCmd
+  .command('search <query...>')
+  .description('Keyword search across all memories')
+  .option('--type <t>', 'Filter by type')
+  .option('-n, --limit <n>', 'Max results', '10')
+  .action((parts: string[], opts) => {
+    const hits = searchMemories(parts.join(' '), {
+      type: opts.type as MemoryType | undefined,
+      limit: parseInt(opts.limit, 10),
+    });
+    if (hits.length === 0) { ui.info('No matches.'); return; }
+    ui.header(`matches (${hits.length})`);
+    for (const h of hits) {
+      console.log(`  ${h.entry.id.slice(0, 8)}  score ${h.score}  [${h.entry.type}]  ${h.entry.name}`);
+      if (h.entry.description) console.log(`             ${h.entry.description.slice(0, 100)}`);
+    }
+  });
+
+  memCmd
+  .command('delete <idPrefix>')
+  .description('Delete a memory')
+  .action((prefix: string) => {
+    const entries = listMemories();
+    const hit = entries.find(e => e.id.startsWith(prefix));
+    if (!hit) { ui.error(`no memory matching "${prefix}"`); process.exit(1); }
+    deleteMemory(hit.id);
+    ui.info(`deleted ${hit.id.slice(0, 8)}`);
+  });
+
+  memCmd
+  .command('index')
+  .description('Print MEMORY.md index verbatim')
+  .action(() => {
+    const idx = readIndex();
+    if (!idx) { ui.info('empty (no memories yet)'); return; }
+    console.log(idx);
+  });
+
+  memCmd
+  .command('where')
+  .description('Show the memory storage path')
+  .action(() => {
+    console.log(`memory dir   ${memoryRoot()}`);
+    console.log(`index file   ${memoryIndexPath()}`);
+  });
+}

package/src/cli/model-watch-cli.ts

@@ -5,7 +5,7 @@ import { loadCatalog, type CatalogIoOpts } from '../intelligence-map/model-catal
 import { getModelWatchProposalPath, runModelIntelligenceWatch, type ModelWatchDeps } from '../intelligence-map/model-watch-mission.js';
 import { fetchProviderModelPages, type ModelWatchFetchResult } from '../intelligence-map/model-watch-fetch.js';
 import type { ModelCandidate } from '../intelligence-map/model-classifier.js';
-import type { WatchIntakeResult } from '../intelligence-map/model-watch-intake.js';
+import { detectPriceChanges, formatPriceChange, type PriceChange, type WatchIntakeResult } from '../intelligence-map/model-watch-intake.js';
 import type { LlmRunner } from '../model-tier/preset-suggest-llm.js';
 
 export interface ModelWatchCliResult {
@@ -14,6 +14,7 @@ export interface ModelWatchCliResult {
   failures: ModelWatchFetchResult['failures'];
   proposal: Pick<WatchIntakeResult['proposal'], 'added' | 'updated'>;
   candidates: WatchIntakeResult['candidates'];
+  priceChanges: PriceChange[];
   perSource: WatchIntakeResult['perSource'];
 }
 
@@ -93,6 +94,7 @@ export async function runModelWatchCli(deps: ModelWatchCliDeps = {}): Promise<Mo
     failures: fetched.failures,
     proposal: { added: intake.proposal.added, updated: intake.proposal.updated },
     candidates: intake.candidates,
+    priceChanges: detectPriceChanges(intake),
     perSource: intake.perSource,
   };
 }
@@ -103,6 +105,7 @@ export function formatModelWatchResult(result: ModelWatchCliResult): string {
     `Proposal: ${result.proposal.added.length} added, ${result.proposal.updated.length} updated (not applied).`,
   ];
   if (result.candidates.length > 0) lines.push(`Candidates: ${result.candidates.map((candidate) => candidate.id).join(', ')}`);
+  if (result.priceChanges.length > 0) lines.push(`Price changes: ${result.priceChanges.map(formatPriceChange).join('; ')}`);
   const abnormalEmptySources = Object.entries(result.perSource)
     .filter(([, source]) => source.candidateCount === 0 && source.status !== 'completed')
     .map(([source]) => source);

package/src/cli/pr-land-pod-shadow.ts

@@ -0,0 +1,54 @@
+/**
+ * PRLAND-HEAVY-ON-POD-1 — `pr land` 무거운 판정을 Pod 에서 그림자 리허설한다.
+ *
+ * 착지 경로에 아직 잇지 않는다. `--heavy-on-pod-shadow` 플래그·실제 Pod 러너 바인딩은
+ * 다음 조각(pr-cli.ts · pod-command-job.ts 무접촉). 이번 단위는 주입형 순수 함수만:
+ * 켜지면 가짜/실 Pod 러너를 한 번 부르고 `pr.land`/`heavy-on-pod-shadow` 관측 한 줄을 남긴 뒤
+ * 로컬 판정을 그대로 반환한다. 끄면 러너 0회. 러너가 던져도 경고 한 줄만 내고 로컬을 지킨다.
+ */
+
+export interface HeavyOnPodShadowInput<T> {
+  enabled: boolean;
+  pr: number;
+  head: string;
+  local: T;
+  runPod: () => T | Promise<T>;
+  log: (category: string, event: string, data: Record<string, unknown>) => void;
+  warn: (message: string) => void;
+}
+
+function agree(local: unknown, pod: unknown): boolean {
+  if (Object.is(local, pod)) return true;
+  try {
+    return JSON.stringify(local) === JSON.stringify(pod);
+  } catch {
+    return false;
+  }
+}
+
+function elapsedMs(started: number): number {
+  return Math.max(0, performance.now() - started);
+}
+
+export async function runHeavyOnPodShadow<T>(input: HeavyOnPodShadowInput<T>): Promise<T> {
+  const { enabled, pr, head, local, runPod, log, warn } = input;
+  if (!enabled) return local;
+
+  const localMs = 0;
+  const started = performance.now();
+  try {
+    const pod = await runPod();
+    log('pr.land', 'heavy-on-pod-shadow', {
+      pr,
+      head,
+      local,
+      pod,
+      agree: agree(local, pod),
+      podMs: elapsedMs(started),
+      localMs,
+    });
+  } catch (error) {
+    warn(error instanceof Error ? error.message : String(error));
+  }
+  return local;
+}