elanous 0.2.11 → 0.2.13

package/src/autopilot/pty-control-loop.ts

@@ -88,7 +88,7 @@ export type ControlDecision =
   | { readonly action: 'handoff'; readonly to: 'codex' | 'claude' | 'elanous'; readonly mission: string; readonly carry?: 'diff' | 'summary' }
   | { readonly action: 'ask-human'; readonly reason: string; readonly url?: string; readonly code?: string }
   /** `no-progress` reports observed lack of progress without claiming completion. */
-  | { readonly action: 'no-progress'; readonly reason: string };
+  | { readonly action: 'no-progress'; readonly reason: string; readonly terminal?: boolean };
 
 export interface RunSupervisor {
   /** run supervisor의 관측 → 다음 행동. 동기/비동기 모두 허용(LLM 은 async). `signal` 이 abort 되면(사람 takeover
@@ -664,6 +664,9 @@ export async function runPtyControlLoop(
           previousIntervention = { ...intervention, sameScreenCount: 1 };
         }
       } else if (decision.action === 'wait' || decision.action === 'no-progress') {
+        if (decision.action === 'no-progress' && decision.terminal) {
+          return finish({ kind: 'stuck', iteration: step, reason: decision.reason }, step, intervention, true);
+        }
         // wait/no-progress — 종료된 자식은 새 출력을 낼 수 없으므로 대기 없이 즉시 수렴한다.
         if (deps.isAlive?.() === false) {
           debug.log('autopilot.control', 'child-exited', { step });

package/src/autopilot/track-agent-shadow.ts

@@ -2,6 +2,7 @@ import { execFile } from 'node:child_process';
 import { appendFileSync, mkdirSync, readFileSync, rmdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { TrackAgentDecision, TrackAgentInput, TrackAgentResult } from './track-agent.js';
 
@@ -127,7 +128,7 @@ export async function launchTrackAgentShadow(input: TrackAgentInput, options: Sh
       const instanceRoot = effectiveInstanceRoot();
       const { stdout } = await exec('bun', ['bin/elanous.mjs', '--config-dir', instanceRoot, ...values], {
         cwd: process.env.ELANOUS_TOOL_CWD?.trim() || resolve(import.meta.dir, '../..'),
-        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot },
+        env: { ...process.env, ELANOUS_STATE_DIR: instanceRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(instanceRoot) },
         encoding: 'utf8', maxBuffer: 1024 * 1024,
       });
       return { stdout };

package/src/autopilot/track-agent.ts

@@ -2,6 +2,7 @@ import { execFile, spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { getOrCreatePersonaSession } from '../session/index.js';
 import { getUserConfig } from '../user-config.js';
@@ -38,7 +39,9 @@ const log = (event: string, data: Record<string, unknown>) => {
 };
 /** The daemon's own universe, resolved once and pinned on the child (config ⊕ state) — the harness isolates its own workers. */
 export function universeLaunch(args: readonly string[], root: string = effectiveInstanceRoot()): { argv: string[]; env: NodeJS.ProcessEnv } {
-  return { argv: ['bin/elanous.mjs', '--config-dir', root, ...args], env: { ...process.env, ELANOUS_STATE_DIR: root } };
+  return { argv: ['bin/elanous.mjs', '--config-dir', root, ...args], env: {
+    ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root),
+  } };
 }
 const runCli = async (args: string[]): Promise<{ stdout: string }> => {
   const { argv, env } = universeLaunch(args);

package/src/boot/daemon-prompt-request.ts

@@ -38,6 +38,7 @@ export interface DaemonPromptBody {
    *  (`none` · `readonly` · `chat` · `webterm`); invalid values reject
    *  the request rather than silently falling back. */
   tools?: DaemonToolSurfaceKind;
+  personaId?: string;
 }
 
 export interface DaemonPromptRequest {
@@ -53,6 +54,7 @@ export interface DaemonPromptRequest {
    *  not opt in; the caller-side (`handlePromptStreamPost`) interprets
    *  null as "use the daemon's boot-time surface". */
   tools: DaemonToolSurfaceKind | null;
+  personaId?: string;
 }
 
 export type DaemonPromptRequestParseResult =
@@ -117,6 +119,7 @@ export function parseDaemonPromptBody(
         body.source ? writeInputSourceMeta(body.source) : undefined,
       ),
       tools: body.tools ?? null,
+      ...(typeof body.personaId === 'string' && body.personaId.trim() ? { personaId: body.personaId } : {}),
     },
   };
 }

package/src/boot/daemon-prompt-turn.ts

@@ -10,7 +10,7 @@ import {
   appendUserPromptBlocksAndBuildMessages,
 } from './daemon-history-helper.js';
 import type { ContentBlock as AcpContentBlock } from '@agentclientprotocol/sdk';
-import type { DaemonSessionHistory } from './daemon-runtime.js';
+import { personaPromptForChat, type DaemonSessionHistory } from './daemon-runtime.js';
 import type { DaemonPromptRequest } from './daemon-prompt-request.js';
 import type { DaemonToolSurface } from './daemon-tools/types.js';
 import type { ConfirmChannel } from '../hitl/confirm.js';
@@ -199,8 +199,9 @@ export async function runDaemonPromptTurn(opts: {
   // …" + active terminals) to the system prompt so the LLM has the
   // session id + terminal ids without an extra discovery call. Helper
   // returns the original prompt unchanged when there's nothing to add.
+  const personaPrompt = await personaPromptForChat(request.personaId);
   const augmentedSystemPrompt = appendWebtermContext(
-    request.effectiveSystemPrompt,
+    personaPrompt ? [personaPrompt, request.effectiveSystemPrompt].filter(Boolean).join('\n\n') : request.effectiveSystemPrompt,
     request.sessionId,
     activeToolSurface,
   );
@@ -291,6 +292,9 @@ export async function runDaemonPromptTurn(opts: {
   if (!isFirstTurn && opts.projectInstructions) {
     messages.unshift({ role: 'system', content: opts.projectInstructions });
   }
+  if (!isFirstTurn && personaPrompt) {
+    messages.unshift({ role: 'system', content: personaPrompt });
+  }
   const result = await runCoreTurn({
     sessionId: request.sessionId,
     userText: request.userText,

package/src/boot/daemon-runtime.ts

@@ -55,6 +55,33 @@ import { elanousSelfAccessPrompt } from '../agent/self-ambient.js';
 import { createToolCwdResolver, type ToolCwdResolver } from './tool-cwd.js';
 import { resolveSessionProjectContext } from '../project/session-context.js';
 import { debug } from '../debug/log.js';
+import { resolvePersonaAddress } from '../intake-plane/persona-answer.js';
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../persona/global-registry.js';
+
+const turnPersonaPrompt = new AsyncLocalStorage<string | undefined>();
+
+export function withChatPersonaPrompt<T>(prompt: string | undefined, run: () => T): T {
+  return turnPersonaPrompt.run(prompt, run);
+}
+
+export function prependChatPersonaOnLaterTurn(
+  messages: LLMMessage[], isFirstTurn: boolean,
+): LLMMessage[] {
+  const prompt = turnPersonaPrompt.getStore();
+  if (!isFirstTurn && prompt) messages.unshift({ role: 'system', content: prompt });
+  return messages;
+}
+
+export async function personaPromptForChat(
+  id: unknown,
+  deps: { load: () => Promise<unknown>; registry: () => Parameters<typeof resolvePersonaAddress>[1] } = {
+    load: awaitGlobalPersonaLoad, registry: getGlobalPersonaRegistry,
+  },
+): Promise<string | undefined> {
+  if (typeof id !== 'string' || !id.trim()) return undefined;
+  await deps.load();
+  return resolvePersonaAddress(id, deps.registry())?.systemPrompt;
+}
 
 /** C4 (2026-07-12) — arm the non-detached-PTY kill ONCE per turn signal.
  *  Multiple tool calls in one turn share the same AbortSignal instance;
@@ -135,7 +162,7 @@ export function composeDaemonSystemPrompt(
   promptMeta: Readonly<Record<string, unknown>> | undefined,
   sessionId?: string,
 ): string {
-  return [basePrompt, buildDaemonInputSourceLine(promptMeta), elanousSelfAccessPrompt(sessionId)]
+  return [turnPersonaPrompt.getStore(), basePrompt, buildDaemonInputSourceLine(promptMeta), elanousSelfAccessPrompt(sessionId)]
     .filter((part): part is string => typeof part === 'string' && part.trim().length > 0)
     .join('\n\n');
 }
@@ -604,12 +631,11 @@ export function createDaemonRunTurn(
       const hasNonTextBlock = !!promptBlocks?.some(
         (b) => (b as { type?: string }).type !== 'text',
       );
-      if (hasNonTextBlock) {
-        return appendUserPromptBlocksAndBuildMessages(
-          history, sessionId, promptBlocks!, systemPrompt,
-        );
-      }
-      return appendUserAndBuildMessages(history, sessionId, userText, systemPrompt);
+      const isFirstTurn = history.get(sessionId).length === 0;
+      const messages = hasNonTextBlock
+        ? appendUserPromptBlocksAndBuildMessages(history, sessionId, promptBlocks!, systemPrompt)
+        : appendUserAndBuildMessages(history, sessionId, userText, systemPrompt);
+      return prependChatPersonaOnLaterTurn(messages, isFirstTurn);
     },
     getTools: () => surface.specs,
     dispatchTool: terminalCapableDispatch(surfaceHasPtyShell, async (name, args, ctx) => {
@@ -723,15 +749,21 @@ export function createDaemonRunTurn(
         });
         debugBridge.activate();
       }
-      const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
-      if (projectCwd || opts.acpSessionCwd) {
-        // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
-        const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
-        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
-        await turnToolCwd.run(resolver, () => inner(turnCtx));
-      } else {
-        await inner(turnCtx);
-      }
+      const elanousMeta = turnCtx.promptMeta?.elanous;
+      const personaId = elanousMeta && typeof elanousMeta === 'object' && !Array.isArray(elanousMeta)
+        && 'pwaPersonaId' in elanousMeta ? elanousMeta.pwaPersonaId : undefined;
+      const personaPrompt = await personaPromptForChat(personaId);
+      await withChatPersonaPrompt(personaPrompt, async () => {
+        const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
+        if (projectCwd || opts.acpSessionCwd) {
+          // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
+          const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
+          const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
+          await turnToolCwd.run(resolver, () => inner(turnCtx));
+        } else {
+          await inner(turnCtx);
+        }
+      });
     } finally {
       debugBridge?.dispose();
     }

package/src/chat/index.ts

@@ -438,6 +438,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
   { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
   { name: 'now', aliases: [], description: '현재 맥락과 출처 표 — /now [주제]' },
+  { name: 'wish', aliases: [], description: '소원을 카드로 남기기 — /wish <소원 한 줄>' },
   { name: 'remaining', aliases: [], description: '계정별 남은 사용량' },
   { name: 'setup', aliases: [], description: '상세 설정 — /setup · /setup reset(다음 실행 때 마법사 다시)', subcommands: ['help', 'reset'] },
   { name: 'quit',  aliases: ['q', 'exit'], description: '나가기' },

package/src/cli/decisions-cli.ts

@@ -1,4 +1,10 @@
-import type { Command } from 'commander';
+import { Option, type Command } from 'commander';
+import { hqCliWriteAllowed, type HqDeps } from '../hq/hq.js';
+import { fileLeaseStore } from '../hq/lease.js';
+import { join } from 'node:path';
+import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig } from '../user-config.js';
 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';
 
@@ -46,13 +52,19 @@ export function formatDecisionDetail(e: DecisionEntry): string {
     ...(e.refs?.length ? [`참조: ${e.refs.join(' · ')}`] : [])].join('\n');
 }
 
-export function registerDecisionsCommands(program: Command, config: DecisionLedgerOptions = {}, out: Pick<Console, 'log'> = console): void {
-  const root = program.command('decisions').description('대표 결정 원장 · 로컬 전용');
+export function registerDecisionsCommands(program: Command, config: DecisionLedgerOptions = {}, out: Pick<Console, 'log'> = console, hqDeps: HqDeps = {}): void {
+  const noXcheck = new Option('--no-xcheck <이유>', '교차 확인 생략 이유');
+  // This flag takes a reason, not Commander's negated boolean default.
+  noXcheck.negate = false;
+  const root = program.command('decisions').description('대표 결정 원장 · 로컬 전용').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
+  const mayWrite = (command: string, override?: boolean) => hqCliWriteAllowed(`decisions ${command}`, Boolean(override || root.opts().hqOverride),
+    (getElanousConfigDirOverride() || config.stateDir) && !hqDeps.store && !getUserConfig().hq?.arbiter ? { ...hqDeps, store: fileLeaseStore(join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'lease.json')), seenPath: join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'seen-generation'), localPath: join(config.stateDir ?? effectiveInstanceRoot(), 'hq', 'local.json') } : hqDeps);
   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 }) => {
+    .option('--dry-run').option('--json').option('--hq-override')
+    .action(async (o: { dryRun?: boolean; json?: boolean; hqOverride?: boolean }) => {
+      if (!o.dryRun && !mayWrite('linear-sync', o.hqOverride)) return;
       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')}` : ''}`);
     });
@@ -61,21 +73,36 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     .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('--xcheck <SEAT:메모>', '교차 확인 (반복)', repeat, [] as string[])
+    .addOption(noXcheck)
+    .option('--alternative <key>').option('--dissent <text>')
     .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; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean }) => fail(() => {
+    .option('--json').option('--hq-override')
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; xcheck: string[]; noXcheck?: string; alternative?: string; dissent?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean; hqOverride?: boolean }) => fail(() => {
       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);
+      if (o.xcheck.length && o.noXcheck !== undefined) throw new Error('choose --xcheck or --no-xcheck, not both');
+      const crossCheck = o.xcheck.map(raw => {
+        const match = /^([^:\s]+):(.+)$/.exec(raw);
+        if (!match || !match[2]!.trim()) throw new Error(`invalid --xcheck: ${raw} (expected SEAT:메모)`);
+        return { seat: match[1]!, at: new Date().toISOString(), note: match[2]!.trim() };
+      });
+      if (!crossCheck.length && o.noXcheck === undefined && getUserConfig().decisions?.requireCrossCheck) throw new Error('교차 확인 없음 — --xcheck SEAT:메모 또는 --no-xcheck 이유');
+      const who = agent(o.agent);
+      if (!mayWrite('raise', o.hqOverride)) return;
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
+        ...(crossCheck.length ? { crossCheck } : { crossCheckSkipped: o.noXcheck ?? 'missing' }),
+        ...(o.alternative !== undefined ? { alternative: o.alternative } : {}), ...(o.dissent !== undefined ? { dissent: o.dissent } : {}),
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },
-        raisedBy: { agent: agent(o.agent), ...(o.track ? { track: o.track } : {}), ...(o.session ? { session: o.session } : {}) }, ...(o.ref.length ? { refs: o.ref } : {}),
+        raisedBy: { agent: who, ...(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) } : {}) });
+      if (entry.crossCheckSkipped === 'missing') console.error('교차 확인 없음 — --xcheck SEAT:메모 또는 --no-xcheck 이유');
       emit(entry, o.json, `올림: ${formatDecisionRow(entry)}`);
     }));
   root.command('list').description('결정 목록 (기본 열린 것)')
@@ -88,11 +115,12 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
   root.command('show <id>').description('SCQA · 선택지 · 권고 · 이력 · 판').option('--json')
     .action((id: string, o: { json?: boolean }) => fail(() => { const entry = new DecisionLedger(config).show(id); emit(entry, o.json, formatDecisionDetail(entry)); }));
   root.command('decide <id> <option>').description('사람 또는 AUTO 위임 결정 기록')
-    .option('--note <text>').option('--auto').option('--delegation <reason>').option('--track <track>').option('--agent <agent>').option('--json')
-    .action((id: string, choice: string, o: { note?: string; auto?: boolean; delegation?: string; track?: DecisionTrack; agent?: string; json?: boolean }) => fail(() => {
+    .option('--note <text>').option('--auto').option('--delegation <reason>').option('--track <track>').option('--agent <agent>').option('--json').option('--hq-override')
+    .action((id: string, choice: string, o: { note?: string; auto?: boolean; delegation?: string; track?: DecisionTrack; agent?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
       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 };
+      if (!mayWrite('decide', o.hqOverride)) return;
       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».
@@ -103,22 +131,26 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       }
       emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
     }));
-  root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json')
-    .action((id: string, o: { json?: boolean }) => fail(() => {
+  root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json').option('--hq-override')
+    .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('retry-answer', o.hqOverride)) return;
       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[])
-    .option('--agent <agent>').option('--json')
-    .action((id: string, o: { option: string[]; agent?: string; json?: boolean }) => fail(() => {
-      const entry = new DecisionLedger(config).addOptions(id, o.option.map(parseOption), agent(o.agent));
+    .option('--agent <agent>').option('--json').option('--hq-override')
+    .action((id: string, o: { option: string[]; agent?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      const who = agent(o.agent);
+      if (!mayWrite('add-options', o.hqOverride)) return;
+      const entry = new DecisionLedger(config).addOptions(id, o.option.map(parseOption), who);
       emit(entry, o.json, formatDecisionDetail(entry));
     }));
-  root.command('withdraw <id>').description('결정 철회도 원장에 남긴다').requiredOption('--reason <reason>').option('--json')
-    .action((id: string, o: { reason: string; json?: boolean }) => fail(() => { const entry = new DecisionLedger(config).withdraw(id, o.reason); emit(entry, o.json, `철회: ${formatDecisionDetail(entry)}`); }));
-  root.command('import-markdown <file>').description('기존 대표 결정 문서 씨앗을 가져온다 (재실행 안전)').option('--json')
-    .action((file: string, o: { json?: boolean }) => fail(() => {
+  root.command('withdraw <id>').description('결정 철회도 원장에 남긴다').requiredOption('--reason <reason>').option('--json').option('--hq-override')
+    .action((id: string, o: { reason: string; json?: boolean; hqOverride?: boolean }) => fail(() => { if (!mayWrite('withdraw', o.hqOverride)) return; const entry = new DecisionLedger(config).withdraw(id, o.reason); emit(entry, o.json, `철회: ${formatDecisionDetail(entry)}`); }));
+  root.command('import-markdown <file>').description('기존 대표 결정 문서 씨앗을 가져온다 (재실행 안전)').option('--json').option('--hq-override')
+    .action((file: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('import-markdown', o.hqOverride)) return;
       const result = importDecisionMarkdown(new DecisionLedger(config), file);
       emit(result, o.json, `가져옴 ${result.imported.length} · 기존 ${result.existing.length} · 불완전 ${result.incomplete.length} · 못 읽음 ${result.unread.length}${result.incomplete.length ? `\n${result.incomplete.join('\n')}` : ''}${result.unread.length ? `\n${result.unread.join('\n')}` : ''}`);
       if (result.unread.length) process.exitCode = 1;

package/src/cli/outputs-cli.ts

@@ -0,0 +1,92 @@
+import { accessSync, constants, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import type { OutputEntry } from '../outputs/ledger.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+type ListOptions = { since?: string; source?: string; limit?: string; json?: boolean };
+
+function sinceIso(value: string): string {
+  if (value === '24h' || value === '7d') {
+    return new Date(Date.now() - (value === '24h' ? 24 : 7 * 24) * 60 * 60 * 1000).toISOString();
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
+    || !Number.isFinite(Date.parse(value))
+    || new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) !== value.slice(0, 10)) {
+    throw new Error(`invalid --since: ${value} (ISO|24h|7d)`);
+  }
+  return new Date(value).toISOString();
+}
+
+// listOutputs intentionally tolerates unreadable months. Detect inaccessible ledger files here so the CLI
+// does not report an incomplete read as a genuine zero (including when run as root under chmod 000).
+function assertReadableLedger(root: string): void {
+  const dir = join(root, 'outputs');
+  let names: string[];
+  try {
+    const info = statSync(dir);
+    if (!info.isDirectory() || (info.mode & 0o444) === 0 || (info.mode & 0o111) === 0) {
+      throw new Error(`outputs ledger directory unreadable: ${dir}`);
+    }
+    accessSync(dir, constants.R_OK | constants.X_OK);
+    names = readdirSync(dir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+    throw error;
+  }
+  for (const name of names.filter(name => /^outputs-\d{4}-(0[1-9]|1[0-2])\.jsonl$/.test(name) || name === 'outputs.jsonl')) {
+    const file = join(dir, name);
+    const info = statSync(file);
+    if (!info.isFile() || (info.mode & 0o444) === 0) throw new Error(`outputs ledger file unreadable: ${file}`);
+    accessSync(file, constants.R_OK);
+  }
+}
+
+export function registerOutputsCommands(program: Command): void {
+  program.command('outputs').description('산출물 원장 조회 (읽기 전용)')
+    .command('list').description('산출물 최신순 목록과 종류별 수')
+    .option('--since <ISO|24h|7d>', '이 시각 이후')
+    .option('--source <source>', 'exec|field-reel|field-feed')
+    .option('--limit <N>', '최대 건수 (기본 50)', '50')
+    .option('--json', 'JSON 출력')
+    .action(async (options: ListOptions) => {
+      try {
+        if (options.source !== undefined && !['exec', 'field-reel', 'field-feed'].includes(options.source)) {
+          throw new Error(`invalid --source: ${options.source} (exec|field-reel|field-feed)`);
+        }
+        if (!options.limit || !/^[1-9]\d*$/.test(options.limit) || !Number.isSafeInteger(Number(options.limit))) {
+          throw new Error(`invalid --limit: ${options.limit}`);
+        }
+        const scope = {
+          since: options.since === undefined ? undefined : sinceIso(options.since),
+          source: options.source as OutputEntry['source'] | undefined,
+          limit: Number(options.limit),
+        };
+        const displayedScope = { since: scope.since ?? null, source: scope.source ?? null, limit: scope.limit };
+        const root = effectiveInstanceRoot();
+        assertReadableLedger(root);
+        const { listOutputs } = await import('../outputs/ledger.js');
+        const items = listOutputs(scope, root);
+        const byKind: Record<string, number> = {};
+        for (const item of items) byKind[item.kind] = (byKind[item.kind] ?? 0) + 1;
+        debug.log('outputs.cli', 'list', { count: items.length, source: scope.source, since: scope.since });
+        if (options.json) {
+          await writeStdoutJson(`${JSON.stringify({ items, count: items.length, byKind, scope: displayedScope })}\n`);
+          return;
+        }
+        for (const item of items) {
+          const at = Number.isFinite(Date.parse(item.at))
+            ? new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'medium', hourCycle: 'h23' }).format(new Date(item.at))
+            : item.at;
+          console.log(`${at} KST · ${item.kind} · ${item.title} · ${item.source}/${item.sourceId} · ${item.seat ?? '—'} · ${item.path ?? item.url ?? '—'}`);
+        }
+        if (!items.length) console.log(`scope: ${JSON.stringify(displayedScope)}`);
+        console.log(`${items.length}개 · 종류별 수 ${JSON.stringify(byKind)}`);
+      } catch (error) {
+        console.error(`outputs list: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/cli/persona-cli.ts

@@ -7,8 +7,10 @@ import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { parsePersonaYaml } from '../persona/loader.js';
 import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
-import { choosePersonaId, clonePreset, describePreset, editPersona, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
+import { UnknownPersonaSchemaKeyError, choosePersonaId, clonePreset, describePreset, editPersona, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
 import { addTeamSet, listTeamSets, removeTeamSet } from '../persona/team-set.js';
+import { validateTeamFile } from '../persona/team.js';
+import { runPersonaLoopOnce } from '../seat-loop/seat-loop.js';
 
 interface StoredPersona { personaId: string; displayName: string; description?: string; preset?: string; title?: string; path: string }
 
@@ -43,11 +45,11 @@ function mapping(value: unknown): value is Record<string, unknown> {
 
 function setEdit(edits: Record<string, unknown>, assignment: string): void {
   const equals = assignment.indexOf('=');
-  if (equals < 1) throw new Error(`--set requires key=value: ${assignment}`);
+  if (equals < 0) throw new Error(`--set requires key=value: ${assignment}`);
   const key = assignment.slice(0, equals);
   const parts = key.split('.');
   if (parts.some((part) => !part || ['__proto__', 'prototype', 'constructor'].includes(part))) {
-    throw new Error(`invalid --set key: ${key}`);
+    throw new UnknownPersonaSchemaKeyError(key);
   }
   const value: unknown = parseYaml(assignment.slice(equals + 1));
   let target = edits;
@@ -68,6 +70,18 @@ function editOptions(fromFile: string | undefined, assignments: readonly string[
 }
 
 export function registerPersonaCommands(program: Command): void {
+  program.command('team').description('Validate a YAML team definition')
+    .command('validate <file>').description('Check team schema, persona references and handoff order')
+    .action((file: string) => {
+      try {
+        const definition = validateTeamFile(file);
+        console.log(`Valid team ${definition.name}`);
+      } catch (error) {
+        console.error(error instanceof Error ? error.message.replace(/\s+/g, ' ').trim() : String(error));
+        process.exitCode = 2;
+      }
+    });
+
   const team = program.command('team-set').description('Install, remove and list persona team sets');
   team.command('add <file>').description('Install a YAML team set').action((file: string) => {
     try { const result = addTeamSet(file); console.log(`Installed team-set ${result['team-set']}`); }
@@ -94,7 +108,7 @@ export function registerPersonaCommands(program: Command): void {
       if (opts.json) { console.log(JSON.stringify({ presets: presets.map((p) => ({ id: p.personaId, displayName: p.displayName, role: p.role, oneLine: p.oneLine })), mine }, null, 2)); return; }
       if (!presets.length) console.log('페르소나 프리셋을 찾지 못했습니다(persona-presets/ 가 이 설치본에 없습니다).');
       else {
-        console.log('프리셋 — 골라서 내 페르소나로 만들기: elanous persona add <프리셋> [--name <이름>]');
+        console.log('프리셋 — 골라서 내 페르소나로 만들기: elanous persona add <이름> [--from <프리셋>]');
         const width = Math.max(...presets.map((p) => p.personaId.length));
         for (const p of presets) console.log(`  ${p.personaId.padEnd(width)}  ${p.displayName} — ${p.role} · ${p.oneLine}`);
       }
@@ -105,24 +119,27 @@ export function registerPersonaCommands(program: Command): void {
       }
     });
 
-  persona.command('add <preset>')
-    .description('Make your own persona from a preset (id, name or role) — the preset file is not changed')
+  persona.command('add <name>')
+    .description('Make your own persona from a preset — the preset file is not changed')
+    .option('--from <preset>', 'Preset to clone (defaults to the named preset)')
     .option('--name <name>', 'What to call it (default: the preset’s first name)')
     .option('--as <name>', 'Clone this preset under a new, unique name')
     .option('--title <title>', 'Optional title, e.g. CMO')
     .option('--json', 'JSON output')
-    .action((query: string, opts: { name?: string; as?: string; title?: string; json?: boolean }) => {
+    .action((query: string, opts: { from?: string; name?: string; as?: string; title?: string; json?: boolean }) => {
       const presets = loadPresets();
-      const preset = findPreset(presets, query);
+      const presetQuery = opts.from ?? query;
+      const preset = findPreset(presets, presetQuery);
       if (!preset) {
-        console.error(`프리셋 «${query}» 을 찾지 못했습니다. 있는 것: ${presets.map((p) => p.personaId).join(', ')}`);
+        console.error(`프리셋 «${presetQuery}» 을 찾지 못했습니다. 있는 것: ${presets.map((p) => p.personaId).join(', ')}`);
         process.exitCode = 1;
         return;
       }
-      if (opts.as !== undefined) {
+      if (opts.as !== undefined || opts.from !== undefined) {
         try {
-          if (opts.name !== undefined || opts.title !== undefined) throw new Error('--as cannot be combined with --name or --title');
-          const result = clonePreset(preset, opts.as);
+          if (opts.from !== undefined && (opts.as !== undefined || opts.name !== undefined || opts.title !== undefined)) throw new Error('--from cannot be combined with --as, --name or --title');
+          if (opts.as !== undefined && (opts.name !== undefined || opts.title !== undefined)) throw new Error('--as cannot be combined with --name or --title');
+          const result = clonePreset(preset, opts.from !== undefined ? query : opts.as!);
           debug.log('persona.cli', 'cloned', { preset: preset.personaId, personaId: result.personaId });
           if (opts.json) console.log(JSON.stringify({ personaId: result.personaId, displayName: result.displayName, preset: preset.personaId, path: result.path }, null, 2));
           else {
@@ -170,7 +187,22 @@ export function registerPersonaCommands(program: Command): void {
           console.log(`  파일: ${result.path}`);
         }
       } catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
+        console.error(err instanceof Error ? err.message.replace(/\s+/g, ' ').trim() : String(err));
+        process.exitCode = err instanceof UnknownPersonaSchemaKeyError ? 2 : 1;
+      }
+    });
+
+  persona.command('loop <name>')
+    .description('Shadow-pick one todo for a saved persona without executing it')
+    .requiredOption('--once', 'Pick exactly one todo')
+    .option('--json', 'JSON output')
+    .action(async (name: string, opts: { json?: boolean }) => {
+      try {
+        const entry = await runPersonaLoopOnce(name);
+        if (opts.json) console.log(JSON.stringify(entry));
+        else console.log(entry.todo ? `그림자 선택 — ${entry.todo.title} (${entry.todo.id})` : '할 일 없음');
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
         process.exitCode = 1;
       }
     });

package/src/cli/pod-cli.ts

@@ -3,11 +3,13 @@
 
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
+import { readPodMemoryAdvice } from './pod-memory-advice.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 { parsePodPool, resolvePodPoolSpec, podPoolHostLease, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl, measurePoolLease, probePoolDns, recommendConcurrency, type PoolLeaseMeasure, type PoolDnsProbe } 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';
+import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js';
 
 export interface PodCliIo {
   log: (line: string) => void;
@@ -24,6 +26,7 @@ export interface PodCliDeps {
   perAccount?: () => number;
   poolSpec?: (explicit?: string) => string | null;
   harnessPool?: () => string | undefined;
+  memoryAdvice?: (logsDb?: string) => ReturnType<typeof readPodMemoryAdvice>;
 }
 
 const HELP = `elanous pod run [--pool <스펙>] [--skill <이름,…>] [--llm grok] [--clone] [--deadline <초>] -- <명령…>
@@ -38,6 +41,21 @@ 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('memory').description('실측 기반 Pod 메모리 권고 (읽기 전용)')
+    .command('advise').description('골 종류별 standard 16Gi / high 32Gi 권고와 근거')
+    .option('--json', '권고와 측정 근거를 JSON 으로')
+    .option('--logs-db <path>', '기존 logs.db 경로')
+    .action((opts: { json?: boolean; logsDb?: string }) => {
+      try {
+        const advice = (deps.memoryAdvice ?? readPodMemoryAdvice)(opts.logsDb);
+        if (opts.json) io.log(JSON.stringify(advice));
+        else for (const row of advice.byGoalType) io.log(`${row.goalType}: ${row.recommended} ${row.limit} · ${row.reason}`);
+        io.exit(0);
+      } catch (err) {
+        io.error(err instanceof Error ? err.message : String(err));
+        io.exit(1);
+      }
+    });
   pod.command('lease').description('Pod 풀 동시 실행 권장 (DNS 점검용 Pod 를 잠깐 만들었다 지움)')
     .command('status').description('지금 추가로 쏠 수 있는 Pod 골과 제한 근거')
     .option('--pool <spec>', '풀 스펙 — 컨텍스트[@ssh호스트][:상한][#레지스트리:포트] 쉼표')
@@ -61,8 +79,13 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         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, unleasedRunning: decision.unleasedRunning, recommended: decision.recommended, limitedBy: decision.limitedBy });
+        const records = members.length ? podPoolHostLease(members).live() : [];
+        const host = hostLeaseCounts(records);
+        // Pending Pods and Job-only reservations are disjoint; a lease for an already Pending Job is the same Job.
+        const waitingJobs = decision.pending === null ? null : decision.pending +
+          records.filter((r) => r.stage === 'job' && !leaseHasPendingPod(r, decision.pendingJobs ?? [])).length;
+        const result = { pool: spec, ...measure, accounts, perAccount, ...decision, reserved: host.reserved, waitingJobs };
+        debug.log('pod.lease', 'status', { pool: spec ? members.map((m) => ({ capacity: m.capacity })) : null, running: decision.running, pending: decision.pending, reserved: host.reserved, waitingJobs, unleasedRunning: decision.unleasedRunning, recommended: decision.recommended, limitedBy: decision.limitedBy });
         if (opts.json) io.log(JSON.stringify(result));
         else {
           io.log(`풀: ${(spec ?? context) || '?'}`);
@@ -72,6 +95,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
             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(`예약(저작 중) ${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 ?? '?'}; 권장 수에서 건강한 멤버의 임대 없는 실행 차감)`);
           io.log(`memory: ${decision.memorySlots ?? '?'} 칸 (할당 가능 − Running 하니스 상한 합; 골당 16Gi · 모든 네임스페이스의 노드별 기존 예약을 반영해 배치 가능 ${decision.placeableSlots ?? '?'} 칸)`);