elanous 0.2.17 → 0.2.19

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

@@ -0,0 +1,49 @@
+import type { Command } from 'commander';
+import type { Database } from 'bun:sqlite';
+import type { GuardianPlan } from '../domains/guardian-tick.js';
+import { getUserConfig } from '../user-config.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+// Domain modules (schedules.db · schedule-runner → node-cron) load lazily inside the actions,
+// so registering `guardian` adds no static dependency to the CLI boot path.
+async function guardianPlan(): Promise<{ db: Database; plan: GuardianPlan }> {
+  const { listSchedules, openSchedulesDb } = await import('../domains/schedule-registry.js');
+  const db = openSchedulesDb();
+  try {
+    return { db, plan: { jobs: listSchedules(db) } };
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+
+export function registerGuardianCommands(program: Command): void {
+  const guardian = program.command('guardian').description('크론 수호자 그림자 관측(기존 크론·알림 무변경)');
+  guardian.command('tick').description('현재 시각에 발화했을 잡을 관측(잡은 실행하지 않음)')
+    .action(async () => {
+      const { guardianTick } = await import('../domains/guardian-tick.js');
+      const { db, plan } = await guardianPlan();
+      try {
+        const cfg = getUserConfig();
+        // Live activation (and crontab retirement) is a separate operational change.
+        if (cfg.guardian?.mode === 'live') throw new Error('guardian live activation is outside GUARD-ONE-a');
+        const result = await guardianTick(new Date(), plan, { config: cfg });
+        await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+      } finally { db.close(); }
+    });
+  guardian.command('compare').description('하루의 예정 발화와 기록된 실제 발화 비교')
+    .requiredOption('--day <YYYY-MM-DD>', '비교할 달력 날짜')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { day: string; json?: boolean }) => {
+      const { guardianShadowDay } = await import('../domains/guardian-tick.js');
+      const { db, plan } = await guardianPlan();
+      try {
+        const result = guardianShadowDay(opts.day, { db, plan });
+        if (opts.json) await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+        else {
+          console.log(`guardian ${result.day}: ${result.same ? 'same' : 'diff'} (현재 레지스트리 cron·활성 기준 재계산 · alertsActual=null: 발송 수 미측정)`);
+          for (const row of result.jobs) console.log(`  ${row.job}: would=${row.would} actual=${row.actual} alertsActual=${row.alertsActual ?? '미측정'}`);
+        }
+      } finally { db.close(); }
+    });
+}

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,63 @@ 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([
+      // The directive index is excluded from the public export; load it at run time only (proact-meter · know-find pattern).
+      import('bun:sqlite'), import('node:fs'), import(['..', 'directives', 'directive-index.js'].join('/')) as Promise<{ directiveDbPath: () => string }>,
+    ]);
+    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>;
@@ -85,14 +145,15 @@ export async function runIntakeToTasksCli(
 
 /** `--telegram` 다이제스트. 렌즈는 digest 를 만들기 전에 돈다. 렌즈 실패는 보고를 막지 않는다. */
 export async function runIntakeDigestCli(
-  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string },
+  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string; seat?: string },
   deps: IntakeDigestCliDeps = {},
 ): Promise<{ sent?: boolean; empty?: boolean }> {
-  const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
+  const { buildIntakeDigest, recordSeatBriefed, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const root = deps.root ?? effectiveInstanceRoot();
   const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
-  if (opts.telegram) {
+  // A seat briefing ignores lens rows (digest drops them), so it does not pay for a lens pass over other seats' items.
+  if (opts.telegram && opts.seat === undefined) {
     const annotate = deps.annotateLens ?? (async (lensRoot, lensDay) => {
       const { annotateIntakeLens } = await import('../intake-plane/lens.js');
       return annotateIntakeLens(lensRoot, lensDay);
@@ -100,9 +161,10 @@ export async function runIntakeDigestCli(
     try { await annotate(root, day); }
     catch (error) { debug.log('intake.lens', 'annotate-failed', { day, reason: error instanceof Error ? error.message : String(error) }); }
   }
-  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
+  const seat = opts.seat === undefined ? undefined : (await import('../intake-plane/intake-sources.js')).canonicalSeat(opts.seat);
+  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day, undefined, undefined, seat);
   if (opts.telegram) {
-    if (!d.absorbed.length && !d.news?.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    if (!seat && !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)
@@ -112,6 +174,8 @@ export async function runIntakeDigestCli(
         return sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
       })();
     debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
+    if (seat && sent) recordSeatBriefed(root, seat, day, d.absorbed.map((entry) => entry.id));
+    if (seat === 'user') debug.log('watch.default', 'brief', { topics: (await import('../intake-plane/intake-sources.js')).listSources({ seat }, root).length, items: d.absorbed.length, sent });
     console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
     if (!sent) process.exitCode = 3;
     return { sent };
@@ -134,7 +198,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 +293,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>')
@@ -325,9 +402,10 @@ export function registerIntakeCommands(program: Command): void {
     .option('--day <YYYY-MM-DD>', 'KST 날짜 (기본 오늘)')
     .option('--json', '구조화 출력')
     .option('--telegram', '텔레그램 보고 채널(telegram.reportChannel)로 짧은 판을 보낸다')
+    .option('--seat <id>', '자리 id (user 아침 브리핑)')
     .option('--vault <root>', '옵시디언 볼트 뿌리 — 텔레그램 판에 노트 열기 주소를 싣는다')
     .option('--note <path>', '열기 주소가 가리킬 노트(그날 트렌드 노트)')
-    .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string }) => {
+    .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string; seat?: string }) => {
       await runIntakeDigestCli(opts);
     });
 

package/src/cli/log-event-names.ts

@@ -1564,6 +1564,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "visibility-failed",
   "visibility-noninteractive",
   "visibility-preflight",
+  "visible",
   "voice-mode-active",
   "warn",
   "watch-error",

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

@@ -71,7 +71,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         const current = spec ? null : kubectl(['config', 'current-context']);
         const context = spec ?? (current?.status === 0 ? current.stdout.trim() : '');
         const members = context ? parsePodPool(context) : [];
-        const measure: PoolLeaseMeasure = members.length ? measurePoolLease(members, { kubectl, dns: (context) => (deps.dns ?? probePoolDns)(context, kubectl) }) : { members: [] };
+        const measure: PoolLeaseMeasure = members.length ? measurePoolLease(members, { kubectl, dns: (context) => (deps.dns ?? probePoolDns)(context, kubectl), measureUsage: true }) : { members: [] };
         let accounts: number | null = null;
         let accountReason: string | null = null;
         try { accounts = (deps.accounts ?? (() => listCodexAccountsInStore().length))(); }
@@ -96,6 +96,10 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           }
           io.log(`실측 점유: ${measure.members.map((m) => `${m.context} ${m.running === null || m.pending === null ? '못 쟀다' : m.running + m.pending}/${m.capacity}`).join(' · ') || '?'}`);
           io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
+          if (decision.admission) {
+            const g = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
+            io.log(`골당 입장 ${g(decision.admission.admitBytes)} (실사용 표본 ${decision.admission.samples} · p95 ${g(decision.admission.p95Bytes)}${decision.admission.fallback ? ` · 폴백: ${decision.admission.fallback}` : ''})`);
+          }
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
           io.log(`capacity: ${decision.capacitySlots ?? '?'} 칸 (상한 ${members.reduce((sum, m) => sum + m.capacity, 0)} − Running ${decision.running ?? '?'} − Pending ${decision.pending ?? '?'}; 권장 수에서 건강한 멤버의 임대 없는 실행 차감)`);

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}`);

package/src/cli/pty-drive-cli.ts

@@ -51,6 +51,18 @@ export interface TuiWorkdirDecision {
   readonly message?: string;
 }
 
+/** 「명시 격리」 판정 — `--test`(명시 플래그 층) 이거나 `--isolated-root` 를 줬을 때만 참.
+ *
+ * ⭐ 이 식은 «한 벌»이다 — `runPtyDriveInner`(거부)와 `src/index.ts` dev 의 자동 워크트리
+ *    판정(`decideAutoWorktree`)이 같이 쓴다. 둘이 갈리면 「자동으로 만들었어야 하는데 거부」나
+ *    「거부했어야 하는데 자동」이 조용히 생긴다. 3층(트리 파생)은 «명시»가 아니라서 빠진다. */
+export function isExplicitlyIsolated(
+  resolution: { readonly kind: string; readonly layer: string },
+  isolatedRoot?: string,
+): boolean {
+  return (resolution.kind === 'test' && resolution.layer === 'explicit-flag') || Boolean(isolatedRoot);
+}
+
 /** Reject the unsafe combination before a TUI child can inherit the caller's tree. */
 export function decideTuiWorkdir(isolated: boolean, cwd: string | undefined): TuiWorkdirDecision {
   const workdirProvided = Boolean(cwd?.trim());
@@ -62,7 +74,7 @@ export function decideTuiWorkdir(isolated: boolean, cwd: string | undefined): Tu
     // ⛔⭐ 거부 문면은 **무엇을 주면 되는지**까지 말한다(교차 세션 제안 · 2026-08-02).
     //    상대가 헤맨 이유가 *"어디에 config 를 쓰나"* 였다 — 실효 자리를 확인하는 한 줄을 함께 준다.
     ...(rejected
-      ? { message: '격리 우주에서는 작업 디렉토리를 명시해야 한다 — `--cwd <worktree-path>` 를 주십시오. '
+      ? { message: '격리 우주에서는 작업 디렉토리를 명시해야 한다 — `--worktree` 를 주거나 `--cwd <worktree-path>` 를 주십시오. '
           + '(안 주면 명령을 친 트리가 자식의 쓰기 허용 구역이 됩니다.) '
           + '지금 어느 우주인지는 `elanous where` 로 확인할 수 있습니다.' }
       : {}),
@@ -499,8 +511,7 @@ async function runPtyDriveInner(opts: PtyDriveOpts): Promise<{ exitCode: number
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const scopeRoot = effectiveInstanceRoot();
   const resolution = resolveCurrentInstance();
-  const explicitlyIsolated = (resolution.kind === 'test' && resolution.layer === 'explicit-flag')
-    || Boolean(opts.isolatedRoot);
+  const explicitlyIsolated = isExplicitlyIsolated(resolution, opts.isolatedRoot);
   const workdirDecision = decideTuiWorkdir(explicitlyIsolated, opts.cwd);
   debug.log('pty.drive', 'tui-workdir-decision', workdirDecision);
   if (workdirDecision.rejected) throw new Error(workdirDecision.message);