elanous 0.2.16 → 0.2.18

package/src/agent-substrate/pr-comment-meta.ts

@@ -97,3 +97,23 @@ export function parse(body: string): PrCommentMeta | null {
   }
   return parsed;
 }
+
+/** 상태 댓글의 details 에 쌓인 라운드 기록을 개별 댓글 본문으로 펼친다. */
+export function expandRecords(body: string): string[] {
+  if (!/^<!-- elanous:run-status -->(?:\r?\n|$)/.test(body)) return [body];
+
+  const records: string[] = [];
+  for (const details of body.matchAll(/<details(?:\s[^>]*)?>([\s\S]*?)<\/details>/g)) {
+    const content = details[1];
+    const headers: Array<{ index: number; round?: number }> = [];
+    for (const header of content.matchAll(/^<!-- elanous-pr-comment v1 [^\r\n]* -->$/gm)) {
+      const meta = parse(header[0]);
+      if (meta) headers.push({ index: header.index, round: meta.round });
+    }
+    for (let i = 0; i < headers.length; i++) {
+      if (headers[i].round === undefined) continue;
+      records.push(content.slice(headers[i].index, headers[i + 1]?.index ?? content.length).replace(/(?:\r?\n)+$/, ''));
+    }
+  }
+  return records.length ? records : [body];
+}

package/src/autopilot/build/llm-conflict-merge.ts

@@ -67,8 +67,10 @@ export interface LlmMergeOutcome {
   testDeclarationUnmeasured?: string[];
   /** 해결기 응답이 LLM 공급자 오류 문구였다 — 파일 내용이 아니다(🅢 2026-09-27 #21086: 세 파일이 통째로 그 문구가 됐다). */
   providerFailure?: string[];
-  /** LLM 입력 상한 초과: 사람 수확으로 넘긴다. 원래 브랜치는 abort 후 보존된다. */
-  reason?: 'conflict-input-too-large' | 'conflict-resolver-interrupted';
+  /** 충돌 미해결의 원인. 기존 두 원인에 마커 잔존·파일 읽기 실패를 추가한다. */
+  reason?: 'conflict-input-too-large' | 'conflict-resolver-interrupted' | 'conflict-markers-remain' | 'conflict-file-unreadable';
+  /** 해결이 멎은 충돌 파일(worktree 상대 경로). */
+  failedFile?: string;
   inputChars?: number;
   /** 병합 결과가 양쪽 판 중 작은 쪽의 절반 아래로 줄었다 — 통째로 날린 것으로 보고 해결 실패로 친다. */
   sizeCollapse?: Array<{ file: string; ours: number; theirs: number; merged: number }>;
@@ -107,6 +109,20 @@ function addSizeChange(size: LlmMergeSizeChange, file: string, before: string, a
 
 export function formatLlmMergeOutcome(outcome: LlmMergeOutcome): string {
   const files = outcome.resolvedFiles?.length ? ` (LLM 종합 ${outcome.resolvedFiles.length}파일: ${outcome.resolvedFiles.join(', ')})` : '';
+  if (outcome.status === 'conflict-unresolved') {
+    // ⛔ reason·failedFile 은 «선택» 칸이다 — 공급자 오류·시험 선언 유실·크기 붕괴 출구는 계약상 reason 이 없다.
+    //   있는 칸만 싣고, 그 출구들은 자기 실제 결과(어느 판정이 멈췄나)를 싣는다 — 「사유 undefined」 금지.
+    const parts = [
+      ...(outcome.reason ? [`사유 ${outcome.reason}`] : []),
+      ...(outcome.failedFile ? [`파일 ${outcome.failedFile}`] : []),
+      ...(outcome.providerFailure?.length ? [`공급자 오류 문구 ${outcome.providerFailure.join(', ')}`] : []),
+      ...(outcome.testDeclarationLoss?.length
+        ? [`시험 선언 유실 ${outcome.testDeclarationLoss.map((l) => `${l.file} ${l.ours}/${l.theirs}→${l.merged}`).join(', ')}`] : []),
+      ...(outcome.sizeCollapse?.length
+        ? [`크기 붕괴 ${outcome.sizeCollapse.map((c) => `${c.file} ${c.ours}/${c.theirs}→${c.merged}줄`).join(', ')}`] : []),
+    ];
+    return `${outcome.status}${files}${parts.length ? `; ${parts.join(' · ')}` : ''}`;
+  }
   if (outcome.status !== 'llm-resolved') return `${outcome.status}${files}`;
   const size = outcome.sizeChange;
   if (size === undefined) return `${outcome.status}${files}; 규모 변화: 못 쟀다`;
@@ -211,6 +227,10 @@ export async function mergeMainWithLlmResolve(
     ...outcome,
     ...(testDeclarationUnmeasured.length ? { testDeclarationUnmeasured } : {}),
   });
+  const unresolved = (outcome: LlmMergeOutcome & { status: 'conflict-unresolved'; failedFile: string }): LlmMergeOutcome => {
+    debug.log('self-dev.merge', 'conflict-unresolved', { reason: outcome.reason, failedFile: outcome.failedFile, resolvedCount: resolvedFiles.length });
+    return measuredOutcome(outcome);
+  };
   for (const f of files) {
     const abs = join(worktreePath, f);
     let conflicted: string;
@@ -219,7 +239,7 @@ export async function mergeMainWithLlmResolve(
       conflicted = git.readFile(abs);
     } catch {
       git.abort(worktreePath);
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
+      return unresolved({ status: 'conflict-unresolved', reason: 'conflict-file-unreadable', failedFile: f, resolvedFiles });
     }
     try {
       // release/next.md: concurrent landings each append a line — keep both without asking the LLM (REL7c).
@@ -227,7 +247,7 @@ export async function mergeMainWithLlmResolve(
       merged = deterministic ?? await resolve(f, conflicted);
     } catch (error) {
       git.abort(worktreePath); // LLM 예외 → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles,
+      return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f,
         ...(error instanceof MergeConflictInputTooLarge
           ? { reason: 'conflict-input-too-large' as const, inputChars: error.inputChars }
           : { reason: 'conflict-resolver-interrupted' as const }),
@@ -235,11 +255,11 @@ export async function mergeMainWithLlmResolve(
     }
     if (PROVIDER_FAILURE_TEXT.test(merged)) {
       git.abort(worktreePath); // 해결기가 공급자 오류 문구를 «내용»으로 돌려줬다 → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, providerFailure: [f] });
+      return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, providerFailure: [f] });
     }
     if (hasConflictMarkers(merged)) {
       git.abort(worktreePath); // LLM 이 종합 못 함(마커 잔존) → base 유지
-      return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });
+      return unresolved({ status: 'conflict-unresolved', reason: 'conflict-markers-remain', failedFile: f, resolvedFiles });
     }
     try {
       const ours = countTestDeclarations(git.readIndexStage(worktreePath, 2, f));
@@ -248,7 +268,7 @@ export async function mergeMainWithLlmResolve(
       if (mergedDeclarations < Math.min(ours, theirs)) {
         const testDeclarationLoss = [{ file: f, ours, theirs, merged: mergedDeclarations }];
         git.abort(worktreePath);
-        return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, testDeclarationLoss });
+        return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, testDeclarationLoss });
       }
     } catch {
       testDeclarationUnmeasured.push(f);
@@ -260,7 +280,7 @@ export async function mergeMainWithLlmResolve(
       const smaller = Math.min(ours, theirs);
       if (smaller >= SIZE_COLLAPSE_MIN_LINES && mergedLines * 2 < smaller) {
         git.abort(worktreePath); // 양쪽 판 모두보다 절반 넘게 작다 → 통째로 날렸다 → base 유지
-        return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles, sizeCollapse: [{ file: f, ours, theirs, merged: mergedLines }] });
+        return unresolved({ status: 'conflict-unresolved', resolvedFiles, failedFile: f, sizeCollapse: [{ file: f, ours, theirs, merged: mergedLines }] });
       }
     } catch {
       /* 한쪽 판이 없는 충돌(삭제·추가) — 크기 비교 대상이 아니다 */

package/src/autopilot/track-agent.ts

@@ -47,7 +47,9 @@ const runCli = async (args: string[]): Promise<{ stdout: string }> => {
   const { argv, env } = universeLaunch(args);
   return exec('bun', argv, { cwd: repoDir(), env, timeout: 120_000, maxBuffer: 1024 * 1024, encoding: 'utf8' });
 };
-const forbiddenActionRegex = /\b(?:delete|remove|deploy|publish|release|restart|reboot|merge|force|pay|purchase|secret|credential|sudo|rm\s+-rf|config\s+set)\b|(?:^|\s)--prod\b|삭제|배포|게시|릴리스|재시작|재부팅|병합|결제|자격|비밀|강제/i;
+// A work topic containing a verb is not necessarily an instruction; the guard matches executable requests.
+// Security words (secret · credential · force · 자격 · 비밀 · 강제) stay blocked anywhere — topic or request (UX harvest).
+const forbiddenActionRegex = /\b(?:delete|remove|deploy|publish|release|restart|reboot|merge|pay|purchase|sudo)\b(?=\s+(?:the\s+(?:branch|site|app|release|file|record)\b|(?:this\s+)?branch\b|(?:to|into)\s+main\b|main\b|now\b|(?:site|app)\b))|\bcut\s+a\s+release\b|\brm\s+-rf\b|\bconfig\s+set\b|\b(?:secret|credential|force|sudo)\b|자격|비밀|강제|(?:^|\s)--prod\b|(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제|강제)(?:해라|하세요|해줘|하라|해\s*주세요|하시오)(?!\S)|(?:^\s*|후\s*)(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제)(?=\s*$|\s*후\s*)|(?:^\s*운영\s*(?:배포|재시작)(?=\s*$))|(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제)(?=\s*(?:해|실행|진행)(?:\s|$))/iu;
 export const TRACK_AGENT_FORBIDDEN_ACTION_REGEX = new RegExp(forbiddenActionRegex.source, forbiddenActionRegex.flags);
 let running = 0;
 
@@ -101,7 +103,7 @@ async function decideTrackActionOnce(input: TrackAgentInput, deps: RunnerDeps):
     const values = decision as Record<string, unknown>;
     if (!['say', 'hold'].includes(String(values.action)) || (values.reason !== undefined && typeof values.reason !== 'string')
       || Object.keys(values).some((key) => !['action', 'reason'].includes(key))) throw new Error('invalid decision');
-    if (typeof values.reason === 'string' && forbiddenActionRegex.test(values.reason)) throw new Error('forbidden action');
+    if (values.action === 'say' && typeof values.reason === 'string' && forbiddenActionRegex.test(values.reason)) throw new Error('forbidden action');
     return decision as TrackAgentDecision;
   } catch (error) {
     log('decision-failed', { track: input.track, taskId: input.taskId, error: redactSecretText(String(error)) });
@@ -111,7 +113,7 @@ async function decideTrackActionOnce(input: TrackAgentInput, deps: RunnerDeps):
 
 export async function executeTrackAction(decision: TrackAgentDecision, input: TrackAgentInput, deps: RunnerDeps = {}): Promise<TrackAgentResult> {
   if (decision.action !== 'say') return { status: 'held', detail: decision.reason ?? '사람 확인' };
-  if (forbiddenActionRegex.test(`${input.title}\n${input.prompt}`)) return { status: 'held', detail: '금지 작업 — 사람 확인' };
+  if (forbiddenActionRegex.test(input.prompt)) return { status: 'held', detail: '금지 작업 — 사람 확인' };
   if (!findTrack(input.track)) return { status: 'held', detail: '트랙 미정 — 사람 확인' };
   try {
     const checkBudget = deps.checkBudget ?? (async () => {

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,10 +6,95 @@ 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')
     .description('Mission-driven autopilot — runs an ACP agent against a single mission with safety + budget guards');
+  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 { 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');
+      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,
+        failureCounts: state.failureCounts ?? {},
+        saveState: () => {
+          mkdirSync(dirname(statePath), { recursive: true });
+          // 실패 횟수는 incrementFailure 가 잠금 안에서 키별로 더한다 — 여기선 덮어쓰지 않는다.
+        },
+        mode: config.taskAgent?.mode,
+        // 하루 착지 칸은 상태 파일 잠금 안에서 확보·반환한다 — 두 CLI 프로세스가 같은 잔여 칸을 쓰지 않게.
+        reserveLanding: (day, limit) => withFileLockSync(`${statePath}.lock`, () => {
+          const disk = readTaskAgentState<ActionState>(statePath);
+          const used = disk.landingDay === day ? disk.landingsToday ?? 0 : 0;
+          if (used >= limit) return false;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, landingDay: day, landingsToday: used + 1 }));
+          deps.landingDay = day; deps.landingsToday = used + 1;
+          return true;
+        }),
+        incrementFailure: (key) => withFileLockSync(`${statePath}.lock`, () => {
+          const disk = readTaskAgentState<ActionState>(statePath);
+          const counts = { ...(disk.failureCounts ?? {}) };
+          counts[key] = (counts[key] ?? 0) + 1;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, failureCounts: counts }));
+          return counts[key]!;
+        }),
+        releaseLanding: (day) => withFileLockSync(`${statePath}.lock`, () => {
+          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;
+        }),
+        observe: (_event, data) => debug.log('task-agent', 'action', data),
+        command: async args => {
+          const p = args[0] === 'gh'
+            // PR 조회는 착지할 작업 트리에서 — 다른 저장소에서 불러도 엉뚱한 PR 을 읽지 않게.
+            ? spawnSync('gh', args.slice(1), { encoding: 'utf8', ...(action.cwd ? { cwd: action.cwd } : {}) })
+            // 지금 돌고 있는 진입점으로 부른다 — 저장소 밖(설치본)에서 불러도 같은 elanous 를 쓴다.
+            : spawnSync(process.execPath, [process.argv[1]!, ...(process.argv.includes('--test') ? ['--test'] : []), ...args], { encoding: 'utf8' });
+          return { status: p.status ?? 1, stdout: p.stdout ?? '', stderr: p.stderr ?? '' };
+        },
+      };
+      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`);
+    });
 
 autopilotCmd
   .command('run <mission...>')

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/decisions-cli.ts

@@ -53,6 +53,7 @@ export function formatDecisionDetail(e: DecisionEntry): string {
       ...(e.note ? [`메모: ${e.note}`] : [])] : []),
     ...(e.withdrawnAt ? [`철회: ${kst(e.withdrawnAt)} · ${e.withdrawReason}`] : []),
     '이력:', ...e.history.map(h => `  ${h.type} · ${h.at ? kst(h.at) : '시각 미상'} · ${h.by}${h.choice ? ` · ${h.choice}` : ''}${h.reason ? ` · ${h.reason}` : ''} · ${h.version ? version(h.version) : '판 미상'}`),
+    ...(e.pendingQuestion ? [`판단 재료:\n${e.pendingQuestion}`] : []),
     ...(e.refs?.length ? [`참조: ${e.refs.join(' · ')}`] : [])].join('\n');
 }
 
@@ -86,6 +87,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
   root.command('raise').description('SCQA·선택지와 권고로 결정 항목을 올린다')
     .requiredOption('--title <text>').requiredOption('--category <category>')
     .requiredOption('--s <text>').requiredOption('--c <text>').option('--q <text>').option('--a <text>')
+    .option('--pending-question <text>', '판단 재료 전문 (무엇·지금까지·재측·선택지별 결과·권고·확신·그냥 두면·근거)')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--xcheck <SEAT:메모>', '교차 확인 (반복)', repeat, [] as string[])
@@ -96,7 +98,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
     .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
     .option('--json').option('--hq-override')
-    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; xcheck: string[]; noXcheck?: string; alternative?: string; dissent?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean; hqOverride?: boolean }) => fail(() => {
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; pendingQuestion?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; xcheck: string[]; noXcheck?: string; alternative?: string; dissent?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean; hqOverride?: boolean }) => fail(() => {
       if (o.run !== undefined && o.resumeQuestion === undefined) throw new Error('--run requires --resume-question');
       if (o.skipRecommend !== undefined && (o.recommend !== undefined || o.why !== undefined)) throw new Error('choose recommendation or skip, not both');
       if (o.skipRecommend === undefined && (!o.recommend || !o.why)) throw new Error('--recommend and --why required, or --skip-recommend <reason>');
@@ -111,6 +113,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       const who = agent(o.agent);
       if (!mayWrite('raise', o.hqOverride)) return;
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
+        ...(o.pendingQuestion ? { pendingQuestion: o.pendingQuestion } : {}),
         ...(crossCheck.length ? { crossCheck } : { crossCheckSkipped: o.noXcheck ?? 'missing' }),
         ...(o.alternative !== undefined ? { alternative: o.alternative } : {}), ...(o.dissent !== undefined ? { dissent: o.dissent } : {}),
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },

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>;
@@ -102,7 +161,7 @@ export async function runIntakeDigestCli(
   }
   const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
   if (opts.telegram) {
-    if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    if (!d.absorbed.length && !d.news?.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
     const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
     const sent = deps.sendTelegram
       ? await deps.sendTelegram(text)
@@ -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/log-event-names.ts

@@ -1064,6 +1064,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "redecompose-opus-tap",
   "redecompose-respawn",
   "redecompose-tap",
+  "reemit-target",
   "reflect.done",
   "refresh-attempt",
   "refused",