elanous 0.2.17 → 0.2.18

package/src/briefing/brief-items.ts

@@ -4,6 +4,7 @@ import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
 import { dateKey } from '../time/format.js';
+import { readRequirementFunnel, type RequirementFunnelResult } from '../intake-plane/requirement-funnel.js';
 
 export const BRIEF_DOMAINS = ['운영', '판', '흡수', '시장', '행정', '코나투스'] as const;
 export const BRIEF_PRIORITIES = ['P0', 'P1', 'P2'] as const;
@@ -41,6 +42,7 @@ export interface BriefItemsOptions {
   stateDir?: string;
   now?: () => Date;
   log?: (category: string, event: string, data?: unknown) => void;
+  requirementFunnel?: (now: Date) => RequirementFunnelResult;
 }
 
 export class BriefItemsInputError extends Error {
@@ -89,8 +91,15 @@ function needsDecision(item: BriefItem, today: string): boolean {
  * duplicate claims dropped (same normalized sentence, most urgent kept).
  */
 export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlot, now: Date): string {
+  return composeBriefPage(items, slot, now).markdown;
+}
+
+/** The ids are exactly the rows represented by the composed page, after deduplication. */
+export function composeBriefPage(items: readonly BriefItem[], slot: BriefSlot, now: Date): { markdown: string; ids: number[] } {
   const today = dateKey(now, { timeZone: KST });
-  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now));
+  // A duplicate left out of a delivered page stays unsent in the ledger, but must not reappear on a later page.
+  const deliveredClaims = new Set(items.filter(item => item.sent_at !== null).map(item => normalizeClaim(item.text)));
+  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now) && !deliveredClaims.has(normalizeClaim(item.text)));
   // Duplicate claims keep the copy that needs a decision today (P0 or due today), then the higher priority, then the earliest (ACP must-fix).
   const rank = (item: BriefItem) => [needsDecision(item, today) ? 0 : 1, BRIEF_PRIORITIES.indexOf(item.priority), item.id];
   const better = (a: BriefItem, b: BriefItem) => { const x = rank(a), y = rank(b); return x[0]! - y[0]! || x[1]! - y[1]! || x[2]! - y[2]!; };
@@ -117,7 +126,7 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
     for (const item of group.sort((a, b) => a.id - b.id)) lines.push(itemLine(item));
     lines.push('');
   }
-  return `${lines.join('\n').trimEnd()}\n`;
+  return { markdown: `${lines.join('\n').trimEnd()}\n`, ids: unique.map(item => item.id) };
 }
 
 function itemLine(item: BriefItem): string {
@@ -166,11 +175,13 @@ export class BriefItemsLedger {
   readonly path: string;
   private readonly now: () => Date;
   private readonly log: (category: string, event: string, data?: unknown) => void;
+  private readonly requirementFunnel: (now: Date) => RequirementFunnelResult;
 
   constructor(options: BriefItemsOptions = {}) {
     this.path = join(options.stateDir ?? elanousStateRoot(), 'briefing', 'items.sqlite');
     this.now = options.now ?? (() => new Date());
     this.log = options.log ?? ((category, event, data) => debug.log(category, event, data));
+    this.requirementFunnel = options.requirementFunnel ?? ((now) => readRequirementFunnel({ stateDir: options.stateDir, now }));
   }
 
   private using<T>(work: (db: Database) => T): T {
@@ -246,15 +257,81 @@ export class BriefItemsLedger {
 
   /**
    * Markdown for one slot. Reads only — never marks, rewrites, or sends an item.
-   * Items created at or after the slot instant are left out.
+   * Items created at or after the slot instant are left out. At 08:30 the
+   * requirement funnel contributes ephemeral lines without adding ledger rows.
    */
   compose(slot: string): string {
+    return this.composeWithIds(slot).markdown;
+  }
+
+  private itemsFromDb(db: Database): BriefItem[] {
+    return db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at, (SELECT MIN(sent_at) FROM sends WHERE sends.item_id = items.id) AS sent_at FROM items ORDER BY id').all() as BriefItem[];
+  }
+
+  private pageFromDb(db: Database, slot: BriefSlot): { markdown: string; ids: number[] } {
+    const items = this.itemsFromDb(db);
+    const now = this.now();
+    const morningCutoff = Date.parse(`${dateKey(now, { timeZone: KST })}T08:30:00+09:00`);
+    let funnelItems: BriefItem[] = [];
+    if (slot === '08:30' && now.getTime() >= morningCutoff) {
+      // A funnel failure must not take the morning brief down with it.
+      try {
+        const extra = this.requirementFunnel(new Date(morningCutoff - 1)).briefItems;
+        // Negative ids never collide with ledger rows and keep the funnel's own order (summary first).
+        funnelItems = extra.map((item, index): BriefItem => ({
+          id: index - extra.length, text: item.text, domain: item.domain, priority: item.priority, deadline: null,
+          evidence: item.evidence ?? null, source: item.source,
+          created_at: new Date(morningCutoff - 1).toISOString(), sent_at: null,
+        }));
+      } catch (error) {
+        this.log('briefing.items', 'requirement-funnel-failed', { slot, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    const composed = composeBriefPage([...items, ...funnelItems], slot, now);
+    // Ephemeral funnel lines appear on the page but have no ledger row to mark sent.
+    const page = { markdown: composed.markdown, ids: composed.ids.filter(id => id > 0) };
+    const candidates = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)).length;
+    this.log('briefing.items', 'composed', { slot, candidates, bytes: Buffer.byteLength(page.markdown) });
+    return page;
+  }
+
+  /** Read-only page and the exact ledger item ids printed on it (after deduplication). */
+  composeWithIds(slot: string): { markdown: string; ids: number[] } {
     if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    const items = this.list();
-    const markdown = composeBriefMarkdown(items, slot as BriefSlot, this.now());
-    const included = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot as BriefSlot, this.now()));
-    this.log('briefing.items', 'composed', { slot, candidates: included.length, bytes: Buffer.byteLength(markdown) });
-    return markdown;
+    return this.using(db => this.pageFromDb(db, slot as BriefSlot));
+  }
+
+  /** Hold the ledger's SQLite writer lock from selecting unsent rows through delivery and marking.
+   * A failed delivery rolls back and releases the lock; the next sender can retry.
+   */
+  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSlot) => number) => T): T {
+    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+    return this.using(db => {
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const page = this.pageFromDb(db, slot as BriefSlot);
+        const result = work(page, (ids, sentSlot) => {
+          if (sentSlot !== slot || ids.length !== page.ids.length || ids.some((id, index) => id !== page.ids[index])) {
+            throw new BriefItemsInputError('marked ids must match composed page');
+          }
+          return this.markSentInDb(db, ids, sentSlot);
+        });
+        db.exec('COMMIT');
+        return result;
+      } catch (cause) {
+        db.exec('ROLLBACK');
+        throw cause;
+      }
+    });
+  }
+
+  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSlot): number {
+    const at = this.now().toISOString();
+    const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
+    let count = 0;
+    for (const id of ids) { insert.run(id, slot, at); count++; }
+    this.log('briefing.items', 'marked-sent', { slot, count });
+    return count;
   }
 
   /**
@@ -263,14 +340,6 @@ export class BriefItemsLedger {
    */
   markSent(ids: readonly number[], slot: BriefSlot): number {
     if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    const at = this.now().toISOString();
-    const count = this.using(db => {
-      const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
-      let n = 0;
-      db.transaction(() => { for (const id of ids) { insert.run(id, slot, at); n++; } })();
-      return n;
-    });
-    this.log('briefing.items', 'marked-sent', { slot, count });
-    return count;
+    return this.using(db => db.transaction(() => this.markSentInDb(db, ids, slot))());
   }
 }

package/src/cli/autopilot-cli.ts

@@ -6,7 +6,12 @@ import { writeStdoutJson } from './stdout-json.js';
 // runner. Spawns an ACP backend, opens a single session, runs the
 // AutopilotLoopDriver against the mission, prints agent deltas on
 // stdout + envelope/termination summary on stderr.
-export function registerAutopilotCommands(program: Command): void {
+export interface AutopilotCliDeps {
+  /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `task-agent-action` 이 부른다. */
+  registerSink?: (surface: string) => Promise<unknown>;
+}
+
+export function registerAutopilotCommands(program: Command, cliDeps: AutopilotCliDeps = {}): void {
   // Explicit runtime entry for a selected action; the task chooser can invoke this entry.
   const autopilotCmd = program
     .command('autopilot')
@@ -14,18 +19,28 @@ export function registerAutopilotCommands(program: Command): void {
   autopilotCmd.command('task-agent-action <actionJson>')
     .description('Execute a selected task-agent action; defaults to shadow')
     .action(async (actionJson: string) => {
+      // 독립 프로세스 — 싱크를 붙이지 않으면 `task-agent`/`action` 관측이 logs.db 에 안 닿는다(fail-open).
+      const { registerTaskAgentSink } = await import('./tasks-cli.js');
+      await registerTaskAgentSink(cliDeps.registerSink);
       const { executeNextAction } = await import('../task-agent/actions.js');
       const { getUserConfig } = await import('../user-config.js');
       const { spawnSync } = await import('node:child_process');
-      const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
+      const { writeFileSync, mkdirSync } = await import('node:fs');
+      // 상태 파일은 «없음»(ENOENT)만 빈 상태다 — 손상·해석 실패면 덮어쓰지 않고 멈춘다(사후 리뷰 must-fix · #24482).
+      const { readTaskAgentState, TaskAgentStateError } = await import('../task-agent/task-hand.js');
       const { join, dirname } = await import('node:path');
       const { debug } = await import('../debug/log.js');
       const { withFileLockSync } = await import('../storage/file-lock.js');
       const config = getUserConfig() as ReturnType<typeof getUserConfig> & { taskAgent?: { mode?: string } };
       const { effectiveInstanceRoot } = await import('../instance/resolve.js');
       const statePath = join(effectiveInstanceRoot(), 'task-agent-actions.json');
-      let state: { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> } = {};
-      try { state = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first run */ }
+      type ActionState = { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> };
+      let state: ActionState;
+      try { state = readTaskAgentState<ActionState>(statePath); } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+      }
       const action = JSON.parse(actionJson) as import('../task-agent/actions.js').NextAction;
       const deps: import('../task-agent/actions.js').ActionDeps = {
         ...state,
@@ -37,8 +52,7 @@ export function registerAutopilotCommands(program: Command): void {
         mode: config.taskAgent?.mode,
         // 하루 착지 칸은 상태 파일 잠금 안에서 확보·반환한다 — 두 CLI 프로세스가 같은 잔여 칸을 쓰지 않게.
         reserveLanding: (day, limit) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const disk = readTaskAgentState<ActionState>(statePath);
           const used = disk.landingDay === day ? disk.landingsToday ?? 0 : 0;
           if (used >= limit) return false;
           mkdirSync(dirname(statePath), { recursive: true });
@@ -47,8 +61,7 @@ export function registerAutopilotCommands(program: Command): void {
           return true;
         }),
         incrementFailure: (key) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const disk = readTaskAgentState<ActionState>(statePath);
           const counts = { ...(disk.failureCounts ?? {}) };
           counts[key] = (counts[key] ?? 0) + 1;
           mkdirSync(dirname(statePath), { recursive: true });
@@ -56,8 +69,7 @@ export function registerAutopilotCommands(program: Command): void {
           return counts[key]!;
         }),
         releaseLanding: (day) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { return; }
+          const disk = readTaskAgentState<ActionState>(statePath);
           if (disk.landingDay !== day || !disk.landingsToday) return;
           writeFileSync(statePath, JSON.stringify({ ...disk, landingsToday: disk.landingsToday - 1 }));
           deps.landingsToday = disk.landingsToday - 1;
@@ -72,7 +84,14 @@ export function registerAutopilotCommands(program: Command): void {
           return { status: p.status ?? 1, stdout: p.stdout ?? '', stderr: p.stderr ?? '' };
         },
       };
-      const result = await executeNextAction(action, deps);
+      let result: string;
+      try { result = await executeNextAction(action, deps); } catch (error) {
+        // 잠금 안 읽기가 손상을 만나면 쓰지 않고 여기로 온다 — 실패로 끝낸다. 그 밖의 오류는 종전대로 올린다.
+        if (!(error instanceof TaskAgentStateError)) throw error;
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+      }
       if (config.taskAgent?.mode === 'live') deps.saveState?.();
       process.stdout.write(`${result}\n`);
     });

package/src/cli/brief-cli.ts

@@ -1,5 +1,8 @@
 import type { Command } from 'commander';
-import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority } from '../briefing/brief-items.js';
+import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefSlot } from '../briefing/brief-items.js';
+import { kindRouteTarget } from '../domains/telegram-kind-route.js';
+import { sendTelegramReturningId } from '../autopilot/mission-notify.js';
+import { getUserConfig } from '../user-config.js';
 
 export interface BriefCliDeps {
   ledger?: BriefItemsLedger;
@@ -7,6 +10,7 @@ export interface BriefCliDeps {
   now?: () => Date;
   output?: (line: string) => void;
   error?: (line: string) => void;
+  send?: (markdown: string) => number | null;
 }
 
 export function registerBriefCommands(program: Command, deps: BriefCliDeps = {}): void {
@@ -20,7 +24,7 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
     error(`brief ${verb}: ${cause instanceof Error ? cause.message : String(cause)}`);
     process.exitCode = cause instanceof BriefItemsInputError ? 2 : 1;
   };
-  const brief = program.command('brief').description('대표 브리핑 항목 원장 — 발신자는 항목만 내고, 발송은 하지 않는다');
+  const brief = program.command('brief').description('대표 브리핑 항목 원장과 슬롯 발송');
 
   brief.command('add')
     .description('주장 한 줄을 원장에 추가한다 (원문 그대로)')
@@ -70,4 +74,34 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
       try { output(ledger().compose(opts.slot)); }
       catch (cause) { fail('compose', cause); }
     });
+
+  brief.command('send')
+    .description('슬롯 이전의 미발송 항목을 한 장 발송하고 성공한 항목만 표시한다')
+    .requiredOption('--slot <slot>', `슬롯 (${BRIEF_SLOTS.join('|')})`)
+    .option('--dry-run', '한 장만 출력하고 발송·표시하지 않는다')
+    .action((opts: { slot: string; dryRun?: boolean }) => {
+      try {
+        const store = ledger();
+        if (opts.dryRun) {
+          const { markdown, ids } = store.composeWithIds(opts.slot);
+          output(ids.length === 0 ? '(보낼 항목 없음)' : markdown);
+          return;
+        }
+        const result = store.withSendLock(opts.slot, ({ markdown, ids }, markSent) => {
+          if (ids.length === 0) return '(보낼 항목 없음)';
+          const send = deps.send ?? ((text: string) => {
+            const target = kindRouteTarget(getUserConfig(), 'ops-report');
+            if (!target) return null;
+            return sendTelegramReturningId(target.botToken, target.chatId, text);
+          });
+          const messageId = send(markdown);
+          if (typeof messageId !== 'number' || !Number.isFinite(messageId) || messageId <= 0) {
+            throw new Error('발송 실패: 양수 메시지 id 없음');
+          }
+          markSent(ids, opts.slot as BriefSlot);
+          return `sent ${messageId} (${ids.length} items)`;
+        });
+        output(result);
+      } catch (cause) { fail('send', cause); }
+    });
 }

package/src/cli/freeze-cli.ts

@@ -7,8 +7,9 @@ import { pendingFrozenMerges, sweepFrozenMerges } from '../self-implement/frozen
 export function registerFreezeCommands(program: Command): void {
   const freeze = program.command('freeze').description('착지 동결 상태 on/off/status');
   freeze.command('on').option('--reason <text>', '동결 이유').option('--until <timestamp>', '끝 시각(타임존 포함 ISO)')
+    .option('--hold-launches', '착지와 함께 새 하니스 launch도 보류')
     .option('--wait-seconds <n>', '이미 동결 검사를 지난 병합이 끝나기를 기다릴 최대 초', '600')
-    .action(async (opts: { reason?: string; until?: string; waitSeconds: string }) => {
+    .action(async (opts: { reason?: string; until?: string; holdLaunches?: boolean; waitSeconds: string }) => {
       const waitSeconds = Number(opts.waitSeconds);
       if (!/^\d+$/.test(opts.waitSeconds.trim()) || !Number.isSafeInteger(waitSeconds) || waitSeconds > 86_400) {
         throw new CliUserError(`잘못된 --wait-seconds: ${opts.waitSeconds}`, '0 이상 86400 이하의 정수 초');
@@ -34,7 +35,7 @@ export function registerFreezeCommands(program: Command): void {
     const state = readLandingFreeze();
     const pending = pendingFrozenMerges();
     if (opts.json) console.log(JSON.stringify({ frozen: state !== null, freeze: state, pendingMerges: pending }));
-    else console.log(`${state ? landingFreezeMessage(state) : '동결 없음'} · 보류 병합 ${pending}건`);
+    else console.log(`${state ? landingFreezeMessage(state) : '동결 없음'} · launch 보류 ${state?.holdLaunches === true ? '예' : '아니오'} · 보류 병합 ${pending}건`);
   });
 }
 

package/src/cli/intake-cli.ts

@@ -12,6 +12,9 @@ import { runGitCommand } from '../git-fs/runner.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
 import { registerIntakeSourceCommands } from './intake-source-cli.js';
+import type { IntakeItem } from '../intake-plane/items.js';
+import type { TaskCard } from '../task-cards/card-store.js';
+import { collectFunnelCandidates, type FunnelDirectiveRow } from '../intake-plane/requirement-funnel.js';
 
 export interface IntakeToTasksCliDeps {
   root: string;
@@ -21,6 +24,62 @@ export interface IntakeToTasksCliDeps {
   llm?: (input: IntakeTaskInput) => Promise<string>;
 }
 
+export interface IntakeCandidatesCliDeps {
+  directives?: () => FunnelDirectiveRow[] | Promise<FunnelDirectiveRow[]>;
+  intakeItems?: () => IntakeItem[] | Promise<IntakeItem[]>;
+  cards?: () => TaskCard[] | Promise<TaskCard[]>;
+  write?: (text: string) => Promise<void>;
+}
+
+/** `--limit` 원 문자열 → 0 이상의 정수. 숫자만(`/^\d+$/`) 받고 나머지('' · 공백 · 음수 · 소수)는 거부한다. */
+export function parseCandidatesLimit(raw: string): number {
+  const limit = /^\d+$/.test(raw) ? Number(raw) : NaN;
+  if (!Number.isSafeInteger(limit)) throw new Error(`--limit 는 0 이상의 정수여야 한다: ${JSON.stringify(raw)}`);
+  return limit;
+}
+
+export async function runIntakeCandidatesCli(
+  opts: { json?: boolean; limit?: string },
+  deps: IntakeCandidatesCliDeps = {},
+): Promise<void> {
+  // 원 문자열을 «먼저» 본다 — `Number('')`·`Number('  ')` 는 0 이라 빈 목록으로 조용히 통과한다.
+  const limit = opts.limit === undefined ? undefined : parseCandidatesLimit(opts.limit);
+  const directives = deps.directives ?? (async () => {
+    const [{ Database }, { existsSync }, { directiveDbPath }] = await Promise.all([
+      import('bun:sqlite'), import('node:fs'), import('../directives/directive-index.js'),
+    ]);
+    const path = directiveDbPath();
+    if (!existsSync(path)) return [];
+    const db = new Database(path, { readonly: true });
+    try { return db.query('SELECT * FROM directives ORDER BY ts DESC').all() as FunnelDirectiveRow[]; }
+    finally { db.close(); }
+  });
+  const intakeItems = deps.intakeItems ?? (async () => {
+    const [{ listIntakeItems }, { effectiveInstanceRoot }] = await Promise.all([
+      import('../intake-plane/items.js'), import('../instance/resolve.js'),
+    ]);
+    return listIntakeItems(effectiveInstanceRoot());
+  });
+  const cards = deps.cards ?? (async () => {
+    const [{ existsSync }, { CardStore, cardIndexPath }] = await Promise.all([
+      import('node:fs'), import('../task-cards/card-store.js'),
+    ]);
+    if (!existsSync(cardIndexPath())) return [];
+    const store = new CardStore(undefined, true);
+    try { return store.listCards({ open: true }); }
+    finally { store.close(); }
+  });
+  const all = collectFunnelCandidates({
+    directives: await directives(), intakeItems: await intakeItems(), cards: await cards(),
+  });
+  const candidates = limit === undefined ? all : all.slice(0, limit);
+  if (opts.json) await (deps.write ?? writeStdoutFully)(JSON.stringify({ candidates }) + '\n');
+  else await (deps.write ?? writeStdoutFully)([
+    `요구 후보 ${candidates.length}건`,
+    ...candidates.map((row) => `${row.source}\t${row.id}\t${row.score ?? '-'}\t${row.grade ?? '-'}\t${row.title}`),
+  ].join('\n') + '\n');
+}
+
 export interface IntakeDigestCliDeps {
   root?: string;
   annotateLens?: (root: string, day: string) => Promise<unknown>;
@@ -134,7 +193,7 @@ export function resolveIntakeCheckRoot(
   }
 }
 
-export function registerIntakeCommands(program: Command): void {
+export function registerIntakeCommands(program: Command, candidateDeps: IntakeCandidatesCliDeps = {}): void {
   // ── intake check — 바깥 사실을 elanous 현재와 대조 (태스크 등록 없음) ──
   const intakeCmd = program.command('intake').description('바깥 사실·문서를 elanous 현재와 대조하거나 태스크로 받는다');
   registerIntakeSourceCommands(intakeCmd);
@@ -229,6 +288,19 @@ export function registerIntakeCommands(program: Command): void {
       }
     });
 
+  intakeCmd
+    .command('candidates')
+    .description('지시·흡수·소원에서 읽기 전용 요구 후보를 모은다')
+    .option('--json', '구조화 출력')
+    .option('--limit <n>', '출력할 후보 상한')
+    .action(async (opts: { json?: boolean; limit?: string }) => {
+      if (opts.limit !== undefined) {
+        try { parseCandidatesLimit(opts.limit); }
+        catch (error) { console.error((error as Error).message); process.exitCode = 2; return; }
+      }
+      await runIntakeCandidatesCli(opts, candidateDeps);
+    });
+
   // 정기 외부 흡수 원장 — RFC-regular-external-intake-and-normalization-pipeline §3 (① 모양 · ② 중복).
   intakeCmd
     .command('collect-pod <dir>')

package/src/cli/notify-cli.ts

@@ -0,0 +1,75 @@
+import type { Command } from 'commander';
+import { inQuietHours, sendOutbound, userRecentlyActive } from '../domains/outbound-alert.js';
+import { isTradingKind } from '../domains/telegram-kind-route.js';
+
+export type NotifyPlan = { ok: true; kind: string } | { ok: false; exitCode: 2; message: string };
+
+export function planNotify({ kind = 'op-report', text }: { kind?: string; text: string }): NotifyPlan {
+  if (isTradingKind(kind)) {
+    return { ok: false, exitCode: 2, message: `매매 kind(${kind})는 운영 보고에 쓸 수 없습니다 — op-report 또는 ops-alert 를 쓰세요` };
+  }
+  if (!kind.trim() || /[\r\n]/.test(kind)) {
+    return { ok: false, exitCode: 2, message: 'kind 가 비었거나 줄바꿈을 포함합니다 — op-report 또는 ops-alert 를 쓰세요' };
+  }
+  if (!text.trim()) return { ok: false, exitCode: 2, message: '본문이 비었습니다 — elanous notify <text...> 또는 --stdin' };
+  return { ok: true, kind };
+}
+
+export interface NotifyCliDeps {
+  send?: (text: string, kind: string) => boolean | Promise<boolean>;
+  quiet?: () => boolean;
+  readStdin?: () => Promise<string>;
+  output?: (line: string) => void;
+  error?: (line: string) => void;
+  setExitCode?: (code: number) => void;
+}
+
+export function registerNotifyCommand(program: Command, deps: NotifyCliDeps = {}): void {
+  const send = deps.send ?? sendOutbound;
+  const quiet = deps.quiet ?? (() => inQuietHours() && !userRecentlyActive());
+  const readStdin = deps.readStdin ?? (async () => {
+    if (process.stdin.isTTY) throw new Error('--stdin requires redirected input');
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+  });
+  const output = deps.output ?? ((line: string) => console.log(line));
+  const error = deps.error ?? ((line: string) => console.error(line));
+  const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
+
+  program.command('notify [text...]')
+    .description('대표에게 운영 보고를 발송한다 (기본 kind: op-report)')
+    .option('--kind <kind>', '운영 알림 kind (매매 report|alert|digest 거부)')
+    .option('--stdin', '본문을 표준 입력에서 읽는다')
+    .option('--json', '결과를 JSON 한 줄로 출력한다')
+    .action(async (parts: string[], opts: { kind?: string; stdin?: boolean; json?: boolean }) => {
+      const kind = opts.kind ?? 'op-report';
+      if (opts.stdin && parts.length) {
+        if (opts.json) output(JSON.stringify({ ok: false, kind, chars: 0, deferred: false }));
+        else error('--stdin 과 본문 인자는 함께 쓸 수 없습니다');
+        setExitCode(2);
+        return;
+      }
+      try {
+        const text = opts.stdin ? await readStdin() : parts.join(' ');
+        const plan = planNotify({ kind, text });
+        if (!plan.ok) {
+          if (opts.json) output(JSON.stringify({ ok: false, kind, chars: [...text].length, deferred: false }));
+          else error(plan.message);
+          setExitCode(plan.exitCode);
+          return;
+        }
+        const deferred = quiet();
+        const ok = await send(text, plan.kind);
+        const chars = [...text].length;
+        if (opts.json) output(JSON.stringify({ ok, kind: plan.kind, chars, deferred: ok && deferred }));
+        else if (ok) output(`${deferred ? '보류됨' : '보냄'}(${plan.kind}) · ${chars}자`);
+        else error(`못 보냄(${plan.kind}) — elanous logs --category outbound.send 로 확인`);
+        setExitCode(ok ? 0 : 1);
+      } catch {
+        if (opts.json) output(JSON.stringify({ ok: false, kind, chars: 0, deferred: false }));
+        else error(`못 보냄(${kind}) — elanous logs --category outbound.send 로 확인`);
+        setExitCode(1);
+      }
+    });
+}

package/src/cli/provider-cli.ts

@@ -398,8 +398,18 @@ export function registerProviderCommands(program: Command): void {
     .command('refresh <name>')
     .description('그 계정의 codex 토큰을 호스트에서 갱신해 정본 스토어로 반영한다 (⛔ default 거부 · 토큰 값은 안 찍는다 · ⚠️ refresh 토큰은 갱신마다 회전 — 본부 한 곳에서만)')
     .action(async (name: string) => {
-      const { refreshCodexAccountHome } = await import('../oauth/codex.js');
-      const r = await refreshCodexAccountHome(name);
+      const { refreshCodexAccountHome, codexAccountRefreshLockPath, withCodexAccountRefreshLock, CodexRefreshLockUnavailableError } = await import('../oauth/codex.js');
+      // PREREFRESH-LOCK: the same per-account lock as the Pod pre-refresh — a hand refresh never races a launch.
+      // 이름 있는 계정의 잠금 자리를 못 구하면 잠금 없이 갱신하지 않는다(Pod 선갱신과 경합하는 자리) — default 는 refreshCodexAccountHome 이 거부한다.
+      const lockPath = name === 'default' ? null : codexAccountRefreshLockPath(name);
+      if (name !== 'default' && !lockPath) { console.error(`갱신 거부: ${name} 의 잠금 자리를 못 구했다(계정 홈 없음) — 잠금 없이 갱신하지 않는다`); process.exitCode = 1; return; }
+      let r: Awaited<ReturnType<typeof refreshCodexAccountHome>>;
+      try { r = await withCodexAccountRefreshLock(lockPath, () => refreshCodexAccountHome(name)); }
+      catch (lockError) {
+        if (!(lockError instanceof CodexRefreshLockUnavailableError)) throw lockError;
+        const why = lockError.reason === 'lock-timeout' ? '다른 갱신이 진행 중 — 잠시 뒤 다시' : `잠금 파일을 못 만들었다: ${lockError.message}`;
+        console.error(`갱신 거부: ${name} 의 갱신 잠금을 못 잡았다(${why})`); process.exitCode = 1; return;
+      }
       if (!r.ok) { console.error(`갱신 실패(${r.kind}): ${r.message}`); process.exitCode = 1; return; }
       const h = (v: number | null) => (v === null ? '?' : `${v}h`);
       console.log(`✅ ${name} 갱신 — 남은 시간 ${h(r.beforeH)} → ${h(r.afterH)} · storeKey=${r.storeKey}`);