elanous 0.2.22 → 0.2.23

package/src/model-tier/llm-tier-map.ts

@@ -400,21 +400,50 @@ const GROK: TierMap = {
 //   kimi·qwen·glm 의 «첫 실제 경로». 사다리는 이름 기억이 아니라 ***실물 `/api/v1/models` 사실***로 골랐다
 //   (2026-09-23 실측 · 전 칸 `tools`·`reasoning` 지원 · 가격 $/MTok 입력/출력):
 //     budget   qwen3.8-flash      0.15/0.47  1M
-//     balanced glm-5.3            0.84/2.64  1.31M   ← 기본(OPENROUTER_MODEL)
+//     balanced glm-5.3            0.039/4.8  1.05M   ← 기본(OPENROUTER_MODEL)
+//     별도 모델 glm-5.3-flash     가격·창 미측정 (0으로 기록하지 않는다)
+//   📏 OP 10-10 OpenRouter 실측: GLM-5.3 입력 $0.039/MTok · 출력 $4.8/MTok · 창 1.05M.
 //     better   qwen3.8-max-0902   2/6        1M
 //     best     kimi-k3            3/15       1.05M
-//   ⇒ 가격순이면서 세 벤더를 «다» 덮는다. ⛔ 가격·창은 늙는다 — 카탈로그(`openrouter/*` 폴드)가 canonical.
+//   ⚠️ GLM 가격 갱신·flash 단가 미측정으로 가격순 주장은 보류한다. 가격·창은 늙는다 — 카탈로그(`openrouter/*` 폴드)가 canonical.
 //   `shipping` = «생성된다»(배선 계약). 도구 호출·도구 루프·elanous 실제 프롬프트 3/3 실측(리서치 문서 §9).
 //   ⚠️ `loaded` 의 reasoningLevel 은 wire 로 «안» 간다 — 측정상 OpenRouter `reasoning.effort` 를 보내면
 //      kimi·glm 이 «덜» 생각한다(필드 없음이 최대). 그래서 옮기지 않았다 — 리서치 문서 §9.
 const OPENROUTER: TierMap = {
   budget:   { model: 'openrouter/qwen/qwen3.8-flash',     label: 'Qwen 3.8 Flash (OpenRouter)',   rationale: 'Fast · cheap · 1M ctx',            status: 'shipping' },
-  balanced: { model: 'openrouter/z-ai/glm-5.3',           label: 'GLM 5.3 (OpenRouter)',          rationale: 'Default · 1.31M ctx',              status: 'shipping' },
+  balanced: { model: 'openrouter/z-ai/glm-5.3',           label: 'GLM 5.3 (OpenRouter)',          rationale: 'Default · $0.039/$4.8 per MTok · 1.05M ctx', status: 'shipping' },
   better:   { model: 'openrouter/qwen/qwen3.8-max-0902',  label: 'Qwen 3.8 Max (OpenRouter)',     rationale: 'Higher quality',                   status: 'shipping' },
   best:     { model: 'openrouter/moonshotai/kimi-k3',     label: 'Kimi K3 (OpenRouter)',          rationale: 'Best · Kimi flagship',             status: 'shipping' },
   loaded:   { model: 'openrouter/moonshotai/kimi-k3', reasoningLevel: 'high', label: 'Kimi K3 · reasoning high (OpenRouter)', rationale: 'Loaded · deep multi-step', status: 'shipping' },
 };
 
+// ── AWS Bedrock (BEDROCK-PROVIDER · 2026-10-11) ───────────────────
+//   ⭐ 판단: ANTHROPIC 사다리의 «추론 수준·역할 배치»를 그대로 두고, 모델은 Bedrock 메시지 엔드포인트에서
+//   확인한 5.5 계열 id(`src/llm/bedrock.ts` BEDROCK_MODELS · 출처 platform.claude.com «Claude in Amazon Bedrock»
+//   Supported models)로만 채운다. 아래 칸(budget·balanced)은 ANTHROPIC 이 haiku-4-5·sonnet-5 를 쓰지만, 이 PR 이
+//   카탈로그에 올린 Bedrock id 는 5.5 셋뿐이라 같은 등급의 5.5(haiku-5-5·sonnet-5-5)로 올렸다.
+//   ⛔ bedrock 은 명시 선택 전용 — 이 표는 `--role-llm <role>=bedrock/<tier>` 같은 «명시» 해석에만 쓰인다.
+//   ⚠️ status = `wip`: 실 AWS 호출(계정별 5.5 접근 조건)을 아직 안 쟀고, 셋업 키 감지 표(PROVIDER_ENV_SPEC)에도
+//      없다(자격이 API 키가 아니라 AWS 체인이라). 첫 실호출 스모크 뒤 `shipping` 으로 올린다.
+const BEDROCK: TierMap = {
+  budget:   { model: 'anthropic.claude-haiku-5-5',  reasoningLevel: 'off',    label: 'Claude Haiku 5.5 (Bedrock)',  rationale: 'Fast · cheap · bulk/classification', status: 'wip' },
+  balanced: { model: 'anthropic.claude-sonnet-5-5', reasoningLevel: 'off',    label: 'Claude Sonnet 5.5 (Bedrock)', rationale: 'Default · everyday coding (BEDROCK_DEFAULT_MODEL)', status: 'wip' },
+  better:   { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'ANTHROPIC better 와 같은 배치(구현 = Opus 5.5)', status: 'wip' },
+  best:     { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'Best reasoning · architecture', status: 'wip' },
+  loaded:   { model: 'anthropic.claude-opus-5-5',   reasoningLevel: 'high',   label: 'Claude Opus 5.5 · extended thinking (Bedrock)', rationale: 'Loaded · deep multi-step', status: 'wip' },
+};
+
+/** 가격·창 미측정이라 기존 tier 배치를 바꾸지 않고 명시 모델로만 고르는 칸.
+ *  소비 경로 = `lookupOpenRouterModelSpec()` ← `resolveRunFallback()`(openrouter 폴백 판정의 관측·ROUTE 결정). */
+const OPENROUTER_EXPLICIT_MODELS: Readonly<Record<string, LlmTierSpec>> = {
+  'z-ai/glm-5.3-flash': {
+    model: 'openrouter/z-ai/glm-5.3-flash',
+    label: 'GLM 5.3 Flash (OpenRouter)',
+    rationale: 'Fast · 가격/창 미측정',
+    status: 'shipping',
+  },
+};
+
 // ── Combined lookup ─────────────────────────────────────────────────
 
 /** Subset of LLMProviderName that has a tier ladder defined here.
@@ -433,6 +462,7 @@ export const LLM_TIER_MAP_BY_PROVIDER: Readonly<Record<LlmTierProvider, TierMap>
   glm: GLM,
   grok: GROK,
   openrouter: OPENROUTER,
+  bedrock: BEDROCK,
 } as const;
 
 /** 사람이 쓰는 tier 별칭 → canonical ModelTier. "grok low tier" 같은 자연어 헷갈림을 SSOT 로 흡수한다.
@@ -454,9 +484,23 @@ export function parseTierArg(raw: string): ModelTier | undefined {
  *  tsc 는 배열 누락을 못 잡는다(2026-09-23 `#19900` 이 `openrouter` 를 빠뜨려 배선 계약 자가 그것을
  *  한 번도 누르지 않았다). 자 = `provider-wiring-contract.test.ts`. */
 export const TIER_PROVIDERS: readonly LlmTierProvider[] = [
-  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter',
+  'anthropic', 'openai', 'openai-codex', 'gemini', 'grok', 'local', 'kimi', 'qwen', 'glm', 'openrouter', 'bedrock',
 ];
 
+/** OpenRouter 모델 id(`openrouter/<vendor>/<model>` 또는 `<vendor>/<model>`)의 tier-map 칸.
+ *  명시 칸(`glm-5.3-flash` 등) → 5-tier 사다리 순으로 찾는다. 모르면 undefined(«미등록»을 기본값으로 접지 않는다). */
+export function lookupOpenRouterModelSpec(model: string): LlmTierSpec | undefined {
+  const bare = model.trim().replace(/^openrouter\//, '');
+  if (!bare) return undefined;
+  const explicit = OPENROUTER_EXPLICIT_MODELS[bare];
+  if (explicit) return explicit;
+  const wanted = `openrouter/${bare}`;
+  for (const tier of ['budget', 'balanced', 'better', 'best'] as const) {
+    if (OPENROUTER[tier].model === wanted) return OPENROUTER[tier];
+  }
+  return undefined;
+}
+
 /** Resolve the spec for (provider, tier).
  *  `auto` and unknown providers have no concrete provider ladder, so both use
  *  Anthropic's balanced default instead of crossing into the Codex family.

package/src/models/prompts.ts

@@ -29,8 +29,12 @@ export type ModelFamily =
   | 'grok'
   | 'gemini'
   | 'local'
+  | 'open-weight'
   | 'other';
 
+/** OpenRouter gateway prefix for OpenAI-served models (see OR-FAMILY-GPT6 in getModelFamily). */
+const OPENROUTER_OPENAI_PREFIX = 'openrouter/openai/';
+
 /** Infer the family from a model id. Mirrors `inferProviderFromModel`
  *  in llm.ts but returns a finer-grained tag (codex vs other gpt,
  *  specifically, because codex-family has the worst observed tool-
@@ -45,6 +49,23 @@ export function getModelFamily(modelId: string | undefined): ModelFamily {
   if (m.includes('grok')) return 'grok';
   if (m.startsWith('gemini-')) return 'gemini';
   if (m.startsWith('local:')) return 'local';
+  // OR-FAMILY-GPT6 — `openrouter/openai/<gpt-* | o1-/o3-/o4-*>` is the same model the direct
+  // path serves; when its bare id is 'gpt' there (gpt-6-*, gpt-4*, o-series) it gets 'gpt' here
+  // too, so it carries the gpt prompt pieces (hygiene addon · preamble addendum · chat variant ·
+  // tool-hint cap). Without this it fell to 'other'. ⛔ A 'codex' verdict (bare gpt-5*) is NOT
+  // taken: in llm.ts 'codex' also switches tool-loop behaviour (inspect/repair stops, Read
+  // auto-narrowing, exploration exemptions, idle timeout) — not just prompt text — and that is a
+  // separate decision. Ids with `codex` in them were already 'codex' above. Gateway-prefixed ids
+  // only — bare `openai/...` ids are not touched (same LM Studio reason as below).
+  if (m.startsWith(OPENROUTER_OPENAI_PREFIX) && getModelFamily(m.slice(OPENROUTER_OPENAI_PREFIX.length)) === 'gpt') {
+    return 'gpt';
+  }
+  // OpenRouter gateway ids only (`openrouter/<vendor>/<model>`). Bare vendor ids such as
+  // `qwen/qwen3-coder-30b` stay 'other' on purpose: LM Studio publishes native ids in that
+  // same shape (see getModelTier's local pattern), and this family must not reach local runs.
+  if (m.startsWith('openrouter/') && (m.includes('glm') || m.includes('kimi') || m.includes('qwen'))) {
+    return 'open-weight';
+  }
   return 'other';
 }
 
@@ -68,7 +89,7 @@ export function getModelFamily(modelId: string | undefined): ModelFamily {
 //     localhost).
 
 import type { LLMProviderName } from '../user-config.js';
-import type { SkillTier } from '../skills/runner.js';
+import type { SkillTier } from '../skills/skill-tier.js';
 import { LLM_TIER_MAP_BY_PROVIDER, TIER_PROVIDERS } from '../model-tier/llm-tier-map.js';
 
 function matchesAny(s: string, needles: string[]): boolean {

package/src/mss/logging/horizon-watch.ts

@@ -0,0 +1,168 @@
+import { Database } from 'bun:sqlite';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { debug } from '../../debug/log.js';
+import { registerStandaloneLogSink } from '../../domains/standalone-log-sink.js';
+import { LogStore, logsDbPath } from './log-store.js';
+
+type HorizonStatus = 'present' | 'empty' | 'unreadable';
+type Attribution = 'first-sample' | 'none' | 'attributed' | 'unattributed-loss';
+
+export interface HorizonSample {
+  atMs: number;
+  oldestTsMs: number | null;
+  status: HorizonStatus;
+  spanHours: number | null;
+  advancedMs: number;
+  deletedEvents: number;
+  attribution: Attribution;
+}
+
+export type HorizonTick = HorizonSample & { outcome: 'ok' | 'fail' };
+
+export interface HorizonWatchOptions { db?: string; state?: string }
+export interface HorizonWatchDeps {
+  openStore?: (path: string) => Pick<LogStore, 'horizon' | 'queryAll' | 'close'>;
+  now?: () => number;
+  stateDir?: string;
+}
+
+function lastReadableSample(path: string): HorizonSample | null {
+  let content = '';
+  try { content = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  for (const line of content.trimEnd().split('\n').reverse()) {
+    if (!line) continue;
+    const sample = JSON.parse(line) as HorizonSample;
+    if (sample.status !== 'unreadable') return sample;
+  }
+  try { return JSON.parse(readFileSync(join(dirname(path), 'last-readable.json'), 'utf8')) as HorizonSample; }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function saveReadableCheckpoint(path: string, sample: HorizonSample): void {
+  const checkpoint = join(dirname(path), 'last-readable.json');
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${checkpoint}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify(sample) + '\n');
+    renameSync(temporary, checkpoint);
+  } finally { rmSync(temporary, { force: true }); }
+}
+
+function saveSample(path: string, sample: HorizonSample): void {
+  let lines: string[];
+  try { lines = readFileSync(path, 'utf8').trimEnd().split('\n').filter(Boolean); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    lines = [];
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, [...lines.slice(-499), JSON.stringify(sample)].join('\n') + '\n');
+    renameSync(temporary, path);
+  } finally { rmSync(temporary, { force: true }); }
+  if (sample.status !== 'unreadable') saveReadableCheckpoint(path, sample);
+}
+
+/** Read the store only; samples live outside logs.db and observations go through debug sinks. */
+export function runHorizonWatchTick(opts: HorizonWatchOptions = {}, deps: HorizonWatchDeps = {}): HorizonTick {
+  const path = join(deps.stateDir ?? opts.state ?? join(elanousStateRoot(), 'log-horizon'), 'samples.jsonl');
+  // Serialize the entire read/compare/append transaction across cron and manual processes.
+  // This lock database is in the sample state directory, never in logs.db.
+  mkdirSync(dirname(path), { recursive: true });
+  const lock = new Database(join(dirname(path), 'samples.lock.db'));
+  try {
+    lock.run('PRAGMA busy_timeout = 120000');
+    lock.run('BEGIN IMMEDIATE');
+    try {
+      return recordSample();
+    } finally {
+      lock.run('ROLLBACK');
+    }
+  } finally {
+    lock.close();
+  }
+
+  function recordSample(): HorizonTick {
+    const now = deps.now ?? Date.now;
+    // The tick clock is read *after* the horizon read (see below), so every `deleted` event logged before the
+    // horizon was observed has ts <= atMs. Windows are half-open (prev.atMs, atMs]: each event is counted once.
+    let atMs: number | undefined;
+    let oldestTsMs: number | null = null;
+  let status: HorizonStatus = 'unreadable';
+  let deletedEvents = 0;
+  let store: ReturnType<NonNullable<HorizonWatchDeps['openStore']>> | undefined;
+  let previous: HorizonSample | null = null;
+  try {
+    store = (deps.openStore ?? LogStore.openReadOnly)(opts.db ?? logsDbPath());
+    const horizon = store.horizon();
+    atMs = now();
+    status = horizon.status;
+    oldestTsMs = horizon.status === 'present' ? horizon.oldestTsMs : null;
+    previous = lastReadableSample(path);
+    if (previous) {
+      deletedEvents = store.queryAll({
+        exactCategories: ['log-store.retention'], events: ['deleted'], sinceMs: previous.atMs + 1, untilMs: atMs,
+      }).length;
+    }
+  } catch (error) {
+    debug.log('log-store.horizon', 'read-failed', { reason: String(error) }, { level: 'warn' });
+    status = 'unreadable';
+    oldestTsMs = null;
+  } finally { store?.close(); }
+  atMs ??= now();
+
+  const advancedMs = status === 'present' && previous?.status === 'present' && previous.oldestTsMs !== null
+    ? Math.max(0, oldestTsMs! - previous.oldestTsMs) : 0;
+  const attribution: Attribution = status === 'unreadable' ? 'none'
+    : !previous ? 'first-sample'
+    : advancedMs === 0 ? 'none'
+    : deletedEvents > 0 ? 'attributed' : 'unattributed-loss';
+  const sample: HorizonSample = {
+    atMs, oldestTsMs, status,
+    spanHours: oldestTsMs === null ? null : (atMs - oldestTsMs) / 3_600_000,
+    advancedMs, deletedEvents, attribution,
+  };
+  try { saveSample(path, sample); }
+  catch (error) {
+    debug.log('log-store.horizon', 'sample-write-failed', { reason: String(error) }, { level: 'warn' });
+    return { ...sample, outcome: 'fail' };
+  }
+  debug.log('log-store.horizon', 'sample', {
+    oldestTs: oldestTsMs === null ? null : new Date(oldestTsMs).toISOString(),
+    spanHours: sample.spanHours, advancedMs, deletedEvents, attribution,
+  }, { level: attribution === 'unattributed-loss' ? 'warn' : 'info' });
+  return { ...sample, outcome: status === 'unreadable' ? 'fail' : 'ok' };
+  }
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const opts: HorizonWatchOptions = {};
+  let json = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') json = true;
+    else if (arg === '--db' && args[i + 1]) opts.db = args[++i];
+    else if (arg === '--state' && args[i + 1]) opts.state = args[++i];
+    else { process.stderr.write(`Unknown or incomplete option: ${arg}\n`); process.exit(1); }
+  }
+  const sinkReady = await registerStandaloneLogSink('log-horizon');
+  // A sink failure must not suppress the sample: the store read (and an 'unreadable' record) still happens,
+  // but the tick cannot claim success because its observation never reached logs.db.
+  const tick = runHorizonWatchTick(opts);
+  const result = sinkReady ? tick : { ...tick, outcome: 'fail' as const, reason: 'log-sink-registration-failed' };
+  if (json) process.stdout.write(`${JSON.stringify(result)}\n`);
+  else process.stdout.write(`${result.outcome}: ${result.attribution} (${result.status})${sinkReady ? '' : ' · log-sink-registration-failed'}\n`);
+  if (result.outcome === 'fail') process.exitCode = 1;
+}

package/src/mss/logging/log-store.ts

@@ -17,7 +17,8 @@
 //     severity 는 SCHEME(이벤트 접미사) → `level` 컬럼으로 물질화.
 
 import { Database } from 'bun:sqlite';
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmdirSync, rmSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { dirname, join } from 'node:path';
 
@@ -81,9 +82,13 @@ export interface LogStoreRetention {
   maxAgeDays: number;
   /** DB 상한(MB). 초과 시 오래된 행부터 삭제. 0 이하 = 크기 정리 안 함. 기본 500. */
   maxDbMb: number;
+  /** 🩸 LOGS-RETENTION-WINDOW-1(10-10): size-cap floor in hours — the size pass never deletes rows newer than
+   *  this; when rows outside the floor are not enough it stops and logs `retention-floor-held`.
+   *  0 = legacy behaviour (oldest-first with no floor). Missing = 24. Age pass (`maxAgeDays`) is unaffected. */
+  minRetainHours?: number;
 }
 
-export const LOG_RETENTION_DEFAULTS: LogStoreRetention = { maxAgeDays: 7, maxDbMb: 500 };
+export const LOG_RETENTION_DEFAULTS: LogStoreRetention = { maxAgeDays: 7, maxDbMb: 500, minRetainHours: 24 };
 
 /** 스토어 OOM 백스톱 — 정책 상한이 아니다. 정책은 각 경계(HTTP·툴)가 갖는다. */
 export const STORE_SAFETY_MAX = 100_000;
@@ -360,22 +365,65 @@ export class LogStore {
     }
     if (policy.maxDbMb > 0) {
       const pageCount = (this.db.query('PRAGMA page_count').get() as { page_count: number }).page_count;
+      const freePages = (this.db.query('PRAGMA freelist_count').get() as { freelist_count: number }).freelist_count;
       const pageSize = (this.db.query('PRAGMA page_size').get() as { page_size: number }).page_size;
-      const sizeMb = (pageCount * pageSize) / (1024 * 1024);
+      // 🩸 OBS-RET-RATCHET(2026-10-09): 빈 페이지까지 세면 VACUUM 없는 파일은 안 줄어든다 → 뜰 때마다 오래된 행 ≈5% 를
+      //   또 지우는 래칫이 됐다(운영 logs.db 528MB · 01:08Z 이전 행 소실). 상한은 «쓰는 페이지»로 잰다.
+      const sizeMb = ((pageCount - freePages) * pageSize) / (1024 * 1024);
       if (sizeMb > policy.maxDbMb) {
         // 초과분 비율만큼 오래된 행 삭제(대략 — 정밀 계산보다 반복 수렴 선호).
         const total = (this.db.query('SELECT COUNT(*) AS c FROM logs').get() as { c: number }).c;
         const dropCount = Math.max(1, Math.floor(total * Math.min(0.5, 1 - policy.maxDbMb / sizeMb)));
-        const r = this.db.run(
-          'DELETE FROM logs WHERE id IN (SELECT id FROM logs ORDER BY ts_ms ASC LIMIT ?)',
-          [dropCount],
-        );
-        deletedBySize = Number(r.changes ?? 0);
+        // 🩸 LOGS-RETENTION-WINDOW-1(10-10): prod write volume made this pass keep only ≈2h of rows, so evidence
+        //   for incidents a few hours old read as «0 rows». Rows inside the floor are never size-deleted.
+        const floorHours = policy.minRetainHours ?? LOG_RETENTION_DEFAULTS.minRetainHours ?? 0;
+        if (floorHours > 0) {
+          const floorCutoff = Date.now() - floorHours * 3_600_000;
+          // Byte-weighted split (payload text + fixed per-row overhead) — row counts alone misjudge mixed row sizes.
+          const split = this.db.query(
+            `SELECT COALESCE(SUM(CASE WHEN ts_ms < ? THEN w ELSE 0 END), 0) AS outsideBytes, COALESCE(SUM(w), 0) AS allBytes
+               FROM (SELECT ts_ms, 64 + LENGTH(ts) + LENGTH(category) + LENGTH(event) + COALESCE(LENGTH(data), 0) AS w FROM logs)`,
+          ).get(floorCutoff) as { outsideBytes: number; allBytes: number };
+          const r = this.db.run(
+            'DELETE FROM logs WHERE id IN (SELECT id FROM logs WHERE ts_ms < ? ORDER BY ts_ms ASC LIMIT ?)',
+            [floorCutoff, dropCount],
+          );
+          deletedBySize = Number(r.changes ?? 0);
+          // dropCount is capped at 50% per run; judge the floor against the full overshoot (by bytes) so a cap the
+          // floor can never reach is reported even when this run's capped batch was fully served from outside rows.
+          const neededShare = 1 - policy.maxDbMb / sizeMb;
+          const outsideShare = split.allBytes > 0 ? split.outsideBytes / split.allBytes : 0;
+          if (outsideShare < neededShare) {
+            debug.log('mss.logging', 'retention-floor-held', {
+              totalMb: Math.round(sizeMb * 10) / 10, maxTotalMb: policy.maxDbMb, floorHours,
+              neededShare: Math.round(neededShare * 1000) / 1000, outsideShare: Math.round(outsideShare * 1000) / 1000,
+              deletedRows: deletedBySize,
+            });
+          }
+        } else {
+          const r = this.db.run(
+            'DELETE FROM logs WHERE id IN (SELECT id FROM logs ORDER BY ts_ms ASC LIMIT ?)',
+            [dropCount],
+          );
+          deletedBySize = Number(r.changes ?? 0);
+        }
       }
     }
+    if (deletedByAge > 0 || deletedBySize > 0) {
+      const oldest = (this.db.query('SELECT MIN(ts_ms) AS t FROM logs').get() as { t: number | null }).t;
+      debug.log('log-store.retention', 'deleted', { deletedByAge, deletedBySize, oldestTs: oldest === null ? null : new Date(oldest).toISOString() });
+    }
     return { deletedByAge, deletedBySize };
   }
 
+  /** Reclaim a bounded number of free pages after retention; legacy databases with auto_vacuum=NONE remain unchanged. */
+  reclaimFreePages(): void {
+    const mode = (this.db.query('PRAGMA auto_vacuum').get() as { auto_vacuum: number }).auto_vacuum;
+    if (mode !== 2) return;
+    const free = (this.db.query('PRAGMA freelist_count').get() as { freelist_count: number }).freelist_count;
+    if (free > 0) this.db.run(`PRAGMA incremental_vacuum(${Math.min(free, 128)})`);
+  }
+
   /**
    * ⛔⭐⭐⭐ **이 스토어에 «실제로 뜬» 카테고리와 그 수**(2026-08-19 · `OBS-T122`).
    *
@@ -658,6 +706,12 @@ export class LogStore {
     return (this.db.query('SELECT COUNT(*) AS c FROM logs').get() as { c: number }).c;
   }
 
+  /** Earliest retained event timestamp, regardless of insertion order. No schema or row writes. */
+  horizon(): { status: 'present'; oldestTsMs: number } | { status: 'empty' } {
+    const { oldestTsMs } = this.db.query('SELECT MIN(ts_ms) AS oldestTsMs FROM logs').get() as { oldestTsMs: number | null };
+    return oldestTsMs === null ? { status: 'empty' } : { status: 'present', oldestTsMs };
+  }
+
   close(): void {
     try { this.db.close(); } catch { /* noop */ }
   }
@@ -850,28 +904,163 @@ export class StoreSink implements LogSink {
   }
 }
 
+const RETENTION_INTERVAL_MS = 6 * 3600 * 1000;
+type RetentionLockOwner = { token: string; pid: number; start: string | null };
+
+/** PID reuse must not let a new process inherit a dead process's ownership. */
+function processStart(pid: number): string | null {
+  try {
+    const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+    return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
+  } catch { return null; }
+}
+
+function ownerDead(owner: RetentionLockOwner): boolean {
+  if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0) return false;
+  try {
+    process.kill(owner.pid, 0);
+    const currentStart = processStart(owner.pid);
+    if (owner.start !== null && currentStart !== null && owner.start !== currentStart) return true;
+    // A zombie still answers kill(pid, 0), but can no longer run retention.
+    try {
+      const stat = readFileSync(`/proc/${owner.pid}/stat`, 'utf8');
+      return stat.slice(stat.lastIndexOf(')') + 2).startsWith('Z ');
+    } catch { return false; }
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'ESRCH';
+  }
+}
+
+/** Only the guard row can authorize removal. A pre-publication temp file belongs to its row's token. */
+function removeRetentionLockDirectory(lockPath: string, token: string, interrupted: boolean): void {
+  if (!existsSync(lockPath)) return;
+  const marker = join(lockPath, 'owner');
+  const temporaryName = `owner.${token}.tmp`;
+  if (readdirSync(lockPath).some((name) => name !== 'owner' && name !== temporaryName)) {
+    throw new Error('retention lock has unknown entries');
+  }
+  if (existsSync(marker)) {
+    const published = readFileSync(marker, 'utf8');
+    if (published !== token && !(interrupted && token.startsWith(published))) {
+      throw new Error('retention lock owner changed');
+    }
+    rmSync(marker);
+  }
+  rmSync(join(lockPath, temporaryName), { force: true });
+  rmdirSync(lockPath);
+}
+
+/** The SQLite guard serializes stale-lock recovery and ownership changes, including process death mid-acquisition. */
+function acquireRetentionLock(lockPath: string): (() => void) | null {
+  const guard = new Database(`${lockPath}.db`);
+  const token = randomUUID();
+  let handedOff = false;
+  try {
+    guard.run('PRAGMA busy_timeout = 100');
+    guard.run('CREATE TABLE IF NOT EXISTS owner (slot INTEGER PRIMARY KEY CHECK(slot = 1), token TEXT NOT NULL, pid INTEGER NOT NULL, start TEXT)');
+    let acquired = false;
+    guard.run('BEGIN IMMEDIATE');
+    try {
+      const previous = guard.query('SELECT token, pid, start FROM owner WHERE slot = 1').get() as RetentionLockOwner | null;
+      if (previous && !ownerDead(previous)) return null;
+      if (existsSync(lockPath)) {
+        // A pre-guard lock has no provable owner: never remove it.
+        if (!previous) return null;
+        try { removeRetentionLockDirectory(lockPath, previous.token, true); }
+        catch { return null; }
+      }
+      guard.run('INSERT OR REPLACE INTO owner (slot, token, pid, start) VALUES (1, ?, ?, ?)', [token, process.pid, processStart(process.pid)]);
+      guard.run('COMMIT');
+      acquired = true;
+    } finally {
+      if (!acquired) guard.run('ROLLBACK');
+    }
+    // The ownership row is committed before mkdir: a crash in this gap is recoverable too.
+    try {
+      mkdirSync(lockPath);
+      const temporary = join(lockPath, `owner.${token}.tmp`);
+      writeFileSync(temporary, token, { flag: 'wx' });
+      renameSync(temporary, join(lockPath, 'owner'));
+    } catch (error) {
+      guard.run('BEGIN IMMEDIATE');
+      try {
+        // Keep the ownership row if cleanup fails: the next process can then
+        // prove who left the directory behind and recover it after this PID dies.
+        removeRetentionLockDirectory(lockPath, token, true);
+        guard.run('DELETE FROM owner WHERE slot = 1 AND token = ?', [token]);
+        guard.run('COMMIT');
+      } catch { guard.run('ROLLBACK'); }
+      throw error;
+    }
+    handedOff = true;
+    return () => {
+      try {
+        guard.run('BEGIN IMMEDIATE');
+        try {
+          const current = guard.query('SELECT token FROM owner WHERE slot = 1').get() as { token: string } | null;
+          if (current?.token === token) {
+            removeRetentionLockDirectory(lockPath, token, false);
+            guard.run('DELETE FROM owner WHERE slot = 1 AND token = ?', [token]);
+          }
+          guard.run('COMMIT');
+        } catch (error) { guard.run('ROLLBACK'); throw error; }
+      } finally { guard.close(); }
+    };
+  } finally { if (!handedOff) guard.close(); }
+}
+
+/** A shared stamp prevents short-lived non-owner processes from repeatedly pruning the same DB. */
+function runStampedRetention(store: LogStore, retention: LogStoreRetention, owner: boolean): void {
+  const stampPath = `${store.path}.retention.stamp`;
+  const lockPath = `${store.path}.retention.lock`;
+  const isFresh = (): boolean => {
+    try {
+      const age = Date.now() - Number(readFileSync(stampPath, 'utf8'));
+      return age >= 0 && age < RETENTION_INTERVAL_MS;
+    } catch { return false; }
+  };
+  if (!owner && isFresh()) return;
+  const release = acquireRetentionLock(lockPath);
+  if (!release) return;
+  try {
+    if (!owner && isFresh()) return;
+    store.enforceRetention(retention);
+    try { store.reclaimFreePages(); }
+    catch (error) { debug.log('log-store.retention', 'reclaim-failed', { reason: error instanceof Error ? error.message : String(error) }); }
+    const temporary = `${stampPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporary, String(Date.now()));
+      renameSync(temporary, stampPath);
+    } finally { rmSync(temporary, { force: true }); }
+  } finally { release(); }
+}
+
 /** 부팅 1줄 등록 헬퍼 — 데몬/TUI/러너가 자기 surface 를 선언하고 스토어
  *  싱크를 단다. retention 은 호출측이 config 에서 읽어 전달(user-config
- *  순환 의존 회피). 반환 = unregister(테스트용) 또는 null(store 불가). */
+ *  순환 의존 회피). 반환 = unregister(테스트용) 또는 null(store 불가).
+ *  nexus owns the periodic job unless the caller explicitly opts in. */
 export function registerLogStoreSink(
   registerSink: (sink: LogSink) => () => void,
   surface: string,
   retention: LogStoreRetention = LOG_RETENTION_DEFAULTS,
+  opts: { retentionOwner?: boolean } = {},
 ): (() => void) | null {
   const store = getDefaultLogStore();
   if (!store) return null;
   const sink = new StoreSink(store, surface, { installExitHandlers: true });
   const off = registerSink(sink);
   try { nestDepth.observeNestAtBoot(); } catch { /* fail-soft — 관측 실패가 싱크 등록을 막지 않는다. */ }
-  // 보존정책 — 부팅 직후 1회(디퍼) + 6시간 주기. 실패는 조용히.
+  const owner = opts.retentionOwner ?? surface === 'nexus';
   const runRetention = (): void => {
-    try { store.enforceRetention(retention); } catch { /* fail-soft */ }
+    try { runStampedRetention(store, retention, owner); }
+    catch (error) { debug.log('log-store.retention', 'failed', { reason: error instanceof Error ? error.message : String(error) }); }
   };
-  setImmediate(runRetention);
-  const h = setInterval(runRetention, 6 * 3600 * 1000);
-  (h as unknown as { unref?: () => void }).unref?.();
+  const startup = setImmediate(runRetention);
+  const h = owner ? setInterval(runRetention, RETENTION_INTERVAL_MS) : null;
+  (h as unknown as { unref?: () => void } | null)?.unref?.();
   return () => {
-    clearInterval(h);
+    clearImmediate(startup);
+    if (h) clearInterval(h);
     sink.close();
     off();
   };

package/src/native-tool-catalog.ts

@@ -9,7 +9,7 @@ import type { VerifierSpec } from './verifier/types.js';
 import type { GuardianSpec } from './guardian/types.js';
 import { ptyAvailable } from './pty-shell/registry.js';
 import { krFlowAvailable } from './skills/tools/kr-flow.js';
-import { SELF_COGNITION_MCP_CATALOG_ENTRIES } from './tool-runtime/self-cognition-runtimes.js';
+import { SELF_COGNITION_MCP_CATALOG_ENTRIES } from './tool-runtime/self-cognition-catalog.js';
 import { SKILLS_LIST_DESCRIPTION } from './onboarding/entry-hints.js';
 
 export type { NativeToolHost } from './tool-surface.js';

package/src/nexus/api/consult-requests.ts

@@ -2,7 +2,7 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, re
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { debug } from '../../debug/log.js';
-import { routeOutbound } from '../outbound/router.js';
+import { sendTelegramReport } from '../../telegram-report.js';
 import { getUserConfig } from '../../user-config.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { jsonResponse } from './json-response.js';
@@ -23,7 +23,7 @@ interface ConsultRequest {
 export interface ConsultRequestsDeps {
   root?: () => string;
   now?: () => string;
-  /** Owner alert. Default = the daemon's own in-process router (the same one `/v1/outbound` uses).
+  /** Owner alert. Default = the daemon's in-process Telegram sender (operations role only).
    *  ⛔ Never `sendOutbound` here: it is a synchronous curl to this very daemon's `/v1/outbound`, so inside the
    *  daemon it blocks the event loop until it times out (~25 s · `unreachable`) and the alert is lost (CS1 · 10-01). */
   send?: (text: string, kind: string) => unknown;
@@ -88,9 +88,9 @@ export async function handleConsultRequests(req: Request, deps: ConsultRequestsD
   if (!body || typeof body !== 'object' || Array.isArray(body)) return rejected('body');
   const input = body as Record<string, unknown>;
   for (const field of ['name', 'contact'] as const) {
-    if (typeof input[field] !== 'string' || !input[field].trim()) return rejected(field);
+    if (typeof input[field] !== 'string' || !input[field].trim() || input[field].length > (field === 'name' ? 256 : 512)) return rejected(field);
   }
-  if (input.org !== undefined && (typeof input.org !== 'string' || !input.org.trim())) return rejected('org');
+  if (input.org !== undefined && (typeof input.org !== 'string' || !input.org.trim() || input.org.length > 256)) return rejected('org');
   if (input.kind !== 'company' && input.kind !== 'personal') return rejected('kind');
   if (input.interest !== 'A' && input.interest !== 'B') return rejected('interest');
   if (input.consent !== true) return rejected('consent');
@@ -114,15 +114,12 @@ export async function handleConsultRequests(req: Request, deps: ConsultRequestsD
   const alert = `📮 상담 문의 ${entry.receiptId} · ${entry.name}(${entry.kind === 'personal' ? '개인' : (entry.org ?? '회사')}) · 관심 ${entry.interest}\n앱에서 보기`;
   // Fire and forget — the receipt is already on disk; the answer must not wait for the channel.
   void Promise.resolve()
-    .then(() => (deps.send ?? notifyInProcess)(alert, 'alert'))
+    .then(() => (deps.send ?? notifyInProcess)(alert, 'ops-alert'))
     .catch((error: unknown) => { debug.log('consult.request', 'notify-failed', { receiptId: entry.receiptId, reason: error instanceof Error ? error.message : String(error) }); });
   return jsonResponse({ receiptId: entry.receiptId, receivedAt: entry.receivedAt }, 202);
 }
 
 async function notifyInProcess(text: string, kind: string): Promise<void> {
-  const result = await routeOutbound(getUserConfig(), { text, markdown: false, kind });
-  debug.log('consult.request', result.delivered ? 'notified' : 'notify-failed', {
-    delivered: result.delivered,
-    channels: result.channels.map((channel) => `${channel.type}:${channel.ok ? 'ok' : 'fail'}`),
-  });
+  const delivered = await sendTelegramReport(getUserConfig(), text, { markdown: false, kind });
+  debug.log('consult.request', delivered ? 'notified' : 'notify-failed', { delivered, channels: [`telegram:${delivered ? 'ok' : 'fail'}`] });
 }