elanous 0.2.8 → 0.2.10

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
@@ -431,7 +432,14 @@ export interface SlashCommand {
 
 // Default commands available in the input
 export const SLASH_COMMANDS: SlashCommand[] = [
-  { name: 'directive', aliases: [], description: 'Record a directive as a Linear issue' },
+  { name: 'help',  aliases: ['?'],         description: '명령과 키 보기' },
+  { name: 'resume',    aliases: [],             description: '지난 대화 이어 가기 · /resume <id 앞자리>' },
+  { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
+  { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
+  { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
+  { name: 'remaining', aliases: [], description: '계정별 남은 사용량' },
+  { name: 'setup', aliases: [], description: '상세 설정 — /setup · /setup reset(다음 실행 때 마법사 다시)', subcommands: ['help', 'reset'] },
+  { name: 'quit',  aliases: ['q', 'exit'], description: '나가기' },
   { name: 'run-skill', aliases: ['rs', 'run'], description: 'Execute a skill via its SKILL.md prompt' },
   { name: 'ad', aliases: [], description: 'Create an advertising plan from a URL, brief, or attached image' },
   // B4 — craft rulebook verdict, same resolution as `elanous repo design-check`
@@ -440,10 +448,8 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'design',    aliases: ['design-check'], description: 'Design rulebooks this repository declares · /design [--declared] · /design pick [number|id] to choose a design direction', subcommands: ['--declared', 'pick'] },
   { name: 'provider',  aliases: ['p'],          description: 'LLM providers — /provider (list) · next (cycle, also Alt+M / pill click) · use <name> · pick (visual picker) · reset', subcommands: ['next', 'use', 'pick', 'picker', 'menu', 'reset', 'list'] },
   { name: 'reasoning', aliases: ['r', 'think'],  description: 'Reasoning level (codex effort + summary, anthropic extended-thinking budget) — /reasoning [off|low|medium|high|xhigh] (cycle when no arg · xhigh 는 모델 상한이 xhigh 이상일 때만 wire 에 실린다, 아니면 high 로 깎인다)', subcommands: ['off', 'low', 'medium', 'high', 'xhigh'] },
-  { name: 'model',     aliases: ['m'],           description: 'Switch active model — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
   { name: 'local',     aliases: ['ll'],         description: 'Local OpenAI-compatible LLM — ping / models / test / use', subcommands: ['ping', 'models', 'test', 'use', 'status'] },
   { name: 'session',   aliases: ['sess'],       description: 'Session resume — list / load / sync / new (handoff from mobile)', subcommands: ['list', 'load', 'sync', 'new'] },
-  { name: 'resume',    aliases: [],             description: 'Pick a past session, or load one by id prefix · /resume <id-prefix>' },
   { name: 'fork',      aliases: [],             description: 'Copy this session into a new one' },
   { name: 'rewind',    aliases: [],             description: 'Rewind — 과거 user 턴 픽커로 되감기 (원본 보존 · 새 세션 분기 · /rewind <n> 숏컷)' },
   // TUI 부활 C-a (2026-07-12): autopilot 미션 TUI 표면 — CLI 동등 단일 창구 소비.
@@ -454,12 +460,8 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'sync',  aliases: ['s'],         description: 'Enter sync mode' },
   { name: 'plugin', aliases: ['plugins'], description: 'Manage plugins', subcommands: ['list', 'activate', 'deactivate', 'reload'] },
   { name: 'widget', aliases: ['widgets'], description: 'Manage widgets', subcommands: ['list', 'reload', 'instances'] },
-  { name: 'clear', aliases: ['cls'],       description: 'Clear chat log' },
   { name: 'log',   aliases: [],             description: 'Chat Log controls — size / clear / filter / search / freeze / solo / turn / fold / help', subcommands: ['size', 'clear', 'filter', 'search', 'freeze', 'solo', 'turn', 'fold', 'help'] },
-  { name: 'help',  aliases: ['?'],         description: 'Show help overlay' },
-  { name: 'setup', aliases: [], description: 'Onboarding wizard guide — /setup (anchor) · /setup reset (re-run wizard on next boot)', subcommands: ['help', 'reset'] },
   { name: 'memory', aliases: ['mem'], description: 'Memory ops — list / show / search / add / delete (see `elanous memory --help`)', subcommands: ['list', 'show', 'search', 'add', 'delete', 'index'] },
-  { name: 'status', aliases: ['st'], description: 'Print the claude-code-style status pills (working dir + git + model)' },
   { name: 'export', aliases: [], description: 'Export this conversation transcript to a markdown file — /export [path] (default ~/temp/elanous-transcript-<stamp>.md)' },
   { name: 'delta', aliases: ['diffs'], description: 'Source delta browser — open the latest turn-scoped file diff popup', subcommands: ['open', 'help'] },
   { name: 'theme', aliases: [], description: 'Theme controls — list / switch / use / reset / preview / export', subcommands: ['list', 'switch', 'use', 'reset', 'preview', 'export'] },
@@ -486,7 +488,6 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'acp',    aliases: [], description: 'ACP chat — stream claude-code / codex / gemini replies into the chat pane (not a VW spawn). /acp codex points at the canonical codex app-server path; /acp cas is a synonym.', subcommands: ['claude', 'codex', 'gemini', 'cas', 'cancel', 'status', 'drop'] },
   { name: 'conv', aliases: [], description: 'Conversation widget/popup host — /conv list · /conv open <session-id> · /conv layout <cascade|tile|stack> · /conv focus <next|prev>.', subcommands: ['list', 'ls', 'open', 'layout', 'focus'] },
   { name: 'handoff', aliases: [], description: 'H5 P3 cross-agent context handoff: /handoff <from_session_id> <to_brand> [--channels r,p,m] [--prompt "prefix"]. Takes source session snapshot (filtered by channels if observer present) and launches target via adapter registry. Brands: codex · claude · claude-code · gemini · elanous.' },
-  { name: 'remaining', aliases: [], description: 'What each account has left' },
   { name: 'agent-room', aliases: [], description: 'H6 P4 VW agent-room — /agent-room <N> <brands...> · /agent-room list · /agent-room close <id> · N ∈ {2,3,4} · brands: codex/claude/gemini/elanous/auto/lll:<m>', subcommands: ['list', 'close', 'preset', 'help'] },
   { name: 'showroom', aliases: ['sr'], description: 'Showroom v2 multi-LLM lane composer — /showroom (default 2-pane) · /showroom <lane1> <lane2> [<lane3> [<lane4>]] · lane = role:provider[:transport] · roles plan/build/exec/review/reflect · pair with /lane and /relay for cross-lane handoffs.', subcommands: ['help'] },
   { name: 'reply',   aliases: [], description: 'H6 P5 AgentReply — /reply <target-session-id> <message...> · send message to a live session, capture the response · flags: --from · --channels r,m · --idle-ms · --timeout-ms', subcommands: ['help'] },
@@ -503,7 +504,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'qc',      aliases: [],          description: 'Quick-control — arm one-shot control mode; next message runs as control, then auto-return to chat.' },
   { name: 'voice-chat', aliases: ['vc'], description: 'Continuous voice chat mode — speak, elanous replies in voice (Phase 4-5). Subcommands: start / stop / cancel / status. Chord: Alt+R toggles enter/exit anywhere.', subcommands: ['start', 'stop', 'cancel', 'status'] },
   { name: 'auto-tts', aliases: ['tts', 'autotts'], description: 'Auto-TTS for chat responses (Phase 2) — speaks LLM replies sentence-by-sentence. Subcommands: on / off / toggle / status.', subcommands: ['on', 'off', 'toggle', 'status'] },
-  { name: 'quit',  aliases: ['q', 'exit'], description: 'Exit application' },
+  { name: 'directive', aliases: [], description: '(운영) 지시를 Linear 이슈로 기록' },
 ];
 
 /** Every user-visible slash spelling, normalized for runtime-catalog comparison. */
@@ -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/op-proxy-sync.ts

@@ -0,0 +1,83 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ACP_TOKEN_FILE } from '../auth/token-store.js';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { userConfigPath } from '../user-config.js';
+
+export interface OpProxyConfig {
+  host: string;
+  bearerFile: string;
+  restart: string;
+}
+
+/** Read the optional, unnormalized nexus setting from the same config file as the CLI. */
+export function readOpProxyConfig(path = userConfigPath()): OpProxyConfig | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8')) as { nexus?: { opProxy?: OpProxyConfig } };
+    return raw?.nexus?.opProxy;
+  } catch {
+    return undefined;
+  }
+}
+
+type SshExecutor = (argv: string[], input: string) => { status: number | null; error?: Error };
+
+export function finishOpProxyRotation(
+  proxy: OpProxyConfig | undefined,
+  token: string,
+  opts: { sync: boolean; ssh?: SshExecutor; tokenFile?: string; out?: (line: string) => void },
+): boolean | undefined {
+  if (!proxy) return undefined;
+  if (!opts.sync) {
+    (opts.out ?? console.log)('op 프록시 토큰도 갈아야 합니다 — `elanous token rotate --sync-op-proxy`');
+    return undefined;
+  }
+  return syncOpProxyToken(proxy, token, opts);
+}
+
+const executeSsh: SshExecutor = (argv, input) => {
+  const result = spawnSync('ssh', argv, { input, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 30_000 });
+  return { status: result.status, ...(result.error ? { error: result.error } : {}) };
+};
+
+const shellQuote = (value: string): string => `'${value.replaceAll("'", "'\\''")}'`;
+
+/** Never interpolate the token in a command, diagnostic, or log. Only SSH stdin carries it. */
+export function syncOpProxyToken(
+  proxy: OpProxyConfig | undefined,
+  token: string,
+  opts: { ssh?: SshExecutor; tokenFile?: string; out?: (line: string) => void } = {},
+): boolean | undefined {
+  if (!proxy) return undefined;
+  const out = opts.out ?? console.log;
+  const host = typeof proxy.host === 'string' ? proxy.host : '';
+  const file = typeof proxy.bearerFile === 'string' ? proxy.bearerFile : '';
+  const service = typeof proxy.restart === 'string' ? proxy.restart : '';
+  const valid = /^[\w][\w.-]*$/.test(host) && file.startsWith('/') && !/[\r\n\0]/.test(file)
+    && /^[\w@][\w@.-]*$/.test(service) && !/[\r\n\0]/.test(opts.tokenFile ?? '');
+  const remote = `sudo install -m 600 /dev/stdin ${shellQuote(file)} && sudo systemctl restart ${shellQuote(service)}`;
+  const manual = valid
+    ? `token=$(head -n 1 < ${shellQuote(opts.tokenFile ?? join(getElanousConfigDir(), ACP_TOKEN_FILE))}) && [ -n "$token" ] && printf 'ELANOUS_OP_BEARER=%s\\n' "$token" | ssh ${shellQuote(host)} ${shellQuote(remote)}`
+    : 'nexus.opProxy 의 host, bearerFile, restart 를 확인한 뒤 bearer 파일을 갱신하고 서비스를 재시작하세요';
+  let reason = '';
+  if (!valid) {
+    reason = 'nexus.opProxy 설정 오류';
+  } else {
+    try {
+      const result = (opts.ssh ?? executeSsh)([host, remote], `ELANOUS_OP_BEARER=${token}\n`);
+      if (result.status === 0 && !result.error) {
+        debug.log('auth.op-proxy-sync', 'synced', { host, reason: 'ok' });
+        out(`op 프록시 토큰을 바꿨습니다(${host})`);
+        return true;
+      }
+      reason = result.error ? 'ssh 실행 실패' : `ssh 종료 코드 ${result.status ?? '미상'}`;
+    } catch {
+      reason = 'ssh 실행 실패';
+    }
+  }
+  debug.log('auth.op-proxy-sync', 'failed', { host, reason });
+  out(`op 프록시 토큰 동기화 실패(${host}): ${reason} — 직접: ${manual}`);
+  return false;
+}

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호스트][:상한] 쉼표')