elanous 0.2.5 → 0.2.7

package/src/cli/release-cli.ts

@@ -5,6 +5,7 @@
 //   elanous release tag --version <x.y.z> --source <commit> [--yes]
 //   elanous release verify  [--version <x.y.z>]
 //   elanous release notes   --from <ref> [--to <ref>]
+//   elanous release run     --version <x.y.z> [--dry-run] [--json] [--if-ready]
 //
 // 🩸 계기(2026-09-25 v0.1.0 첫 공개): 손으로 밟은 절차에서 둘을 빠뜨릴 뻔했다 — 공개본 git 커밋(판 커밋이 공개본 커밋이 된다) ·
 //    PWA 빌드(빌드 산출은 공개본에 안 실린다 → 빠뜨리면 «웹 화면 없는 판»). 절차를 명령으로 굳힌다.
@@ -22,7 +23,11 @@ import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, devVersion, listChecklist, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus } from '../release-loop/checklist.js';
+import { addItem, devVersion, listChecklist, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition } from '../release-loop/checklist.js';
+import { writeStdoutJson } from './stdout-json.js';
+import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
+import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
+import { runReleaseIfReady } from './release-run-if-ready.js';
 
 export const DEFAULT_PUBLIC_REPO = 'ElanvitalAI/elanous';
 const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
@@ -466,11 +471,11 @@ function checklistVersion(input: string | undefined, codenames: Record<string, s
   return resolved;
 }
 
-function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean): void {
+async function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean): Promise<void> {
   const data = listChecklist(v);
   const summary = summarizeChecklist(data);
   const result = { ...data, codename: codenames[v] ?? '', ...summary };
-  if (json) { console.log(JSON.stringify(result)); return; }
+  if (json) { await writeStdoutJson(`${JSON.stringify(result)}\n`); return; }
   console.log(`${v}${result.codename ? ` (${result.codename})` : ''} · 공개 ${data.released || '없음'} · 개발 ${data.dev}`);
   if (mode === 'list') {
     for (const item of data.items) console.log(`${({ green: '🟢', yellow: '🟡', red: '🔴', done: '✅' } as const)[item.status]} ${item.id} ${item.title}${item.owner ? ` · ${item.owner}` : ''}`);
@@ -481,7 +486,7 @@ function checklistOutput(v: string, codenames: Record<string, string>, mode: 'li
   }
 }
 
-export function registerReleaseCommands(program: Command): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
     .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')
@@ -492,26 +497,28 @@ export function registerReleaseCommands(program: Command): void {
     return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
   };
   const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON');
-  withContext(checklist.command('list').description('모든 칸')).action((_opts: unknown, cmd: Command) => {
+  withContext(checklist.command('list').description('모든 칸')).action(async (_opts: unknown, cmd: Command) => {
     const { version, codenames, json } = context(cmd);
-    checklistOutput(version, codenames, 'list', json);
+    await checklistOutput(version, codenames, 'list', json);
   });
-  withContext(checklist.command('status').description('상태 요약')).action((_opts: unknown, cmd: Command) => {
+  withContext(checklist.command('status').description('상태 요약')).action(async (_opts: unknown, cmd: Command) => {
     const { version, codenames, json } = context(cmd);
-    checklistOutput(version, codenames, 'status', json);
+    await checklistOutput(version, codenames, 'status', json);
   });
   withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').action((id: string, title: string, opts: { owner?: string }, cmd: Command) => {
     const { version, json } = context(cmd);
     const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}) });
     if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 추가`);
   });
-  withContext(checklist.command('set <id>').description('칸 상태·근거·담당 갱신'))
+  withContext(checklist.command('set <id>').description('칸 상태·근거·담당·처분 갱신'))
     .option('--status <status>', 'green|yellow|red|done').option('--evidence <evidence>', '근거').option('--owner <owner>', '담당')
-    .action((id: string, opts: { status?: string; evidence?: string; owner?: string }, cmd: Command) => {
+    .option('--disposition <disposition>', 'move|known-issue|block')
+    .action((id: string, opts: { status?: string; evidence?: string; owner?: string; disposition?: string }, cmd: Command) => {
       const { version, json } = context(cmd);
       if (opts.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(opts.status)) throw new Error(`잘못된 상태: ${opts.status}`);
-      if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined) throw new Error('갱신할 칸을 지정하라');
-      const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}) }, process.env.ELANOUS_TRACK || 'cli');
+      if (opts.disposition !== undefined && !['move', 'known-issue', 'block'].includes(opts.disposition)) throw new Error(`잘못된 처분: ${opts.disposition}`);
+      if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined && opts.disposition === undefined) throw new Error('갱신할 칸을 지정하라');
+      const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.disposition !== undefined ? { disposition: opts.disposition as ChecklistDisposition } : {}) }, process.env.ELANOUS_TRACK || 'cli');
       if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 갱신`);
     });
   withContext(checklist.command('rm <id>').description('칸 삭제')).action((id: string, _opts: unknown, cmd: Command) => {
@@ -584,4 +591,41 @@ export function registerReleaseCommands(program: Command): void {
       const { draftReleaseNotes, readLandedCommits, renderReleaseNotes } = await import('../../scripts/release-notes.js');
       console.log(renderReleaseNotes(draftReleaseNotes(readLandedCommits(o.from, o.to), o.from, o.to)));
     });
+  release.command('run')
+    .description('릴리스 루프 실행 — 원장 직전 판과 release.loop 설정으로 그래프 입력 구성 · --dry-run 은 입력만 출력')
+    .requiredOption('--version <v>', '공개할 판(x.y.z)')
+    .option('--dry-run', '체크리스트·그래프 실행 없이 전체 입력 보기')
+    .option('--if-ready', '준비되지 않았으면 사유를 출력하고 성공으로 건너뛴다')
+    .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
+    .action(async (o: { version: string; dryRun?: boolean; ifReady?: boolean; json?: boolean }) => {
+      if (o.ifReady && !o.dryRun) {
+        try {
+          const outcome = await runReleaseIfReady(o.version, {
+            ledgerRoot: releaseRunDeps.ledgerRoot,
+            readiness: (version, options) => releaseReadiness(version, { ledgerRoot: releaseRunDeps.ledgerRoot, checklist: releaseRunDeps.checklist, ...options }),
+            run: () => runUnattendedRelease({ version: o.version }, releaseRunDeps),
+          });
+          if (outcome.skipped) {
+            if (o.json) await writeStdoutJson(`${JSON.stringify(outcome)}\n`);
+            else console.log(`· 준비 안 됨 ${o.version} · ${outcome.reason} · ${outcome.detail}`);
+            return;
+          }
+          const result = outcome.result;
+          const ok = result.dryRun || result.state?.status === 'done' || result.state?.status === 'awaiting-approval';
+          (o.json ? console.error : console.log)(`${result.dryRun ? '· 드라이런' : '▶ 릴리스 루프'} ${result.input.version} · 입력 ${JSON.stringify(result.input)}`);
+          if (o.json) await writeStdoutJson(`${JSON.stringify({ ok, ...result })}\n`);
+          if (!ok && !process.exitCode) process.exitCode = 1;
+        } catch (e) {
+          if (o.json) await writeStdoutJson(`${JSON.stringify({ ok: false, error: (e as Error).message })}\n`);
+          else console.error(`⛔ ${(e as Error).message}`);
+          process.exitCode = 1;
+        }
+        return;
+      }
+      await jsonAction(o.json, async (log) => {
+        const result = await runUnattendedRelease({ version: o.version, dryRun: o.dryRun }, releaseRunDeps);
+        log(`${result.dryRun ? '· 드라이런' : '▶ 릴리스 루프'} ${result.input.version} · 입력 ${JSON.stringify(result.input)}`);
+        return result;
+      }, (r) => r.dryRun || r.state?.status === 'done' || r.state?.status === 'awaiting-approval');
+    });
 }

package/src/cli/release-run-if-ready.ts

@@ -0,0 +1,48 @@
+import { closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import type { ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
+
+export type ReleaseIfReadySkip = { skipped: true; reason: Exclude<ReleaseReadiness, { ready: true }>['reason']; detail: string };
+
+export async function runReleaseIfReady<T>(version: string, deps: {
+  readiness: (version: string, options?: { isPidAlive?: (pid: number) => boolean }) => ReleaseReadiness | Promise<ReleaseReadiness>;
+  run: () => Promise<T>;
+  ledgerRoot?: string;
+  pid?: number;
+  now?: () => Date;
+}): Promise<ReleaseIfReadySkip | { skipped: false; result: T }> {
+  const skip = (readiness: Exclude<ReleaseReadiness, { ready: true }>): ReleaseIfReadySkip => {
+    const detail = readiness.reason === 'checklist-blocked'
+      ? [...readiness.details.red, ...readiness.details.undecided, ...readiness.details.blocked].join(', ')
+      : readiness.details;
+    debug.log('release-loop.readiness', readiness.reason, { version, detail });
+    return { skipped: true, reason: readiness.reason, detail };
+  };
+  const readiness = await deps.readiness(version);
+  if (!readiness.ready) return skip(readiness);
+
+  const dir = join(deps.ledgerRoot ?? releaseLedgerRoot(), 'release', version);
+  mkdirSync(dir, { recursive: true });
+  const lock = join(dir, 'run.lock');
+  let fd: number;
+  try { fd = openSync(lock, 'wx', 0o600); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+    const detail = 'run.lock already exists';
+    debug.log('release-loop.readiness', 'already-running', { version, detail });
+    return { skipped: true, reason: 'already-running', detail };
+  }
+  try {
+    writeFileSync(fd, `${JSON.stringify({ pid: deps.pid ?? process.pid, startedAt: (deps.now ?? (() => new Date()))().toISOString() })}\n`);
+    // This call still checks publication and checklist, but must not treat our own lock as another runner.
+    const insideLock = await deps.readiness(version, { isPidAlive: () => false });
+    if (!insideLock.ready) return skip(insideLock);
+    debug.log('release-loop.readiness', 'ready', { version });
+    return { skipped: false, result: await deps.run() };
+  } finally {
+    closeSync(fd);
+    rmSync(lock);
+  }
+}

package/src/cli/setup-cli.ts

@@ -1,9 +1,10 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import type { Command } from 'commander';
-import { formatDoctorReport, runDoctor, type DoctorOptions, type DoctorReport } from './doctor-cli.js';
+import { Command } from 'commander';
+import { formatDoctorReport, registerDoctorCommand, runDoctor, type DoctorOptions, type DoctorReport } from './doctor-cli.js';
 import { applyClaudePluginSetup, planClaudePluginSetup } from './claude-plugin-setup.js';
+import { recommendedSetup } from './setup-recommend.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig, saveUserConfig, type UserConfig } from '../user-config.js';
 
@@ -20,6 +21,7 @@ type SetupStep = {
 
 export interface SetupCliDeps extends DoctorOptions {
   runDoctor?: (options: DoctorOptions) => DoctorReport;
+  runDoctorFix?: (args: readonly string[]) => Promise<number>;
   readFile?: (path: string) => string;
   exists?: (path: string) => boolean;
   homeDir?: () => string;
@@ -154,14 +156,16 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
   const setup = program.command('setup')
     .description('Check OpenAI Codex setup and guide each missing credential step')
     .option('--non-interactive', 'Report setup state without prompts or writes')
-    .action(async (opts: { nonInteractive?: boolean }) => {
+    .option('--yes', 'Set a missing Codex provider and apply recommended doctor repairs without asking')
+    .action(async (opts: { nonInteractive?: boolean; yes?: boolean }) => {
       const doctor = doctorRunner(deps);
       if (opts.nonInteractive) {
         out.log(formatSetupReport(doctor, setupSteps(deps), true));
+        for (const line of recommendedSetup((deps.getUserConfig ?? getUserConfig)())) out.log(line);
         setExitCode(0);
         return;
       }
-      if (!isStdinTty()) {
+      if (!isStdinTty() && !opts.yes) {
         (out.error ?? out.log)('대화형 온보딩은 stdin TTY가 있는 자리에서만 실행할 수 있다. 무인 설정은 `elanous setup --non-interactive`를 사용하라.');
         setExitCode(1);
         return;
@@ -169,8 +173,8 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
       let steps = setupSteps(deps);
       const provider = steps[1]!;
       if (!provider.complete) {
-        const answer = await prompt('Set llm.provider to openai-codex now? [y/N] ');
-        if (answer?.trim().toLowerCase() === 'y') {
+        const approved = opts.yes || (await prompt('Set llm.provider to openai-codex now? [y/N] '))?.trim().toLowerCase() === 'y';
+        if (approved) {
           const config = (deps.getUserConfig ?? getUserConfig)();
           (deps.saveUserConfig ?? saveUserConfig)({ ...config, llm: { ...config.llm, provider: 'openai-codex' } });
           steps = setupSteps(deps);
@@ -179,6 +183,23 @@ export function registerSetupCommand(program: Command, deps: SetupCliDeps = {}):
         }
       }
       out.log(formatSetupReport(doctor, steps, false));
+      for (const line of recommendedSetup((deps.getUserConfig ?? getUserConfig)())) out.log(line);
+      const accepted = opts.yes || (isStdinTty() && /^(?:y|yes)?$/i.test((await prompt('추천대로 켤까요? [Y/n] '))?.trim() ?? 'n'));
+      if (accepted) {
+        const runDoctorFix = deps.runDoctorFix ?? (async (args: readonly string[]) => {
+          const doctorProgram = new Command();
+          let exitCode = 0;
+          registerDoctorCommand(doctorProgram, {
+            out,
+            err: { error: (message) => (out.error ?? out.log)(message) },
+            setExitCode: (code) => { exitCode = code; },
+          });
+          await doctorProgram.parseAsync([...args], { from: 'user' });
+          return exitCode;
+        });
+        setExitCode(await runDoctorFix(['doctor', '--fix', '--yes']));
+        return;
+      }
       setExitCode(0);
     });
 

package/src/cli/setup-recommend.ts

@@ -0,0 +1,8 @@
+export function recommendedSetup(state: { chat: { fastPath: boolean } }): [string, string] {
+  return [
+    '고칠 것 고치기 — 권한·PATH·서비스 파일·파이썬 환경 등 고칠 수 있는 항목을 고칩니다(로그인·서비스 재시작은 별도): `elanous doctor --fix --yes`',
+    state.chat.fastPath
+      ? '짧은 물음은 빠르게 — 켜져 있음(chat.fastPath=true): 짧은 물음에 도구 없이 먼저 답합니다. 끄기: `elanous config set chat.fastPath false`'
+      : '짧은 물음은 빠르게 — 꺼져 있음(chat.fastPath=false): 켜면 짧은 물음에 도구 없이 먼저 답합니다. 켜기: `elanous config set chat.fastPath true`',
+  ];
+}

package/src/cli/usage-cli.ts

@@ -12,9 +12,13 @@ import { consumeCodexResetCredits, listCodexResetCredits } from '../budget/codex
 import { rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
 import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { LOGS_SINCE_OPTION, parseSince } from './logs-cli.js';
+import { formatCodexCreditPlan, type CodexCreditPlan } from '../budget/codex-credit-plan.js';
+import { codexCreditPlanFromDisk } from './codex-credit-plan-view.js';
 
 export interface UsageCliDeps {
   readonly collect?: typeof collectUnifiedUsage;
+  /** Codex credit plan (disk only). Returns null when it cannot be read. */
+  readonly creditPlan?: () => CodexCreditPlan | null;
   readonly out?: { log: (s: string) => void };
   /** Read-only LogStore query seam; returns stored llm-usage rows, newest first. */
   readonly readRunLogs?: (query: LogQuery) => LogStoreRow[];
@@ -61,6 +65,10 @@ function usageData(row: LogStoreRow): RunUsageInput | null {
   } catch { return null; }
 }
 
+function defaultCreditPlan(): CodexCreditPlan | null {
+  try { return codexCreditPlanFromDisk(); } catch { return null; }
+}
+
 export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}): void {
   const out = deps.out ?? { log: (s: string) => console.log(s) };
   const collect = deps.collect ?? collectUnifiedUsage;
@@ -71,11 +79,13 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
     .option('--json', 'JSON 출력 — 자격 값은 없다')
     .action(async (opts: { json?: boolean }) => {
       const report = await collect();
+      const creditPlan = (deps.creditPlan ?? defaultCreditPlan)();
       if (opts.json) {
-        out.log(JSON.stringify(report, null, 2));
+        out.log(JSON.stringify({ ...report, codexCreditPlan: creditPlan }, null, 2));
         return;
       }
       out.log(formatUnifiedUsage(report));
+      if (creditPlan) out.log(['', 'codex 크레딧', ...formatCodexCreditPlan(creditPlan).map((l) => `  ${l}`)].join('\n'));
     });
 
   usage

package/src/codex/setup.ts

@@ -62,14 +62,33 @@ export interface CodexSetupResult {
 
 // ── Picker helpers (shared with onboarding) ──────────────────────────
 
-export async function pickCodexAuthMode(io: WizardIO): Promise<CodexAuthMode> {
-  const existing = loadTokens('openai-codex');
-  if (existing) {
-    const exp = existing.tokens.expiresAt;
-    const when = exp != null
-      ? (Date.now() > exp ? 'EXPIRED' : `${Math.round((exp - Date.now()) / 60000)}min left`)
-      : 'no expiry tracked';
-    io.print(`  OAuth tokens already on file (${when}).`);
+export interface CodexAuthModeDeps {
+  loadTokens?: typeof loadTokens;
+  /** OB1 — a codex CLI login (~/.codex/auth.json) the runtime already uses; default = `inspectSubscription`. */
+  hasCodexCliLogin?: () => boolean;
+}
+
+export async function pickCodexAuthMode(io: WizardIO, deps: CodexAuthModeDeps = {}): Promise<CodexAuthMode> {
+  const existing = (deps.loadTokens ?? loadTokens)('openai-codex');
+  // OB1 (10-01): a user already signed in to the codex CLI was sent through the device-code flow again,
+  // because only elanous's own token store counted. The runtime reads ~/.codex/auth.json, so it counts too.
+  // Same judgment as the runtime (`codexOAuthAvailable` in llm.ts) — two judgments drifting apart was the bug.
+  const codexCli = !existing && (deps.hasCodexCliLogin ?? (() => {
+    try {
+      const { codexOAuthAvailable } = require('../llm.js') as typeof import('../llm.js');
+      return codexOAuthAvailable();
+    } catch { return false; }
+  }))();
+  if (existing || codexCli) {
+    if (existing) {
+      const exp = existing.tokens.expiresAt;
+      const when = exp != null
+        ? (Date.now() > exp ? 'EXPIRED' : `${Math.round((exp - Date.now()) / 60000)}min left`)
+        : 'no expiry tracked';
+      io.print(`  OAuth tokens already on file (${when}).`);
+    } else {
+      io.print('  Found your ChatGPT/Codex login from the codex CLI (~/.codex/auth.json).');
+    }
     // Sprint 11 — chooseFrom Yes/No so fullScreenIO renders the arrow
     // picker (with 'y'/'n' + 한글 자모 quick-pick from PR #986 + #988)
     // instead of a bare text input. The runner distinguishes 'oauth-keep'

package/src/dashboard/index.ts

@@ -16779,7 +16779,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             preferHistoryArrowKeys: slashQuickMode,
             history: inputHistory,
             placeholder: anyProviderAvailable()
-              ? '/command, or type a question (inline /path/to.pdf to attach)'
+              ? '말 한 줄로 시작 — 질문하거나 «하니스로 구현 …» · /command · /path/to.pdf 첨부'
               : '/quit /clear (run `elanous setup` — no LLM provider available)',
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {

package/src/discord.ts

@@ -23,6 +23,8 @@
 import { markdownToTelegramHtml as _unusedMarkdownFn } from './telegram-format.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { debug } from './debug/log.js';
 import { getUserConfig } from './user-config.js';
+import { handleDiscordSeatWork, type DiscordSeatWorkDeps } from './intake-plane/discord-seat-work.js';
+import { parseSeatAddress } from './seat-address/seat-address.js';
 
 // Telegram's HTML markdown isn't directly useful for Discord (Discord
 // uses CommonMark + its own subset). Import kept as a reminder that
@@ -163,6 +165,8 @@ export interface DiscordBotOpts {
    *  primary `onMessage` LLM chat path. Errors are swallowed by the
    *  caller — this is a best-effort fan-out. */
   onTriggerTap?: (event: DcTriggerEvent) => void | Promise<void>;
+  /** Override the intake door's dependencies for isolated Discord seat-work tests. */
+  seatWorkDeps?: DiscordSeatWorkDeps;
 }
 
 /** Surface-unification v2 — minimal trigger-side event shape. Maps
@@ -204,6 +208,8 @@ export class DiscordBot {
   private readonly token: string;
   private readonly allowedUsers: Set<string>;
   private readonly guildTextChannels: Set<string>;
+  /** The bot's own user id (from READY) — EV12c lets an allowlisted @mention open any guild channel. */
+  private selfUserId: string | undefined;
   private readonly onMessage: DcMessageHandler;
   private readonly maxChars: number;
   private readonly log: (msg: string) => void;
@@ -216,6 +222,7 @@ export class DiscordBot {
   private readonly onReaction: ((event: DcReactionEvent) => void | Promise<void>) | null;
   /** Surface-unification v2 (FU-1) — workflow-runtime tap. */
   private readonly onTriggerTap: ((event: DcTriggerEvent) => void | Promise<void>) | null;
+  private readonly seatWorkDeps: DiscordSeatWorkDeps;
   private ws: WebSocket | null = null;
   private running = false;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -239,6 +246,7 @@ export class DiscordBot {
     this.onInteraction = opts.onInteraction ?? null;
     this.onReaction = opts.onReaction ?? null;
     this.onTriggerTap = opts.onTriggerTap ?? null;
+    this.seatWorkDeps = opts.seatWorkDeps ?? {};
   }
 
   /** Send a raw payload on the gateway WebSocket. Voice adapter uses
@@ -604,6 +612,7 @@ export class DiscordBot {
             session_id?: string;
           };
           this.log(`READY — logged in as @${d.user?.username ?? '?'} (${d.user?.id ?? '?'})`);
+          if (d.user?.id) this.selfUserId = d.user.id;
           if (this.voiceTap?.onReady && d.session_id && d.user?.id) {
             try { this.voiceTap.onReady(d.session_id, d.user.id); }
             catch (err: any) { this.log(`voice tap onReady failed: ${err?.message ?? err}`); }
@@ -684,6 +693,20 @@ export class DiscordBot {
 
   // ── Message routing ────────────────────────────────────────
 
+  /** EV12c — true when this message @mentions the bot itself (mentions array or the raw `<@id>` token). */
+  private mentionsSelf(m: Record<string, unknown>, text: string): boolean {
+    const self = this.selfUserId;
+    if (!self) return false;
+    if (Array.isArray(m.mentions) && (m.mentions as Array<{ id?: unknown }>).some(u => String(u?.id) === self)) return true;
+    return text.includes(`<@${self}>`) || text.includes(`<@!${self}>`);
+  }
+
+  private stripSelfMention(text: string): string {
+    const self = this.selfUserId;
+    if (!self) return text;
+    return text.split(`<@!${self}>`).join('').split(`<@${self}>`).join('').replace(/\s+/g, ' ').trim();
+  }
+
   private async handleMessageCreate(m: Record<string, unknown>): Promise<void> {
     // Ignore bot's own messages (DM reply from our own send would
     // re-enter here).
@@ -692,19 +715,25 @@ export class DiscordBot {
 
     // DM-only v1 scope: guild_id is absent for DM channels.
     // Voice channel commands (`/voice-join`, `/voice-leave`,
-    // `/voice-status`) intentionally bypass DM-only — they need a
-    // guild context to operate. Everything else stays DM-routed so
-    // unrelated guild traffic doesn't reach the LLM path.
+    // `/voice-status`) and allowlisted, seat-addressed work bypass
+    // DM-only. All other guild traffic stays gated unless explicitly
+    // configured as a guild text channel.
     const isDm = !m.guild_id;
+    const rawText = typeof m.content === 'string' ? m.content : '';
+    const mentionsSelf = this.mentionsSelf(m, rawText);
     if (!isDm && !this.guildTextChannels.has(String(m.channel_id))) {
-      const trimmed = typeof m.content === 'string' ? m.content.trim() : '';
-      if (!/^\/voice-(join|leave|status)\b/.test(trimmed)) return;
+      if (!/^\/voice-(join|leave|status)\b/.test(rawText.trim())
+          && !(this.allowedUsers.has(author.id) && (parseSeatAddress(rawText) || mentionsSelf))) {
+        debug.log('discord.trigger', 'dropped', { reason: 'guild-not-chat', channelId: String(m.channel_id) });
+        return;
+      }
     }
 
     // Allowlist enforcement. An empty allowlist refuses everyone —
     // safer default than "open to the world" when the bot runs
     // with no user config.
     if (this.allowedUsers.size > 0 && !this.allowedUsers.has(author.id)) {
+      debug.log('discord.trigger', 'dropped', { reason: 'not-allowed', isDm });
       this.log(`discord: refusing unknown user ${author.id}`);
       try {
         await this.sendMessage(
@@ -738,7 +767,7 @@ export class DiscordBot {
       channelId: String(m.channel_id),
       userId: author.id,
       userName: author.username,
-      text: typeof m.content === 'string' ? m.content : '',
+      text: mentionsSelf ? this.stripSelfMention(rawText) : rawText,
       messageId: String(m.id),
       isDm,
       attachments,
@@ -790,6 +819,27 @@ export class DiscordBot {
       }
     }
 
+    // Addressed work is submitted only by configured owners; ordinary chat keeps its existing path.
+    if (this.allowedUsers.has(author.id) && parseSeatAddress(ctx.text)) {
+      const threadId = typeof m.thread_id === 'string' && m.thread_id ? m.thread_id : undefined;
+      const replyChannelId = threadId ?? ctx.channelId;
+      try {
+        const seatReply = await handleDiscordSeatWork(ctx.text, {
+          channelId: replyChannelId,
+          messageId: ctx.messageId,
+          ...(threadId ? { threadId } : {}),
+        }, this.seatWorkDeps);
+        if (seatReply !== null) {
+          await this.sendMessage(replyChannelId, seatReply);
+          return;
+        }
+      } catch (err: unknown) {
+        this.log(`discord seat work failed: ${err instanceof Error ? err.message : String(err)}`);
+        await this.sendMessage(replyChannelId, '좌석 요청을 접수하지 못했습니다. 잠시 후 다시 보내 주세요.');
+        return;
+      }
+    }
+
     // §C5 스트리밍 flip — streaming.discord ON 이면 옛 경로(placeholder+streamer+delivery) 억제,
     // 청크 fan-out sink 가 담당(handler chunkProducer 가 primarySurfaces=['discord']). 텔레그램 동형.
     const dcStreamingFlip = getUserConfig().sessionFabric?.streaming?.discord === true;

package/src/domains/core-tools.ts

@@ -15,6 +15,8 @@ import { existsSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
 import type { LLMToolSpec } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { runRecall, type RecallSearch } from '../tool-runtime/self-cognition-runtimes.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { SCHEDULE_MANAGE_SPEC, dispatchScheduleManage } from './schedule-manage-tool.js';
 import { SESSION_MANAGE_SPEC, dispatchSessionQuery } from './session-query-tool.js';
 import { AUTOPILOT_MISSION_SPEC, dispatchAutopilotMissions } from '../autopilot/mission-tool.js';
@@ -43,6 +45,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
       sinceHours: { type: 'number', description: '조회 기간 시간(기본 168=7일).' },
       limit: { type: 'number', description: '반환 건수(기본 8).' },
       restoreId: { type: 'string', description: '느린 복원(선택) — archived 후보의 id 를 지정하면 그 cold 기억을 S3 에서 복원(recall_count++·warm 재활성화)해 본문 반환. 회상 결과 archived 에 관련 후보가 있고 본문이 필요할 때만.' },
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
     },
     required: [],
   },
@@ -50,7 +53,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
 
 /** memory_recall 코어(db 주입·테스트 가능). restoreId 지정 시 느린 복원(축B P2), 아니면 회상 + archive 발견.
  *  recency+importance+relevance 스코어. restoreDeps 는 테스트 S3 mock(생략 시 기본 S3). */
-export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps): unknown {
+export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps, onPartial?: (result: Record<string, unknown>) => void): unknown {
   // ★ 축B P2 느린 복원 — restoreId 지정 시 cold 기억을 S3 에서 명시적 복원(recall_count++·warm 재활성화).
   //   자동 아님(명시적) = 복원 폭주 방지. 죽어있던 restoreFromArchive 호출부 배선.
   if (typeof args.restoreId === 'string' && args.restoreId) {
@@ -75,15 +78,17 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
     ...(typeof args.sinceHours === 'number' ? { sinceHours: args.sinceHours } : {}),
     ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
   });
+  const mappedHits = hits.map(h => ({
+    when: h.ts, surface: h.surface, kind: h.kind,
+    text: h.text.slice(0, 400), importance: h.importance,
+    score: Math.round(h.score * 1000) / 1000,
+  }));
+  onPartial?.({ hits: mappedHits, count: hits.length });
   // M2 — cold(S3 보관) 기억 메타 발견(본문 fetch 없음·빠름). 존재+id 알리고 복원은 restoreId 로 명시적.
   const q = typeof args.query === 'string' ? String(args.query) : '';
   const archived = q ? searchArchive(mdb, q, { ...(typeof args.domain === 'string' && args.domain ? { domain: String(args.domain) } : {}), limit: 3 }) : [];
   return {
-    hits: hits.map(h => ({
-      when: h.ts, surface: h.surface, kind: h.kind,
-      text: h.text.slice(0, 400), importance: h.importance,
-      score: Math.round(h.score * 1000) / 1000,
-    })),
+    hits: mappedHits,
     count: hits.length,
     ...(archived.length ? { archived: archived.map(a => ({ id: a.id, when: a.ts, summary: a.summary, note: 'cold·S3 보관(restoreId 로 느린 복원)' })) } : {}),
     note: '내가 발송/통지한 것의 원장 회상(크로스서피스 기억·hot/warm). archived=흐려져 S3 로 이관된 cold 기억(존재+id·본문은 restoreId 로 느린 복원). 비었으면 해당 기간 발송 없음.',
@@ -91,18 +96,18 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
 }
 
 /** memory_recall 공유 구현(finance-tools 에서 이관). db 열기 + recallOrRestore 위임. */
-async function dispatchMemoryRecall(args: Record<string, unknown>): Promise<unknown> {
+async function dispatchMemoryRecall(args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void): Promise<unknown> {
   if (!existsSync(surfaceEventsDbPath())) {
     return { hits: [], note: '발송 원장 미생성 — 아직 기록된 발송이 없음(데몬 재시작 후 sendOutbound부터 적재).' };
   }
   const mdb = openSurfaceEventsDb();
-  try { return recallOrRestore(mdb, args); }
+  try { return recallOrRestore(mdb, args, undefined, onPartial); }
   catch (e) { return { error: `기억 회상 실패: ${e instanceof Error ? e.message.slice(0, 100) : String(e)}` }; }
   finally { mdb.close(); }
 }
 
 /** L2 코어 앱 도구 dispatch 핸들러 — 이름 → 구현. 새 코어 도구는 여기 추가. */
-const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
+const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void) => Promise<unknown>> = {
   schedule_manage: dispatchScheduleManage,
   session_manage: (args) => dispatchSessionQuery(args), // 대화 세션 검색·열람·목록·삭제(내용/ID/텔레그램)
   memory_recall: dispatchMemoryRecall,
@@ -115,26 +120,44 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Prom
   mission_decide: dispatchMissionDecide, // 미션 결정 기록(re-ground·defer·boundary…)·3박자 주입·코어
 };
 
+/** Worker-side search entry: dispatch must not re-enter its own budget wrapper. */
+export function dispatchRecallUnbudgeted(name: 'memory_recall' | 'self_recall', args: Record<string, unknown>, onPartial: (result: Record<string, unknown>) => void): Promise<unknown> {
+  return CORE_TOOL_HANDLERS[name]!(args, onPartial);
+}
+
 /** L2 코어 앱 도구 spec 목록(전 서피스 공용). */
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
+const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
+  ...SELF_RECALL_SPEC,
+  parameters: {
+    ...SELF_RECALL_SPEC.parameters,
+    properties: {
+      ...(SELF_RECALL_SPEC.parameters.properties as Record<string, unknown>),
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
+    },
+  },
+};
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
   names: Set<string>;
-  dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  dispatch: (name: string, args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void, context?: ToolRuntimeContext) => Promise<unknown>;
 }
 
 /** 서피스 무관 코어 앱 도구 세트. 모든 서피스가 이걸 조립 → 코어 도구 단일 출처 상속.
  *  L1(native)·L3(finance 팩)와 조합해 쓴다. dispatch 는 이름으로 라우팅(미등록=error). */
-export function buildCoreTools(): CoreTools {
+export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
   const names = new Set(CORE_TOOL_SPECS.map(s => s.name));
   return {
     specs: CORE_TOOL_SPECS,
     names,
-    dispatch: async (name, args) => {
+    dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
       if (!h) return { error: `unknown core tool: ${name}` };
-      return h(args);
+      if (name === 'memory_recall' || name === 'self_recall') {
+        return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
+      }
+      return h(args, onPartial);
     },
   };
 }