elanous 0.2.9 → 0.2.10

package/src/chat/ctrl-c-in-input.ts

@@ -0,0 +1,14 @@
+/** U1a — how long an empty-input Ctrl+C stays armed (and its hint stays on screen). */
+export const CTRL_C_ARM_MS = 2_000;
+
+export function resolveCtrlCInInput({ text, now, armedAt }: {
+  text: string;
+  now: number;
+  armedAt: number | null;
+}): { action: 'clear-input' | 'arm-exit' | 'exit'; armedAt: number | null; hint: string | null } {
+  if (text.length > 0) return { action: 'clear-input', armedAt: null, hint: null };
+  if (armedAt !== null && now >= armedAt && now - armedAt <= CTRL_C_ARM_MS) {
+    return { action: 'exit', armedAt: null, hint: null };
+  }
+  return { action: 'arm-exit', armedAt: now, hint: '한 번 더 누르면 나갑니다 · /quit' };
+}

package/src/chat/index.ts

@@ -19,6 +19,7 @@ import type { ModalSurface } from '../display/modal-stack.js';
 import type { ContentBlock } from '../llm.js';
 import { debug } from '../debug/log.js';
 import { matchTextInputGlobalAction } from './global-actions.js';
+import { CTRL_C_ARM_MS, resolveCtrlCInInput } from './ctrl-c-in-input.js';
 import { isTextInputQuitChord } from './input-quit-chord.js';
 // P5 — leader-chord pass-through from input focus. chat.ts swallows
 // plain letters into its textarea buffer, so the resolver never sees
@@ -896,6 +897,10 @@ export async function textInput(opts: {
   let lastReportedLines = -1;
   let lineIdx = 0;   // current line
   let colIdx = lines[0]!.length;  // cursor at end of initial text
+  let ctrlCArmedAt: number | null = null;
+  let ctrlCHintTimer: ReturnType<typeof setTimeout> | null = null;
+  let ctrlCHint: string | null = null;
+  let ctrlCHintPainted = false;
 
   // KX2 — picker selection / navigation / async fetch caches live in
   // the shared state machine (chat-picker-state.ts). textInput keeps
@@ -1173,6 +1178,14 @@ export async function textInput(opts: {
     }
     prevDrawnLines = visibleLines;
 
+    if (ctrlCHint) {
+      writeTerminal(ansi.moveTo(row + 2, col) + '\x1b[2K' + C.muted(truncate(ctrlCHint, width)));
+      ctrlCHintPainted = true;
+    } else if (ctrlCHintPainted) {
+      writeTerminal(ansi.moveTo(row + 2, col) + '\x1b[2K');
+      ctrlCHintPainted = false;
+    }
+
     // Cursor — its buffer line is `lineIdx`; its screen row is the
     // bottom-anchored offset within the visible window. Critically,
     // `textBeforeCursor` reads from `lines[lineIdx]` (the buffer), not
@@ -1468,6 +1481,11 @@ export async function textInput(opts: {
       process.exit(0);
     }
 
+    if (!(key.ctrl && (key.name === 'c' || key.name === 'ㅊ') && !key.shift && !key.alt)) {
+      ctrlCArmedAt = null;
+      ctrlCHint = null;
+    }
+
     // A bracketed-paste envelope is one atomic event. Handle it before
     // host routing so embedded newlines cannot reach a submit handler.
     if (key.name === 'paste') {
@@ -1571,6 +1589,40 @@ export async function textInput(opts: {
       continue;
     }
 
+    if (key.ctrl && (key.name === 'c' || key.name === 'ㅊ') && !key.shift && !key.alt) {
+      const text = lines.join('\n');
+      const result = resolveCtrlCInInput({ text, now: Date.now(), armedAt: ctrlCArmedAt });
+      debug.log('chat.input', 'ctrl-c', { action: result.action, length: text.length });
+      ctrlCArmedAt = result.armedAt;
+      ctrlCHint = result.hint;
+      if (ctrlCHintTimer) clearTimeout(ctrlCHintTimer);
+      ctrlCHintTimer = null;
+      if (result.action === 'arm-exit') {
+        // U1a — the hint promises «one more press exits» only while that is true.
+        const armedAt = result.armedAt;
+        ctrlCHintTimer = setTimeout(() => {
+          ctrlCHintTimer = null;
+          if (ctrlCArmedAt !== armedAt) return;
+          ctrlCArmedAt = null;
+          ctrlCHint = null;
+          drawAll();
+        }, CTRL_C_ARM_MS + 50);
+        ctrlCHintTimer.unref?.();
+      }
+      if (result.action === 'exit') return submitBufferResult('/quit');
+      if (result.action === 'clear-input') {
+        lines = [''];
+        lineIdx = 0;
+        colIdx = 0;
+        historyIdx = -1;
+        savedCurrentInput = '';
+        onUserBufferEdit();
+        await picker.refresh(bufView());
+      }
+      drawAll();
+      continue;
+    }
+
     const globalDispatcher = dispatchGlobalAction;
     const globalAction = globalDispatcher
       ? matchTextInputGlobalAction(key, {

package/src/chat/pickers/state.ts

@@ -33,6 +33,7 @@ import type {
 } from '../index.js';
 import { filterSlashCommands } from '../index.js';
 import { filterInputMatches } from '../../input/query-match.js';
+import { readTuiSlashAudience, slashMaturity, slashVisibleFor } from '../../maturity/tui-slash-maturity.js';
 
 /** Read-only snapshot of the textInput buffer handed to state on
  *  every public call. The state machine never mutates it; it only
@@ -234,8 +235,11 @@ export function createPickerState(deps: PickerDeps): PickerState {
   let currentAtItems: AtCandidate[] = [];
   let currentSkillItems: SkillCandidate[] = [];
 
-  const filteredSlash = (buf: PickerBufferView): SlashCommand[] =>
-    filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands);
+  const filteredSlash = (buf: PickerBufferView): SlashCommand[] => {
+    const { role, showBeta } = readTuiSlashAudience();
+    return filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands)
+      .filter((cmd) => (role === 'owner' && slashMaturity(cmd.name) === undefined) || slashVisibleFor(cmd.name, role, { showBeta }));
+  };
 
   const refreshArgs = async (buf: PickerBufferView): Promise<ArgSuggestion[]> => {
     const ctx = parseArgContext(buf, deps.commands);

package/src/cli/agent-cli.ts

@@ -3,6 +3,7 @@ import { resolve } from 'node:path';
 import { getUserConfig, reloadUserConfig } from '../user-config.js';
 import { handleOnboardingRefusal, needsOnboarding, runOnboarding } from '../onboarding.js';
 import { runTurn, ensureCliSession, sessionBudget } from '../session/chat.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
 import { NoLlmProviderAvailableError, noProviderAvailableMessage } from '../llm.js';
 import { resolveSessionId, getActiveSessionId, setActiveSessionId } from '../session/index.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
@@ -433,6 +434,12 @@ export async function runChatTurnCli(opts: {
   }
   const session = ensureCliSession(opts.cfg, resolvedSessionIdHint);
   setActiveSessionId(session.id);
+  if (!opts.json && (!resolvedSessionIdHint || session.id !== resolvedSessionIdHint)) {
+    try {
+      const project = suggestProjectForFolder(process.cwd());
+      if (project) console.log(`Project suggestion: ${project.name} (${project.id})`);
+    } catch { /* suggestions must not interrupt a CLI conversation */ }
+  }
   const harnessSpace = getHarnessSpace();
   // Tag the debug log with this session id so every event in this
   // process attributes correctly. enrichDebugRecord picks up the

package/src/cli/decisions-cli.ts

@@ -1,4 +1,5 @@
 import type { Command } from 'commander';
+import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry } from '../decisions/decision-ledger.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
@@ -49,22 +50,31 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
   const root = program.command('decisions').description('대표 결정 원장 · 로컬 전용');
   const emit = (value: unknown, json?: boolean, text?: string) => out.log(json ? JSON.stringify(value) : text ?? JSON.stringify(value));
   const fail = (action: () => void) => { try { action(); } catch (e) { throw new Error(`decisions: ${e instanceof Error ? e.message : String(e)}`); } };
+  root.command('linear-sync').description('열린 결정을 COO Linear 프로젝트에 투영하고 닫힌 결정을 동기화한다')
+    .option('--dry-run').option('--json')
+    .action(async (o: { dryRun?: boolean; json?: boolean }) => {
+      const result = await projectDecisionsToLinear({ stateDir: config.stateDir, dryRun: o.dryRun });
+      emit(result, o.json, result.reason ?? `생성 ${result.created} · 닫음 ${result.closed} · 건너뜀 ${result.skipped} · 실패 ${result.failed}${result.plan?.length ? `\n${result.plan.map(p => `${p.action} ${p.decisionId}${p.issue ? ` ${p.issue}` : ''}`).join('\n')}` : ''}`);
+    });
   root.command('raise').description('SCQA·선택지와 권고로 결정 항목을 올린다')
     .requiredOption('--title <text>').requiredOption('--category <category>')
     .requiredOption('--s <text>').requiredOption('--c <text>').option('--q <text>').option('--a <text>')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--track <track>').option('--agent <agent>').option('--session <id>')
+    .option('--resume-question <qid>').option('--run <runId>')
     .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
     .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
     .option('--json')
-    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; ref: string[]; json?: boolean }) => fail(() => {
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: 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>');
       const options: DecisionOption[] = o.option.map(parseOption);
       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,
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },
         raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}),
+        ...(o.resumeQuestion !== undefined ? { resume: { questionId: o.resumeQuestion, ...(o.run !== undefined ? { runId: o.run } : {}) } } : {}),
         ...(o.due ? { dueAt: dueAt(o.due) } : {}) });
       emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
@@ -83,8 +93,20 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (o.auto && !o.delegation?.trim()) throw new Error('--auto requires --delegation');
       if (!o.auto && (o.delegation || o.track || o.agent)) throw new Error('delegation/track/agent require --auto');
       const by = o.auto ? { kind: 'auto' as const, agent: agent(o.agent), delegation: o.delegation!, ...(o.track ? { track: o.track } : {}) } : { kind: 'human' as const };
-      const entry = new DecisionLedger(config).decide(id, choice, by, o.note);
-      emit(entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+      const { entry, delivery } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
+      if (delivery && !delivery.ok) {
+        // The decision is recorded; only the answer to the waiting run failed — say so and how to retry, never «success».
+        const hint = `⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`;
+        emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
+        process.exitCode = 3;
+        return;
+      }
+      emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+    }));
+  root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json')
+    .action((id: string, o: { json?: boolean }) => fail(() => {
+      const entry = new DecisionLedger(config).retryAnswer(id);
+      emit(entry, o.json, `답 전달: ${entry.id} → ${entry.resume?.questionId}`);
     }));
   root.command('add-options <id>').description('선택지가 미기재된 과거 항목에 확인된 선택지를 추가')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])

package/src/cli/doctor-bundle-upload.ts

@@ -0,0 +1,68 @@
+import { readFileSync, statSync } from 'node:fs';
+import { debug } from '../debug/log.js';
+
+export interface DoctorBundleUploadOptions {
+  path: string;
+  files: readonly string[];
+  uploadUrl?: string;
+  confirm: (message: string) => Promise<boolean>;
+  fetch: typeof globalThis.fetch;
+  yes?: boolean;
+  /** Present the inventory before either consent or transport; JSON callers can use stderr. */
+  announce?: (contents: string) => void;
+  /** Pass the size returned by buildDoctorBundle, if available. */
+  bytes?: number;
+}
+
+export interface DoctorBundleUploadResult {
+  path: string;
+  uploaded: boolean;
+  code?: string;
+  reason?: string;
+  exitCode: number;
+  message: string;
+}
+
+/** The bundle is local until both an HTTPS destination and affirmative consent exist. */
+export async function uploadDoctorBundle({ path, files, uploadUrl, confirm, fetch, yes = false, bytes, announce = console.log }: DoctorBundleUploadOptions): Promise<DoctorBundleUploadResult> {
+  const size = bytes ?? (() => { try { return statSync(path).size; } catch { return undefined; } })();
+  const skipped = (reason: string, message: string): DoctorBundleUploadResult => {
+    debug.log('doctor.bundle', 'upload-skipped', { bytes: size, reason });
+    return { path, uploaded: false, reason, exitCode: 0, message };
+  };
+  if (!uploadUrl?.trim()) return skipped('no-recipient', `수신처가 아직 정해지지 않았습니다 — 파일을 지원에 직접 보내 주세요: ${path}`);
+  let destination: URL;
+  try {
+    destination = new URL(uploadUrl.trim());
+    if (destination.protocol !== 'https:' || !destination.hostname || destination.username || destination.password) throw new Error('invalid destination');
+  } catch {
+    return skipped('invalid-recipient', `수신처가 유효한 HTTPS 주소가 아닙니다 — 파일을 지원에 직접 보내 주세요: ${path}`);
+  }
+  const contents = `내용 목록 (${size === undefined ? '크기 확인 불가' : `${size} bytes`}):\n${files.map((file) => `  ${file}`).join('\n')}`;
+  announce(contents);
+  if (!yes) {
+    let agreed = false;
+    try { agreed = await confirm('올릴까요? (y/N) '); } catch { /* An unavailable prompt is a refusal. */ }
+    if (!agreed) {
+      debug.log('doctor.bundle', 'declined', { bytes: size, reason: 'consent-declined' });
+      return { path, uploaded: false, reason: 'consent-declined', exitCode: 0, message: `업로드하지 않았습니다: ${path}` };
+    }
+  }
+  const failed = (reason: string): DoctorBundleUploadResult => {
+    debug.log('doctor.bundle', 'upload-failed', { bytes: size, reason });
+    return { path, uploaded: false, reason, exitCode: 1, message: `업로드 실패 (${reason}) — 파일: ${path} — 다시 시도해 주세요.` };
+  };
+  try {
+    const response = await fetch(destination.href, {
+      method: 'POST', headers: { 'Content-Type': 'application/gzip' }, body: readFileSync(path), redirect: 'manual',
+    });
+    if (!response.ok) return failed(`HTTP ${response.status}`);
+    const data: unknown = await response.json();
+    const code = data && typeof data === 'object' && !Array.isArray(data) ? (data as { code?: unknown }).code : undefined;
+    if (typeof code !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(code)) return failed('진단 코드 응답이 올바르지 않습니다');
+    debug.log('doctor.bundle', 'uploaded', { bytes: size, reason: 'success' });
+    return { path, uploaded: true, code, exitCode: 0, message: `진단 코드: ${code} — 이 코드만 지원에 알려 주세요` };
+  } catch {
+    return failed('네트워크 또는 파일 읽기 오류');
+  }
+}

package/src/cli/doctor-cli.ts

@@ -38,6 +38,7 @@ import { describeModes, formatModeLine, type DoctorMode } from './doctor-modes.j
 import { formatDoctorLocalLlm, probeDoctorLocalLlm, type DoctorLocalLlm } from './doctor-local-llm.js';
 import type { LlmInventory } from '../llm/local-manager/types.js';
 import { buildDoctorBundle } from './doctor-bundle.js';
+import { uploadDoctorBundle } from './doctor-bundle-upload.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -193,6 +194,9 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   adviceInteractive?: boolean;
   /** Local-manager inventory seam; default calls getInventory(). */
   localLlmInventory?: () => Promise<LlmInventory>;
+  /** Inject the upload transport and consent for isolated CLI tests. */
+  uploadFetch?: typeof globalThis.fetch;
+  confirmBundleUpload?: (message: string) => Promise<boolean>;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1217,15 +1221,21 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
     .option('--json', 'structured output')
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')
+    .option('--upload', 'send the bundle to diagnostics.uploadUrl after consent (requires --bundle)')
     .option('--out <dir>', 'output directory for --bundle')
     .option('--fix', 'show repairs; git installation asks on a TTY (other repairs require --yes)')
     .option('--advise', 'ask the configured LLM to rank catalog repairs (read-only advice)')
-    .option('--yes', 'apply planned doctor repairs (requires --fix)')
+    .option('--yes', 'apply planned doctor repairs (--fix), or confirm bundle upload (--bundle --upload)')
     .option('--sudo', 'also run the planned sudo install lines — only where `sudo -n true` works (requires --fix --yes)')
     .option('--restart', 'restart the nexus service when it runs a different version than this installed copy, then verify it (requires --fix --yes · interrupts bots, terminals and running turns)')
-    .action(async (opts: { json?: boolean; credentials?: boolean; bundle?: boolean; out?: string; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+    .action(async (opts: { json?: boolean; credentials?: boolean; bundle?: boolean; upload?: boolean; out?: string; fix?: boolean; advise?: boolean; yes?: boolean; sudo?: boolean; restart?: boolean }) => {
+      if (opts.upload && !opts.bundle) {
+        err.error('--upload requires --bundle');
+        setExitCode(1);
+        return;
+      }
       if (opts.bundle) {
-        if (opts.fix || opts.advise || opts.yes || opts.sudo || opts.restart) {
+        if (opts.fix || opts.advise || opts.sudo || opts.restart || (opts.yes && !opts.upload)) {
           err.error('--bundle cannot be combined with repair or advice options');
           setExitCode(1);
           return;
@@ -1235,7 +1245,31 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
           const doctorReport = runDoctor(deps);
           if (doctorReport.ok) doctorReport.localLlm = await probeDoctorLocalLlm(deps.localLlmInventory);
           const result = buildDoctorBundle({ outDir: opts.out ?? process.cwd(), doctorOptions: deps, doctorReport });
-          out.log(opts.json ? JSON.stringify(result) : [`Diagnostics: ${result.path} (${result.bytes} bytes)`, 'Contents:', ...result.files.map((file) => `  ${file}`)].join('\n'));
+          if (opts.upload) {
+            let uploadUrl: string | undefined;
+            try { uploadUrl = (deps.userConfig ?? (deps.getUserConfig ?? getUserConfig)()).diagnostics?.uploadUrl; }
+            catch {
+              const reason = '설정을 읽을 수 없습니다';
+              debug.log('doctor.bundle', 'upload-failed', { bytes: result.bytes, reason: 'config-read-failed' });
+              if (opts.json) out.log(JSON.stringify({ path: result.path, uploaded: false, reason }));
+              else err.error(`업로드 실패 (${reason}) — 파일: ${result.path} — 다시 시도해 주세요.`);
+              setExitCode(1);
+              return;
+            }
+            const uploaded = await uploadDoctorBundle({
+              ...result,
+              uploadUrl,
+              yes: opts.yes,
+              announce: (contents) => { if (opts.json) err.error(contents); else out.log(contents); },
+              confirm: deps.confirmBundleUpload ?? ((message) => confirmDoctorAdvice(message, opts.json === true)),
+              fetch: deps.uploadFetch ?? globalThis.fetch,
+            });
+            if (opts.json) out.log(JSON.stringify({ path: uploaded.path, uploaded: uploaded.uploaded, ...(uploaded.code ? { code: uploaded.code } : {}), ...(uploaded.reason ? { reason: uploaded.reason } : {}) }));
+            else out.log(uploaded.message);
+            if (uploaded.exitCode) setExitCode(uploaded.exitCode);
+          } else {
+            out.log(opts.json ? JSON.stringify(result) : [`Diagnostics: ${result.path} (${result.bytes} bytes)`, 'Contents:', ...result.files.map((file) => `  ${file}`)].join('\n'));
+          }
         } catch {
           err.error('Could not create diagnostics archive.');
           setExitCode(1);

package/src/cli/ops-cli.ts

@@ -1,6 +1,11 @@
 import type { Command } from 'commander';
 import * as ui from '../ui.js';
 import { writeStdoutJson } from './stdout-json.js';
+import type { OpsNowResult } from '../ops-now/ops-now-refresh.js';
+
+export function opsNowExitCode(outcome: OpsNowResult['outcome']): number {
+  return outcome === 'channel-unreadable' || outcome === 'summarize-failed' ? 2 : 0;
+}
 
 export function registerOpsCommands(program: Command): void {
 const opsCmd = program.command('ops')
@@ -173,6 +178,21 @@ async function runOpsBuild(buildId: string | undefined, opts: OpsBuildOpts): Pro
   process.exit(0);
 }
 
+opsCmd.command('now-refresh').description('채널 📌안내로 ops-now 고정 기억 갱신(1회)')
+  .option('--once', '한 번 실행(기본)')
+  .option('--dry-run', '기억을 쓰지 않고 새 본문 출력')
+  .option('--json', '결과를 JSON으로 출력')
+  .action(async (o: { dryRun?: boolean; json?: boolean }) => {
+    const { refreshOpsNow } = await import('../ops-now/ops-now-refresh.js');
+    const result = await refreshOpsNow({ dryRun: o.dryRun === true });
+    if (o.json) await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+    else {
+      console.log(`ops-now: ${result.outcome} · 안내 ${result.notices}개`);
+      if (o.dryRun && result.body !== undefined) console.log(result.body);
+    }
+    process.exitCode = opsNowExitCode(result.outcome);
+  });
+
 opsCmd.command('status').description('현재 상태 종합(미션·태스크·루프·오케스트레이션·스케줄) · --all-instances 로 fleet 전체 종합(미션/태스크/loops/스케줄/오케스트레이션) · -r/--remote 로 원격 GET 조립')
   .option('--json').option('--all-instances', '등록 인스턴스 전체 종합(미션/태스크/loops/스케줄/오케스트레이션 · fleet · read-only · §10)')
   .option('--include-test', '연합에 격리 test 인스턴스도 포함(기본 제외)')

package/src/cli/pod-cli.ts

@@ -2,6 +2,11 @@
 // 산출 경로를 한 줄로 알리고 명령의 종료 코드로 끝난다. `--deadline` 생략 시 기존 Pod Job 상한.
 
 import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
+import { parsePodPool, resolvePodPoolSpec, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
+import { leaseKubectl, measurePoolLease, recommendConcurrency, type PoolLeaseMeasure } from '../task-orchestrator/surfaces/pod-lease.js';
 import { POD_COMMAND_DEADLINE_SECONDS, runPodCommand, type PodCommandResult, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
 
 export interface PodCliIo {
@@ -13,6 +18,10 @@ export interface PodCliIo {
 export interface PodCliDeps {
   io?: PodCliIo;
   run?: (options: RunPodCommandOptions) => Promise<PodCommandResult>;
+  kubectl?: PoolKubectl;
+  accounts?: () => number;
+  perAccount?: () => number;
+  poolSpec?: (explicit?: string) => string | null;
 }
 
 const HELP = `elanous pod run [--pool <스펙>] [--skill <이름,…>] [--llm grok] [--clone] [--deadline <초>] -- <명령…>
@@ -27,6 +36,46 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
   };
   const run = deps.run ?? ((options: RunPodCommandOptions) => runPodCommand(options));
   const pod = program.command('pod').description('Pod 명령 Job — 하니스 없이 명령 하나를 돌리고 산출을 돌려받는다');
+  pod.command('lease').description('Pod 풀의 읽기 전용 동시 실행 권장')
+    .command('status').description('지금 추가로 쏠 수 있는 Pod 골과 제한 근거')
+    .option('--pool <spec>', '풀 스펙 — 컨텍스트[@ssh호스트][:상한] 쉼표')
+    .option('--json', '표 대신 동일 측정값을 JSON 으로')
+    .action((opts: { pool?: string; json?: boolean }) => {
+      try {
+        const kubectl = deps.kubectl ?? leaseKubectl;
+        const spec = (deps.poolSpec ?? ((explicit?: string) => resolvePodPoolSpec(explicit)))(opts.pool);
+        // No pool configured: mirror the Pod launch fallback to kubectl's current context.
+        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 }) : { members: [] };
+        let accounts: number | null = null;
+        let accountReason: string | null = null;
+        try { accounts = (deps.accounts ?? (() => listCodexAccountsInStore().length))(); }
+        catch { accountReason = '측정 불가: accounts'; }
+        const perAccount = (deps.perAccount ?? (() => getUserConfig().pod?.lease?.perAccount ?? 4))();
+        const decision = recommendConcurrency(measure, { capacity: members.reduce((sum, m) => sum + m.capacity, 0), accounts: accounts ?? -1, perAccount });
+        if (!context) { decision.recommended = null; decision.limitedBy = null; decision.reason = '측정 불가: cluster (current context)'; }
+        const result = { pool: spec, ...measure, accounts, perAccount, ...decision };
+        debug.log('pod.lease', 'status', { pool: spec ? members.map((m) => ({ capacity: m.capacity })) : null, running: decision.running, pending: decision.pending, recommended: decision.recommended, limitedBy: decision.limitedBy });
+        if (opts.json) io.log(JSON.stringify(result));
+        else {
+          io.log('컨텍스트 | 상한 | Running | Pending | 메모리(상한 합/할당 가능) | CPU(할당 가능)');
+          for (const m of measure.members) {
+            const mem = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
+            io.log(`${m.context} | ${m.capacity} | ${m.running ?? '?'} | ${m.pending ?? '?'} | ${mem(m.memoryLimitBytes)}/${mem(m.allocatableMemoryBytes)} | ${m.allocatableCpuMillicores === null ? '?' : m.allocatableCpuMillicores / 1000}${m.reason ? ` (${m.reason})` : ''}`);
+          }
+          io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
+          io.log(`capacity: ${decision.capacitySlots ?? '?'} 칸 (상한 ${members.reduce((sum, m) => sum + m.capacity, 0)} − Running ${decision.running ?? '?'} − Pending ${decision.pending ?? '?'})`);
+          io.log(`memory: ${decision.memorySlots ?? '?'} 칸 (할당 가능 − Running 하니스 상한 합; 골당 16Gi · 모든 네임스페이스의 노드별 기존 예약을 반영해 배치 가능 ${decision.placeableSlots ?? '?'} 칸)`);
+          io.log(`accounts (관측만 · 상한 아님): ${decision.accountSlots ?? '?'} 칸 (${accounts ?? '?'} × ${perAccount} − Running ${decision.running ?? '?'})${accountReason ? ` · ${accountReason}` : ''}`);
+        }
+        io.exit(0);
+      } catch (err) {
+        io.error(err instanceof Error ? err.message : String(err));
+        io.exit(1);
+      }
+    });
   pod.command('run')
     .description(HELP)
     .option('--pool <spec>', '풀 스펙 — 컨텍스트[@ssh호스트][:상한] 쉼표')

package/src/cli/pr-cli.ts

@@ -13,6 +13,7 @@ import { runGate as runChangedTypecheckGate } from '../../scripts/ci-typecheck-c
 import { runIsolationHardcodeGate } from '../../scripts/ci-isolation-hardcode-gate.js';
 import { androidFilesIn, runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
 import { iosFilesIn, runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.js';
+import { runPwaBuildGate } from '../../scripts/ci-pwa-build-gate.js';
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
@@ -51,6 +52,7 @@ import {
   unionPaths,
 } from './pr-granularity.js';
 import { branchLineageSlug, findSiblingPrs } from './pr-lineage.js';
+import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 
 export { branchLineageSlug, findSiblingPrs };
 
@@ -114,6 +116,7 @@ export interface PrLandDeps {
   runAndroidGate?: (out: { log: (message: string) => void; error: (message: string) => void }, changedFiles: readonly string[]) => boolean;
   /** iOS 시험 게이트 심(시험 주입용). */
   runIosGate?: (out: { log: (message: string) => void; error: (message: string) => void }, changedFiles: readonly string[]) => boolean;
+  runPwaGate?: (out: { log: (message: string) => void; error: (message: string) => void }, changedFiles: readonly string[]) => boolean;
   isInteractive?: () => boolean;
   /** Clock for the recent-landings window (test seam · default Date.now). */
   now?: () => number;
@@ -406,13 +409,14 @@ function gateVerdict(
   label: string,
   gate: (out: { log: (message: string) => void; error: (message: string) => void }) => boolean,
   out: { log: (message: string) => void; error: (message: string) => void },
+  failClosed = false,
 ): { ok: boolean; measured: boolean } {
   try {
     return { ok: gate(out), measured: true };
   } catch (error) {
     out.error(`⚠ ${label}: 게이트가 «못 쟀다» — ${error instanceof Error ? error.message : String(error)}`);
-    out.error(`⚠ ${label}: 「위반 없음」이 아니라 「검사 못 함」이다. 이 착지는 통과시키되 게이트를 고쳐라.`);
-    return { ok: true, measured: false };
+    out.error(`⚠ ${label}: 「위반 없음」이 아니라 「검사 못 함」이다. ${failClosed ? '착지를 막는다.' : '이 착지는 통과시키되 게이트를 고쳐라.'}`);
+    return { ok: !failClosed, measured: false };
   }
 }
 
@@ -426,6 +430,21 @@ function record(step: string, ok: boolean, extra: Record<string, unknown> = {}):
   debug.log('pr.land', 'step', { step, ok, ...extra });
 }
 
+export function nextMdWarning(body: string, changedFiles: readonly string[], out: { log: (message: string) => void }): void {
+  const section = body.split(/^## 릴리스 노트[ \t]*\r?$/m).at(-1)!;
+  const parsed = parseReleaseNoteSection(body);
+  const hasNote = parsed.fragment !== undefined || parsed.problems.length > 0;
+  const kind = parsed.fragment?.kind ?? (hasNote
+    ? /^[ \t]*- 종류:[ \t]*(feat|fix|security|internal)[ \t]*\r?$/m.exec(section.split(/^#{1,6}[ \t]+/m)[0]!)?.[1]
+    : undefined);
+  const reason = hasNote
+    ? (kind === 'feat' || kind === 'fix' || kind === 'security' ? `release-note:${kind}` : undefined)
+    : (changedFiles.some((file) => /^(?:apps\/pwa\/src\/|src\/cli\/|src\/dashboard\/)/.test(file)) ? 'user-facing-path' : undefined);
+  const warn = !!reason && !changedFiles.includes('release/next.md');
+  record('next-md', true, { warnOnly: true, reason: reason ?? (hasNote ? 'non-user-facing-note' : 'no-user-facing-path') });
+  if (warn) out.log('⚠ next-md: 사용자에게 보이는 변경인데 release/next.md 에 줄이 없습니다 — 공개 노트에서 빠집니다. 「- <kind> — <영어 한 문장>. Documentation: … Target: next.」 한 줄을 더하십시오.');
+}
+
 type PrRemoteCapability = 'github' | 'local-path' | 'no-remote' | 'other';
 
 function isLocalRemote(raw: string): boolean {
@@ -1323,6 +1342,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   }
 
   const changedPaths = currentChangePaths(run, cwd, staged, base, out);
+  nextMdWarning(body ?? '', changedPaths, out);
   publicLeakWarning(changedPaths, deps.runPublicLeakGate ?? runPrLandPublicLeakGate, out);
   if (!exportLeakBlock(changedPaths, () => (deps.runExportLeakCheck ?? runPrLandExportLeakCheck)(changedPaths ?? [], cwd), opts.allowPublicLeak === true, out)) return 1;
   if (publicDocPaths(changedPaths, () => true).length > 0) {
@@ -1371,6 +1391,15 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     out.log('✓ ios-gate: scripts/ci-ios-unit-tests.ts PASS — iOS 순수-로직 시험이 «실제로 돌았고» 실패 0.');
   }
 
+  // PWA 는 bun test/tsc 밖의 정적 번들이다. 측정 불가도 착지 불가로 판정한다.
+  const pwaGate = gateVerdict('pwa-gate', deps.runPwaGate
+    ? (o) => deps.runPwaGate!(o, changedPaths)
+    : (o) => runPwaBuildGate({ args: ['--changed-files', ...changedPaths], cwd, log: o.log, error: o.error }) === 0, out, true);
+  record('pwa-gate', pwaGate.ok && pwaGate.measured, { measured: pwaGate.measured });
+  if (!pwaGate.ok || !pwaGate.measured) {
+    out.error('✗ pwa-gate: scripts/ci-pwa-build-gate.ts blocked pr land — PWA 빌드 실패 또는 측정 불가.');
+    return 1;
+  }
 
   const overlapFound = emitLandingOverlapAdvisory(run, cwd, base, changedPaths, out);
   const siblingFound = emitSiblingPrAdvisory(